Spring5

一、Spring 框架概述

  1. Spring 是轻量级的开源的 JavaEE 框架

  2. Spring 可以解决企业应用开发的复杂性

  3. Spring 有两个核心部分：IOC 和 Aop

    • IOC：控制反转，把创建对象过程交给 Spring 进行管理
    • Aop：面向切面，不修改源代码进行功能增强

  4. Spring 特点

    • 方便解耦，简化开发
    • Aop 编程支持
    • 方便程序测试
    • 方便和其他框架进行整合
    • 方便进行事务操作
    • 降低 API 开发难度

==Spring5 入门案例==

jar包地址:https://repo.spring.io/release/org/springframework/spring/

创建普通类，在这个类创建普通方法

1
2
3
4
5
public class User {
     public void add() {
     		System.out.println("add......");
     }
}

创建 Spring 配置文件，在配置文件配置创建的对象 

1
2
3
4
5
6
7
8
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd">
 <!--配置 User 对象创建--> 
 	<bean id="user" class="com.atguigu.spring5.User"></bean>
</beans>

进行测试代码编写

1
2
3
4
5
6
7
8
9
10
@Test
public void testAdd() {
 //1 加载 spring 配置文件
     ApplicationContext context =
     new ClassPathXmlApplicationContext("bean1.xml");
     //2 获取配置创建的对象
     User user = context.getBean("user", User.class);
     System.out.println(user);
     user.add();
}

二、IOC 容器

2.1 IOC 底层原理

IOC简介

  1. 控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理
  2. 使用 IOC 目的：为了耦合度降低
  3. 做入门案例就是 IOC 实现

IOC 底层原理：xml 解析、工厂模式、反射

降低耦合

图1

IOC进一步降低耦合

image-20221222203659098

2.2 IOC 接口(BeanFactory)

  1. OC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂

  2. Spring 提供 IOC 容器实现两种方式：（两个接口）

    • BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用* 加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
    • ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用* 加载配置文件时候就会把在配置文件对象进行创建

  3. ApplicationContext 接口有实现类

    image-20221222203918532

2.3 IOC操作Bean管理(xml)

Bean 管理指的是两个操作

  • Spring 创建对象
  • Spirng 注入属性

有两种方式实现:

  • xml
  • 注解

image-20221223145412560

  1. 在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建

  2. 在 bean 标签有很多属性，介绍常用的属性

    id 属性：唯一标识

    class 属性：类全路径（包类路径）

  3. 创建对象时候，默认也是执行无参数构造方法完成对象创建

① set 方法进行注入

1
2
3
4
5
6
7
8
9
10
11
12
public class Book {
    //创建属性
     private String bname;
     private String bauthor;
     //创建属性对应的 set 方法
     public void setBname(String bname) {
     	this.bname = bname;
     }
     public void setBauthor(String bauthor) {
     	this.bauthor = bauthor;
     }
}
1
2
3
4
5
6
7
8
9
<!--2 set 方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book">
     <!--使用 property 完成属性注入
     name：类里面属性名称
     value：向属性注入的值
     -->
     <property name="bname" value="易筋经"></property>
     <property name="bauthor" value="达摩老祖"></property>
</bean>

② 用有参数构造进行注入

1
2
3
4
5
6
7
8
9
10
public class Orders {
     //属性
     private String oname;
     private String address;
     //有参数构造
     public Orders(String oname,String address) {
     	this.oname = oname;
     	this.address = address;
     }
}
1
2
3
4
<bean id="orders" class="com.atguigu.spring5.Orders">
     <constructor-arg name="oname" value="电脑"></constructor-arg>
     <constructor-arg name="address" value="China"></constructor-arg>
</bean>

③ p 名称空间注入

第一步 添加 p 名称空间在配置文件中

image-20221223150412362

1
2
3
<!--2 set 方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" 
p:bauthor="无名氏"></bean>

④ xml 注入其他类型属性

null 值

1
2
3
<property name="address">
 	<null/>
</property>

属性值包含特殊符号

1
2
3
4
5
6
7
<!--属性值包含特殊符号
 1 把<>进行转义 &lt; &gt;
 2 把带特殊符号内容写到 CDATA
-->
<property name="address">
 	<value><![CDATA[<<南京>>]]></value>
</property>

注入属性-外部 bean

  1. 创建两个类 service 类和 dao 类
  2. 在 service 调用 dao 里面的方法
  3. 在 spring 配置文件中进行配置
1
2
3
4
5
6
7
8
9
10
11
public class UserService {
     //创建 UserDao 类型属性，生成 set 方法
     private UserDao userDao;
     public void setUserDao(UserDao userDao) {
    	 this.userDao = userDao;
     }
     public void add() {
     	System.out.println("service add...............");
     	userDao.update();
     }
}
1
2
3
4
5
6
7
8
9
<!--1 service 和 dao 对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
 <!--注入 userDao 对象
 name 属性：类里面属性名称
 ref 属性：创建 userDao 对象 bean 标签 id 值
 -->
 <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

注入属性-内部 bean

  1. 一对多关系：部门和员工,一个部门有多个员工，一个员工属于一个部门,部门是一，员工是多

  2. 在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//部门类
public class Dept {
     private String dname;
     public void setDname(String dname) {
    	 this.dname = dname;
     }
}
//员工类
public class Emp {
     private String ename;
     private String gender;
     //员工属于某一个部门，使用对象形式表示
     private Dept dept;
     public void setDept(Dept dept) {
     	this.dept = dept;
     }
     public void setEname(String ename) {
     	this.ename = ename;
     }
     public void setGender(String gender) {
     	this.gender = gender;
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
<!--内部 bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
     <!--设置两个普通属性-->
     <property name="ename" value="lucy"></property>
     <property name="gender" value="女"></property>
     <!--设置对象类型属性-->
     <property name="dept">
     	<bean id="dept" class="com.atguigu.spring5.bean.Dept">
     		<property name="dname" value="安保部"></property>
     	</bean>
     </property>
</bean>

注入属性-级联赋值

（1）第一种写法 

1
2
3
4
5
6
7
8
9
10
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
     <!--设置两个普通属性-->
     <property name="ename" value="lucy"></property>
     <property name="gender" value="女"></property>
     <!--级联赋值-->
     <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
     <property name="dname" value="财务部"></property>
</bean>

（2）第二种写法

image-20221223152128052

1
2
3
4
5
6
7
8
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
     <!--设置两个普通属性-->
     <property name="ename" value="lucy"></property>
     <property name="gender" value="女"></property>
     <!--级联赋值-->
     <property name="dept" ref="dept"></property>
     <property name="dept.dname" value="技术部"></property>
</bean>

xml 注入集合属性

1、注入数组类型属性
2、注入 List 集合类型属性
3、注入 Map 集合类型属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Stu {
     //1 数组类型属性
     private String[] courses;
     //2 list 集合类型属性
     private List<String> list;
     //3 map 集合类型属性
     private Map<String,String> maps;
     //4 set 集合类型属性
     private Set<String> sets;
     public void setSets(Set<String> sets) {
     	this.sets = sets;
     }
     public void setCourses(String[] courses) {
    	 this.courses = courses;
     }
     public void setList(List<String> list) {
     	this.list = list;
     }
     public void setMaps(Map<String, String> maps) {
    	 this.maps = maps;
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<!--1 集合类型属性注入-->
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
     <!--数组类型属性注入-->
     <property name="courses">
         <array>
             <value>java 课程</value>
             <value>数据库课程</value>
         </array>
     </property>
     <!--list 类型属性注入-->
     <property name="list">
         <list>
             <value>张三</value>
             <value>小三</value>
         </list>
     </property>
     <!--map 类型属性注入-->
     <property name="maps">
   		  <map>
             <entry key="JAVA" value="java"></entry>
             <entry key="PHP" value="php"></entry>
         </map>
     </property>
     <!--set 类型属性注入-->
     <property name="sets">
         <set>
             <value>MySQL</value>
             <value>Redis</value>
         </set>
     </property>
</bean>

在集合里面设置对象类型值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!--创建多个 course 对象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
 	<property name="cname" value="Spring5 框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
     <property name="cname" value="MyBatis 框架"></property>
</bean>
<!--注入 list 集合类型，值是对象-->
<bean>
    <property name="courseList">
         <list>
             <ref bean="course1"></ref>
             <ref bean="course2"></ref>
         </list>
    </property>
</bean>

把集合注入部分提取出来

==提取公共部分==

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:util="http://www.springframework.org/schema/util"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/util 
http://www.springframework.org/schema/util/spring-util.xsd">
1
2
3
4
5
6
7
8
9
10
<!--1 提取 list 集合类型属性注入-->
<util:list id="bookList">
     <value>易筋经</value>
     <value>九阴真经</value>
     <value>九阳神功</value>
</util:list>
<!--2 提取 list 集合类型属性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
 	<property name="list" ref="bookList"></property>
</bean>

2.4 Bean管理其他知识

① 工厂Bean

Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

  • 普通 bean：在配置文件中定义 bean 类型就是返回类型
  • 工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样

第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean

第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyBean implements FactoryBean<Course> {
     //定义返回 bean
     @Override
     public Course getObject() throws Exception {
     	 Course course = new Course();
     	 course.setCname("abc");
    	 return course;
     }
     @Override
     public Class<?> getObjectType() {
     	return null;
     }
     @Override
     public boolean isSingleton() {
    	 return false;
     }
}
1
<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>
1
2
3
4
5
6
7
@Test
public void test3() {
     ApplicationContext context =
     new ClassPathXmlApplicationContext("bean3.xml");
     Course course = context.getBean("myBean", Course.class);
     System.out.println(course);
}

② bean 作用域

==在 Spring 里面，默认情况下，bean 是单实例对象==

image-20221223160340863

scope 属性值

第一个值 默认值，singleton，表示是单实例对象

第二个值 prototype，表示是多实例对象

image-20221223160431628

③ bean 生命周期

  1. 通过构造器创建 bean 实例（无参数构造）
  2. 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
  3. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
  4. bean 可以使用了（对象获取到了）
  5. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Orders {
     //无参数构造
     public Orders() {
    	 System.out.println("第一步 执行无参数构造创建 bean 实例");
     }
     private String oname;
     public void setOname(String oname) {
     this.oname = oname;
    	 System.out.println("第二步 调用 set 方法设置属性值");
     }
     //创建执行的初始化的方法
     public void initMethod() {
     	System.out.println("第三步 执行初始化的方法");
     }
     //创建执行的销毁的方法
     public void destroyMethod() {
     	System.out.println("第五步 执行销毁的方法");
     }
}
1
2
3
<bean id="orders" class="com.atguigu.spring5.bean.Orders" initmethod="initMethod" destroy-method="destroyMethod">
 <property name="oname" value="手机"></property>
</bean>

bean 的后置处理器，bean 生命周期有七步

  1. 通过构造器创建 bean 实例（无参数构造）
  2. 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
  3. 把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
  4. 调用 bean 的初始化的方法（需要进行配置初始化的方法）
  5. 把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
  6. bean 可以使用了（对象获取到了）
  7. 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
（1）创建类，实现接口 BeanPostProcessor，创建后置处理器
public class MyBeanPost implements BeanPostProcessor {
     @Override
     public Object postProcessBeforeInitialization(Object bean, String beanName) 
    throws BeansException {
     	System.out.println("在初始化之前执行的方法");
     	return bean;
     }
     @Override
     public Object postProcessAfterInitialization(Object bean, String beanName) 
    throws BeansException {
     	System.out.println("在初始化之后执行的方法");
     	return bean;
     }
}

④ xml 自动装配

自动装配：根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

（1）根据属性名称自动注入

1
2
3
4
5
6
7
8
<!--实现自动装配
 bean 标签属性 autowire，配置自动装配
 autowire 属性常用两个值：
 byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
 byType 根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

（2）根据属性类型自动注入

1
2
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

⑤ 外部属性文件

1.引入Durid(JAR包)

1
2
3
4
5
6
7
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
 <property name="url" 
value="jdbc:mysql://localhost:3306/userDb"></property>
 <property name="username" value="root"></property>
 <property name="password" value="root"></property>
</bean>

2.引入外部属性文件配置数据库连接池

image-20221223162640353

把外部 properties 属性文件引入到 spring 配置文件中 引入 context 名称空间

1
2
3
4
5
6
7
8
9
10
11
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:p="http://www.springframework.org/schema/p" 
 xmlns:util="http://www.springframework.org/schema/util" 
 xmlns:context="http://www.springframework.org/schema/context" 
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd 
 http://www.springframework.org/schema/util 
http://www.springframework.org/schema/util/spring-util.xsd 
 http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd">

image-20221223162714773

1
2
3
4
5
6
7
8
9
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="${prop.driverClass}"></property>
 <property name="url" value="${prop.url}"></property>
 <property name="username" value="${prop.userName}"></property>
 <property name="password" value="${prop.password}"></property>
</bean>

2.5 操作Bean管理(注解)

  1. @Component
  2. @Service
  3. @Controller
  4. @Repository

上面四个注解功能是一样的，都可以用来创建 bean 实例

image-20221223172627751

第二步 开启组件扫描

1
2
3
4
5
<!--开启组件扫描
 1 如果扫描多个包，多个包使用逗号隔开
 2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>

第三步 创建类，在类上面添加创建对象注解

1
2
3
4
5
6
7
8
9
//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
     public void add() {
     	System.out.println("service add.......");
     }
}

开启组件扫描细节配置

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
 <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

基于注解方式实现属性注入

==@Autowired==：根据属性类型进行自动装配

  1. 创建 service 和 dao 对象，在 service 和 dao 类添加创建对象注解
  2. 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解
1
2
3
4
5
6
7
8
9
10
11
12
@Service
public class UserService {
     //定义 dao 类型属性
     //不需要添加 set 方法
     //添加注入属性注解
 	 @Autowired 
 	 private UserDao userDao;
     public void add() {
         System.out.println("service add.......");
         userDao.add();
     }
}

==@Qualifier==：根据名称进行注入 这个@Qualifier 注解的使用，和上面@Autowired 一起使用

1
2
3
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

image-20221223174607458

==@Resource==：可以根据类型注入，可以根据名称注入

1
2
3
//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

==@Value==：注入普通类型属性

1
2
@Value(value = "abc")
private String name;

完全注解开发

（1）创建配置类，替代 xml 配置文件

1
2
3
4
@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
}

（2）编写测试类

1
2
3
4
5
6
7
8
@Test
public void testService2() {
 //加载配置类
     ApplicationContext context= new AnnotationConfigApplicationContext(SpringConfig.class);
     UserService userService = context.getBean("userService", UserService.class);
     System.out.println(userService);
     userService.add();
}

三、Aop

  1. 面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
  2. 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
  3. 使用登录例子说明 AOP

image-20221223185401792

3.1 AOP 底层原理

有两种情况动态代理

  • 第一种 有接口情况，使用 JDK 动态代理

    image-20221223191708035

  • 没有接口情况，使用 CGLIB 动态代理

    image-20221223191725340

3.2 JDK 动态代理

使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象，调用 newProxyInstance 方法

方法有三个参数：

第一参数，类加载器

第二参数，增强方法所在的类，这个类实现的接口，支持多个接口

第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

1
2
3
4
public interface UserDao {
     public int add(int a,int b);
     public String update(String id);
}
1
2
3
4
5
6
7
8
9
10
public class UserDaoImpl implements UserDao {
     @Override
     public int add(int a, int b) {
     	return a+b;
     }
     @Override
     public String update(String id) {
    	 return id;
     }
}

使用 Proxy 类创建接口代理对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class JDKProxy {
     public static void main(String[] args) {
         //创建接口实现类代理对象
         Class[] interfaces = {UserDao.class};
         UserDaoImpl userDao = new UserDaoImpl();
         UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, 
        new UserDaoProxy(userDao));
         int result = dao.add(1, 2);
         System.out.println("result:"+result);
     }
}


//创建代理对象代码
class UserDaoProxy implements InvocationHandler {
     //1 把创建的是谁的代理对象，把谁传递过来
     //有参数构造传递
     private Object obj;
     public UserDaoProxy(Object obj) {
     	this.obj = obj;
     }
     //增强的逻辑
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         //方法之前
         System.out.println("方法之前执行...."+method.getName()+" :传递的参=数..."+ Arrays.toString(args));
         //被增强的方法执行
         Object res = method.invoke(obj, args);
         //方法之后
         System.out.println("方法之后执行...."+obj);
         return res;
       }
 }

3.3 AOP术语

连接点：类中哪些方法可以被增强，称为连接点(四个方法都能被增强)

切入点：实际被增强的方法称为切入点(但我只增强Add方法)

通知：实际被增强的部分(通知的类型如下)

  • 前置通知：前面增强
  • 后置通知：后面增强
  • 环绕通知：前后增强
  • 异常通知：异常时通知
  • 最终通知：一定会通知(finally)

切面：动作，把通知应用到切入点

image-20221224202740880

3.4 AspectJ

Spring 框架一般都是基于 AspectJ 实现 AOP 操作

AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作

基于 AspectJ 实现 AOP 操作

  • 基于 xml 配置文件实现
  • 基于注解方式实现（使用）

引入依赖

切入点表达式：知道对哪个类里面的哪个方法进行增强

1
2
3
4
5
6
7
8
语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

举例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强
execution(* com.atguigu.dao.BookDao.add(..))
举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
execution(* com.atguigu.dao.BookDao.* (..))
举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
execution(* com.atguigu.dao.*.* (..))

1、创建类，在类里面定义方法

1
2
3
4
5
public class User {
     public void add() {
     	System.out.println("add.......");
     }
}

2、创建增强类（编写增强逻辑）

1
2
3
4
5
6
7
在增强类里面，创建方法，让不同方法代表不同通知类型
//增强的类
public class UserProxy {
     public void before() {//前置通知
     	System.out.println("before......");
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns:context="http://www.springframework.org/schema/context" 
 xmlns:aop="http://www.springframework.org/schema/aop" 
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd 
 http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd 
 http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop.xsd">
 <!-- 开启注解扫描 -->
 <context:component-scan basepackage="com.atguigu.spring5.aopanno"></context:component-scan>

image-20221224204414951

在增强类上面添加注解 @Aspect

1
2
3
4
@Component
@Aspect //生成代理对象
public class UserProxy {
}
1
2
3
spring 配置文件中开启生成代理对象
<!-- 开启 Aspect 生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

配置不同类型的通知在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
     //前置通知
     //@Before 注解表示作为前置通知
     @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
     public void before() {
     	System.out.println("before.........");
     }
     //后置通知（返回通知）
     @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
     public void afterReturning() {
     	System.out.println("afterReturning.........");
     }
     //最终通知
     @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
     public void after() {
     	System.out.println("after.........");
     }
     //异常通知
     @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
     public void afterThrowing() {
     	System.out.println("afterThrowing.........");
     }
     //环绕通知
     @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
     public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
     	System.out.println("环绕之前.........");
         //被增强的方法执行
         proceedingJoinPoint.proceed();
         System.out.println("环绕之后.........");
     }
}

相同的切入点抽取

1
2
3
4
5
6
7
8
9
10
//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
   public void pointdemo() {
   }
   //前置通知
   //@Before 注解表示作为前置通知
   @Before(value = "pointdemo()")
   public void before() {
       System.out.println("before.........");
   }

有多个增强类多同一个方法进行增强，设置增强类优先级

1
2
3
4
5
在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy

==完全使用注解开发== 创建配置类，不需要创建 xml 配置文件

1
2
3
4
5
@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

xml方式：

  1. 创建两个类，增强类和被增强类，创建方法

  2. 在 spring 配置文件中创建两个类对象

    1
    2
    3
    <!--创建对象-->
    <bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

  3. 在 spring 配置文件中配置切入点

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <!--配置 aop 增强-->
    <aop:config>
         <!--切入点-->
         <aop:pointcut id="p" expression="execution(* 
        com.atguigu.spring5.aopxml.Book.buy(..))"/>
         <!--配置切面-->
         <aop:aspect ref="bookProxy">
         <!--增强作用在具体的方法上-->
             <aop:before method="before" pointcut-ref="p"/>
         </aop:aspect>
    </aop:config>

四、JdbcTemplate

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

image-20221225162605356

1
2
3
4
5
6
7
<!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
     <property name="url" value="jdbc:mysql:///user_db" />
     <property name="username" value="root" />
     <property name="password" value="root" />
     <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

配置 JdbcTemplate 对象，注入 DataSource

1
2
3
4
5
<!-- JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <!--注入 dataSource-->
 <property name="dataSource" ref="dataSource"></property>
</bean>

创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象

1
2
<!-- 组件扫描 -->
<context:component-scan base-package="com.atguigu"></context:component-scan>
1
2
3
4
5
6
@Service
public class BookService {
     //注入 dao
     @Autowired
     private BookDao bookDao;
}
1
2
3
4
5
6
@Repository
public class BookDaoImpl implements BookDao {
     //注入 JdbcTemplate
     @Autowired
     private JdbcTemplate jdbcTemplate;
}

对应数据库创建实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Repository
public class BookDaoImpl implements BookDao {
     //注入 JdbcTemplate
     @Autowired
     private JdbcTemplate jdbcTemplate;
     //添加的方法
     @Override
     public void add(Book book) {
         //1 创建 sql 语句
         String sql = "insert into t_book values(?,?,?)";
         //2 调用方法实现
         Object[] args = {book.getUserId(), book.getUsername(),  book.getUstatus()};
         int update = jdbcTemplate.update(sql,args);
         System.out.println(update);
     }
}

查询返回某个值

⚫ 有两个参数

⚫ 第一个参数：sql 语句

⚫ 第二个参数：返回类型 Class

1
2
3
4
5
6
7
//查询表记录数
@Override
public int selectCount() {
     String sql = "select count(*) from t_book";
     Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
     return count;
}

查询返回对象

⚫ 有三个参数

⚫ 第一个参数：sql 语句

⚫ 第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装

⚫ 第三个参数：sql 语句值

1
2
3
4
5
6
7
@Override
public Book findBookInfo(String id) {
     String sql = "select * from t_book where user_id=?";
     //调用方法
     Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
     return book;
}
1
2
3
4
5
6
7
8
//查询返回集合
@Override
public List<Book> findAllBook() {
     String sql = "select * from t_book";
     //调用方法
     List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
     return bookList;
}

五、事务管理

事务四个特性（ACID）：原子性，一致性，隔离性，持久性

开启事务注解

1
2
<!--开启事务注解-->
<tx:annotation-driven transactionmanager="transactionManager"></tx:annotation-driven>
1
2
3
@Service
@Transactional
public class UserService

image-20221225163652101

propagation：事务传播行为当一个事务方法被另外一个事务方法调用时候，这个事务方法如何进行

image-20221225163731214

image-20221225171214269

image-20221225174258408

image-20221225174417238

image-20221225174428275

isolation：事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题
（2）有三个读问题：脏读、不可重复读、虚（幻）读

脏读：一个未提交事务读取到另一个未提交事务的数据

image-20221225173323424

不可重复读：一个未提交事务读取到另一提交事务修改数据

image-20221225173345013

虚读：一个未提交事务读取到另一提交事务添加数据

image-20221225173433266

image-20221225173451257

timeout：超时时间
（1）事务需要在一定时间内进行提交，如果不提交进行回滚
（2）默认值是 -1 ，设置时间以秒单位进行计算

readOnly：是否只读
（1）读：查询操作，写：添加修改删除操作
（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true，设置成 true 之后，只能查询

rollbackFor：回滚
（1）设置出现哪些异常进行事务回滚

noRollbackFor：不回滚
（1）设置出现哪些异常不进行事务回滚