Spring入门

一、Spring简介

1、Spring概述

官网地址：https://spring.io/

Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用Spring 框架来创建性能好、易于测试、可重用的代码。

Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。

Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。

Spring 框架的核心特性是可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO编程模型来促进良好的编程实践。

2、Spring家族

项目列表：https://spring.io/projects

3、Spring Framework

Spring 基础框架，可以视为 Spring 基础设施，基本上任何其他 Spring 项目都是以Spring Framework为基础的。

3.1、Spring Framework特性

• 非侵入式：使用 Spring Framework 开发应用程序时，Spring 对应用程序本身的结构影响非常小。对领域模型可以做到零污染；对功能性组件也只需要使用几个简单的注解进行标记，完全不会破坏原有结构，反而能将组件结构进一步简化。这就使得基于 Spring Framework 开发应用程序时结构清晰、简洁优雅。

• 控制反转：IOC——Inversion of Control，翻转资源获取方向。把自己创建资源、向环境索取资源变成环境将资源准备好，我们享受资源注入。

• 面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上增强代码功能。

• 容器：Spring IOC 是一个容器，因为它包含并且管理组件对象的生命周期。组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大的降低了使用门槛，大幅度提高了开发效率。

• 组件化：Spring 实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用 XML和 Java 注解组合这些对象。这使得我们可以基于一个个功能明确、边界清晰的组件有条不紊的搭建超大型复杂应用系统。

• 声明式：很多以前需要编写代码才能实现的功能，现在只需要声明需求即可由框架代为实现。

• 一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库。而且Spring 旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在 Spring Framework 的基础上全部使用 Spring 来实现。

3.2、Spring Framework五大功能模块

二、IOC

1、IOC容器

1.1、IOC思想

IOC：Inversion of Control，翻译过来是反转控制。

①获取资源的传统方式

自己做饭：买菜、洗菜、择菜、改刀、炒菜，全过程参与，费时费力，必须清楚了解资源创建整个过程中的全部细节且熟练掌握。

在应用程序中的组件需要获取资源时，传统的方式是组件主动的从容器中获取所需要的资源，在这样的模式下开发人员往往需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率。

②反转控制方式获取资源

点外卖：下单、等、吃，省时省力，不必关心资源创建过程的所有细节。

反转控制的思想完全颠覆了应用程序组件获取资源的传统方式：反转了资源的获取方向——改由容器主动的将资源推送给需要的组件，开发人员不需要知道容器是如何创建资源对象的，只需要提供接收资源的方式即可，极大的降低了学习成本，提高了开发的效率。这种行为也称为查找的被动形式。

③DI

DI：Dependency Injection，翻译过来是依赖注入。

DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器的资源注入。相对于IOC而言，这种表述更直接。

所以结论是：IOC 就是一种反转控制的思想， 而 DI 是对 IOC 的一种具体实现。

1.2、IOC容器在Spring中的实现

Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：

①BeanFactory

这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。

②ApplicationContext

BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用。ApplicationContext 而不是底层的 BeanFactory。

③ApplicationContext的主要实现类

2、基于XML管理bean

2.1、实验一：入门案例

①创建Maven Module

②引入依赖

<dependencies>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.0.2.RELEASEversion>
    dependency>
    
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
        <scope>testscope>
    dependency>
dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

③创建类HelloWorld

public class HelloWorld {
    public void sayHello() {
        System.out.println("hello,spring");
    }
}
1
2
3
4
5

④创建Spring的配置文件

applicationContext.xml

<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    
    <bean id="helloWorld" class="com.edu.pojo.HelloWorld" />
    
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

⑤创建测试类测试

public class HelloWorldTest {
    @Test
    public void test(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取IOC容器中的bean对象
        HelloWorld helloWorld = (HelloWorld) ioc.getBean("helloWorld");
        helloWorld.sayHello();
    }
}
1
2
3
4
5
6
7
8
9
10

⑥思路

⑦注意

Spring 底层默认通过反射技术调用组件类的无参构造器来创建组件对象，这一点需要注意。如果在需要无参构造器时，没有无参构造器，则会抛出异常。

2.2、实验二：获取bean

①方式一：根据bean的id获取

由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。

<bean id="studentOne" class="com.edu.pojo.Student"/>
1

@Test
public void testIOC() {
    //获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取IOC容器中的bean对象
    Student studentOne = (Student) ioc.getBean("studentOne");
    System.out.println(studentOne);
}
1
2
3
4
5
6
7
8

②方式二：根据bean的类型获取

<bean id="studentOne" class="com.edu.pojo.Student"/>
1

@Test
public void testIOC() {
    //获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取IOC容器中的bean对象
    Student studentOne = ioc.getBean(Student.class);
    System.out.println(studentOne);
}
1
2
3
4
5
6
7
8

③方式三：根据bean的id和类型获取

<bean id="studentOne" class="com.edu.pojo.Student"/>
1

@Test
public void testIOC() {
    //获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取IOC容器中的bean对象
    Student studentOne = ioc.getBean("studentOne", Student.class);
    System.out.println(studentOne);
}
1
2
3
4
5
6
7
8

④注意

根据类型获取bean时，要求IOC容器中有且只有一个类型匹配的bean

• 若没有任何一个类型匹配的bean，此时抛出异常：NoSuchBeanDefinitionException
• 若有多个类型匹配的bean，此时抛出异常：NoUniqueBeanDefinitionException

⑤扩展

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

可以，前提是bean唯一

如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？

不行，因为bean不唯一

⑥结论

根据类型来获取bean时，在满足bean唯一性的前提下

其实只是看：【对象instanceof指定的类型】的返回结果

只要返回结果是true就可以认定为和类型匹配，能够获取到

即通过bean类型，bean所继承的类的类型，bean所实现的接口的类型都可以获取bean

2.3、实验三：依赖注入之setter注入

①创建学生类Student

//使用lombok
@Data
public class Student {
    private Integer id;
    private String name;
    private Integer age;
    private String gender;
}
1
2
3
4
5
6
7
8

②配置bean时为属性赋值

<bean id="student" class="com.edu.pojo.Student">
    
    <property name="id" value="110"/>
    <property name="name" value="张三"/>
    <property name="age" value="22"/>
    <property name="gender" value="男"/>
bean>
1
2
3
4
5
6
7
8
9
10
11
12

③测试

@Test
public void testDI() {
    //获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取IOC容器中的bean对象
    Student studentOne = ioc.getBean("student", Student.class);
    System.out.println(student);
}
1
2
3
4
5
6
7
8

2.4、实验四：依赖注入之构造器注入

①在Student类中添加有参构造

public Student(Integer id, String name, Integer age, String gender) {
    this.id = id;
    this.name = name;
    this.age = age;
    this.gender = gender;
}
1
2
3
4
5
6

②配置bean

<bean id="student" class="com.edu.pojo.Student">
    
    <constructor-arg name="id" value="111"/>
    <constructor-arg name="name" value="李四"/>
    <constructor-arg name="age" value="22"/>
    <constructor-arg name="gender" value="男"/>
bean>
1
2
3
4
5
6
7
8
9
10
11
12

注意：

constructor-arg标签还有两个属性可以进一步描述构造器参数：

• index属性：指定参数所在位置的索引（从0开始）
• name属性：指定参数名

③测试

@Test
public void testDI() {
    //获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取IOC容器中的bean对象
    Student studentOne = ioc.getBean("student", Student.class);
    System.out.println(student);
}
1
2
3
4
5
6
7
8

2.5、实验五：特殊值处理

①字面量赋值

什么是字面量？

int a = 10;

声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a的时候，我们实际上拿到的值是10。而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<property name="name" value="张三"/>
1
2
3
4
5

②null值

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

注意：

<property name="name" value="null">property>
1

以上写法，为name所赋的值是字符串null

③xml实体

<property name="expression" value="a < b"/>
1
2
3
4
5
6
7

④CDATA节

<property name="expression">
    <value>value>
property>
1
2
3
4
5
6
7
8
9
10

2.6、实验六：为类类型属性赋值

①创建班级类Clazz

@Data
public class Clazz {
    private Integer cid;
    private String cname;
    private List<Student> students;
}
1
2
3
4
5
6

②修改Student类

在Student类中添加以下代码：

private Clazz clazz;
public Clazz getClazz() {
    return clazz;
}
public void setClazz(Clazz clazz) {
    this.clazz = clazz;
}
1
2
3
4
5
6
7

③方式一：引用外部已声明的bean

配置Clazz类型的bean：

<bean id="clazzOne" class="com.edu.pojo.Clazz">
    <property name="clazzId" value="1111">property>
    <property name="clazzName" value="老六班">property>
bean>
1
2
3
4

为Student中的clazz属性赋值：

<bean id="student" class="com.edu.pojo.Student">
    <property name="id" value="113"/>
    <property name="name" value="赵六"/>
    <property name="age" value="20"/>
    <property name="gender" value="男"/>

    
	<property name="clazz" ref="clazzOne"/>
bean>
1
2
3
4
5
6
7
8
9
10
11
12

④方式二：内部bean

<bean id="student" class="com.edu.pojo.Student">
    <property name="id" value="113"/>
    <property name="name" value="赵六"/>
    <property name="age" value="20"/>
    <property name="gender" value="男"/>

    
    <property name="clazz">
        <bean id="clazzInner" class="com.edu.pojo.Clazz">
            <property name="cid" value="333333"/>
            <property name="cname" value="老三班"/>
        bean>
    property>
bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

⑤方式三：级联属性赋值

<bean id="student" class="com.edu.pojo.Student">
    <property name="id" value="113"/>
    <property name="name" value="赵六"/>
    <property name="age" value="20"/>
    <property name="gender" value="男"/>

    <!--
        级联方式 需要提前为clazz属性赋值或者实例化
    -->
    <property name="clazz" ref="clazzOne"/>
    <property name="clazz.cid" value="2222"/>
    <property name="clazz.cname" value="老气班"/>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13

2.7、实验七：为数组类型属性赋值

①修改Student类

在Student类中添加以下代码：

private String[] hobbies;
public String[] getHobbies() {
    return hobbies;
}
public void setHobbies(String[] hobbies) {
    this.hobbies = hobbies;
}
1
2
3
4
5
6
7

②配置bean

<bean id="student" class="com.edu.pojo.Student">
    <property name="id" value="113"/>
    <property name="name" value="赵六"/>
    <property name="age" value="20"/>
    <property name="gender" value="男"/>

    
    <property name="hobbies">
        <array>
            <value>抽烟value>
            <value>喝酒value>
            <value>烫头value>
        array>
    property>
bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.8、实验八：为集合类型属性赋值

①为List集合类型属性赋值

在Clazz类中添加以下代码：

private List<Student> students;
public List<Student> getStudents() {
    return students;
}
public void setStudents(List<Student> students) {
    this.students = students;
}
1
2
3
4
5
6
7

配置bean：

<bean id="student" class="com.edu.pojo.Student">
    <property name="id" value="113"/>
    <property name="name" value="赵六"/>
    <property name="age" value="20"/>
    <property name="gender" value="男"/>

    
    <property name="students">
        <list>
            <ref bean="studentOne"/>
            <ref bean="studentTwo"/>
            <ref bean="studentThree"/>
        list>
    property>
bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

②为Map集合类型属性赋值

创建教师类Teacher：

@Data
public class Teacher {
    private Integer tid;
    private String tname;
}
1
2
3
4
5

在Student类中添加以下代码：

private Map<String, Teacher> teacherMap;
public Map<String, Teacher> getTeacherMap() {
    return teacherMap;
}
public void setTeacherMap(Map<String, Teacher> teacherMap) {
    this.teacherMap = teacherMap;
}
1
2
3
4
5
6
7

配置bean：

<bean id="teacherOne" class="com.edu.pojo.Teacher">
    <property name="tid" value="10000"/>
    <property name="tname" value="大宝"/>
bean>
<bean id="teacherTwo" class="com.edu.pojo.Teacher">
    <property name="tid" value="10001"/>
    <property name="tname" value="小宝"/>
bean>

<bean id="student" class="com.edu.pojo.Student">
    <property name="id" value="113"/>
    <property name="name" value="赵六"/>
    <property name="age" value="20"/>
    <property name="gender" value="男"/>
    
    <property name="teacherMap">
        <map>
            <entry key="10000" value-ref="teacherOne"/>
            <entry key="10001" value-ref="teacherTwo"/>
        map>
    property>
bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

③引用集合类型的bean

<util:list id="studentListUtil">
    <ref bean="studentOne"/>
    <ref bean="studentTwo"/>
    <ref bean="studentThree"/>
util:list>
<util:map id="teacherMapUtil">
    <entry key="10000" value-ref="teacherOne"/>
    <entry key="10001" value-ref="teacherTwo"/>
util:map>

<bean id="student" class="com.edu.pojo.Student">
    <property name="id" value="113"/>
    <property name="name" value="赵六"/>
    <property name="age" value="20"/>
    <property name="gender" value="男"/>

    <property name="students" ref="studentListUtil"/>
    <property name="teacherMap" ref="teacherMapUtil"/>
bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

使用util:list、util:map标签必须引入相应的命名空间，可以通过idea的提示功能选择

2.9、实验九：p命名空间

引入p命名空间后，可以通过以下方式为bean的各个属性赋值

<bean id="studentSix" class="com.edu.pojo.Student" p:id="115" p:name="jack"/>
1
2

2.10、实验十：引入外部属性文件

①加入依赖

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.47version>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.0.31version>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12

②创建外部属性文件

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_exercise
jdbc.username=root
jdbc.password=123456
1
2
3
4

③引入属性文件

<context:property-placeholder location="classpath:jdbc.properties"/>
1
2

④配置bean

<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
bean>
1
2
3
4
5
6

⑤测试

@Test
public void testDataSource() throws SQLException {
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-dataSource.xml");
    DruidDataSource dataSource = ioc.getBean(DruidDataSource.class);
    System.out.println(dataSource.getConnection());
}
1
2
3
4
5
6

2.11、实验十一：bean的作用域

①概念

在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

②创建类User

@Data
public class Student implements Person {
    private Integer id;
    private String name;
    private Integer age;
    private String gender;
}    
1
2
3
4
5
6
7

③配置bean

<bean id="student" class="com.edu.pojo.Student" scope="prototype">
    <property name="id" value="1001"/>
    <property name="name" value="张三"/>
bean>
1
2
3
4
5
6
7
8
9
10

④测试

@Test
public void testScope(){
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-scope.xml");
    Student student1 = ioc.getBean(Student.class);
    Student student2 = ioc.getBean(Student.class);

    System.out.println(student1==student2);
}
1
2
3
4
5
6
7
8

2.12、实验十二：bean的生命周期

①具体的生命周期过程

• bean对象创建（调用无参构造器）
• 给bean对象设置属性
• bean对象初始化之前操作（由bean的后置处理器负责）
• bean对象初始化（需在配置bean时指定初始化方法）
• bean对象初始化之后操作（由bean的后置处理器负责）
• bean对象就绪可以使用
• bean对象销毁（需在配置bean时指定销毁方法）
• IOC容器关闭

②修改类User

public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

    public User() {
        System.out.println("生命周期1：实例化");
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        System.out.println("生命周期2：依赖注入");
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void initMethod(){
        System.out.println("生命周期3：初始化");
    }

    public void destroyMethod(){
        System.out.println("生命周期4：销毁");
    }
}
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

注意其中的initMethod()和destroyMethod()，可以通过配置bean指定为初始化和销毁的方法

③配置bean

<bean id="user" class="com.edu.pojo.User" init-method="initMethod" destroy-method="destroyMethod">
    <property name="id" value="1"/>
    <property name="username" value="jack"/>
    <property name="password" value="123456"/>
    <property name="age" value="18"/>
bean>
1
2
3
4
5
6
7
8

④测试

@Test
public void test(){
    //ConfigurableApplicationContext是ApplicationContext的子接口，其中扩展了刷新和关闭容器的方法
    ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
    User user = ioc.getBean(User.class);
    System.out.println(user);
    ioc.close();
}
1
2
3
4
5
6
7
8

⑤bean的后置处理器

bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口，且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行

创建bean的后置处理器：

public class MyBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //此方法在bean的生命周期初始化之前执行
        System.out.println("MyBeanPostProcessor-->后置处理器postProcessBeforeInitialization");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //此方法在bean的生命周期初始化之后执行
        System.out.println("MyBeanPostProcessor-->后置处理器postProcessAfterInitialization");
        return bean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在IOC容器中配置后置处理器：

<bean id="myBeanPostProcessor" class="com.edu.process.MyBeanPostProcessor" />
1

⑥总结

1.实例化
2.依赖注入
3.后置处理器postProcessBeforeInitialization
4.初始化，需要通过bean的init-method属性指定初始化的方法
5.后置处理器postProcessAfterInitialization
6.IOC容器关闭时销毁，需要通过bean的destroy-method属性指定销毁的方法

bean的后置处理器会在生命周期的初始化前后添加额外的操作，
需要实现BeanPostProcessor接口且配置到IOC容器中，
需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行

注意：
    若bean的作用域为单例时，生命周期的前三个步骤会在获取IOC容器时执行
    若bean的作用域为多例时，生命周期的前三个步骤会在获取bean时执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.13、实验十三：FactoryBean

①简介

FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。

FactoryBean是一个接口，需要创建一个类实现该接口
其中有三个方法
    getObject()：通过一个对象交给IOC管理
    getObjectType()：设置所提供对象的类型
    isSingleton()：所提供的对象是否单例
当把FactoryBean的实现类配置为bean时，
会将当前类中的getObject()所返回的对象交给IOC容器管理
1
2
3
4
5
6
7

package org.springframework.beans.factory;
import org.springframework.lang.Nullable;

public interface FactoryBean<T> {

    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;
 
    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

②创建类UserFactoryBean

public class UserFactoryBean implements FactoryBean<User> {
    public User getObject() throws Exception {
        return new User();
    }

    public Class<?> getObjectType() {
        return User.class;
    }
}
1
2
3
4
5
6
7
8
9

③配置bean

<bean class="com.edu.factory.UserFactoryBean"/>
1

④测试

@Test
public void testFactory(){
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-factory.xml");
    User user = ioc.getBean(User.class);
    System.out.println(user);
}
1
2
3
4
5
6

2.14、实验十四：基于xml的自动装配

自动装配：根据指定的策略，在IOC容器中匹配某个bean，自动为bean中的类类型的属性或接口类型的属性赋值可以通过bean标签中的autowire属性设置自动装配的策略

自动装配：根据指定的策略，在IOC容器中匹配某个bean，自动为bean中的类类型的属性或接口类型的属性赋值可以通过bean标签中的autowire属性设置自动装配的策略

自动装配的策略：
1.no default：表示不装配，即bean中的属性不会自动匹配某个bean为属性赋值，此时属性使用默认值
2.byType：根据要赋值的属性的类型，在IOC容器中匹配某个bean，为属性赋值
   注意：
       a>若通过类型没有找到任何一个类型匹配的bean，此时不装配，属性适用默认值
       b>若通过类型找到多个类型匹配的bean，此时会抛出异常：NoUniqueBeanDefinitionException
   总结：当使用byType实现自动装配时，IOC容器中有且只有一个类型匹配的bean能够为属性赋值
3.byName：将要赋值的属性的属性名作为bean的id的IOC容器中匹配某个bean，为属性赋值
   总结：当类型匹配的bean有多个时，此时可以使用byName实现自动装配
1
2
3
4
5
6
7
8
9
10
11

①场景模拟

创建类UserController

public class UserController {
    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void saveUser(){
        userService.saveUser();
    }
}
1
2
3
4
5
6
7
8
9
10
11

创建接口UserService

public interface UserService {
    /**
     * 保存用户信息
     * */
    void saveUser();
}
1
2
3
4
5
6

创建类UserServiceImpl实现接口UserService

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void saveUser() {
        userDao.saveUser();
    }
}
1
2
3
4
5
6
7
8
9
10
11

创建接口UserDao

public interface UserDao {
    /**
     * 保存用户信息
     * */
    void saveUser();
}
1
2
3
4
5
6

创建类UserDaoImpl实现接口UserDao

public class UserDaoImpl implements UserDao {
    public void saveUser() {
        System.out.println("保存成功");
    }
}
1
2
3
4
5

②配置bean

使用bean标签的autowire属性设置自动装配效果

自动装配方式：byType

<bean class="com.edu.controller.UserController" id="userController" autowire="byType">
    
bean>

<bean class="com.edu.service.impl.UserServiceImpl" id="userService" autowire="byType">
    
bean>

<bean class="com.edu.dao.impl.UserDaoImpl" id="userDao">
1
2
3
4
5
6
7
8
9

③测试

@Test
public void testAutowire(){
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-autowire.xml");
    UserController userController = ioc.getBean(UserController.class);
    userController.saveUser();
}
1
2
3
4
5
6

3、基于注解管理bean

3.1、实验一：标记与扫描

①注解

和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。

本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。

②扫描

Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

③新建Maven Module

<dependencies>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.1version>
    dependency>
    
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
        <scope>testscope>
    dependency>
dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

④创建Spring配置文件

⑤标识组件的常用注解

@Component：将类标识为普通组件

@Controller：将类标识为控制层组件

@Service：将类标识为业务层组件

@Repository：将类标识为持久层组件

问：以上四个注解有什么关系和区别？

@Controller、@Service、@Repository这三个注解只是在@Component注解的基础上起了三个新的名字。对于Spring使用IOC容器管理这些组件来说没有区别。

所以@Controller、@Service、@Repository这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。

注意：虽然它们本质上一样，但是为了代码的可读性，为了程序结构严谨我们肯定不能随便胡乱标记。

⑥创建组件

创建控制层组件

@Controller("controller")
public class UserController {}
1
2

创建接口UserService

public interface UserService {}
1

创建业务层组件UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
    public void saveUser() {
        userDao.saveUser();
    }
}
1
2
3
4
5
6

创建接口UserDao

public interface UserDao {
    /**
     * 保存用户信息
     * */
    void saveUser();
}
1
2
3
4
5
6

创建持久层组件UserDaoImpl

@Repository
public class UserDaoImpl implements UserDao {
    public void saveUser() {
        System.out.println("保存成功");
    }
}
1
2
3
4
5
6

⑦扫描组件

情况一：最基本的扫描方式

<context:component-scan base-package="com.edu" />

<bean class="com.edu.service.impl.UserServiceImpl" id="userService"/>
<bean class="com.edu.dao.impl.UserDaoImpl" id="userDao"/>
1
2
3
4
5

情况二：指定要排除的组件

<context:component-scan base-package="com.edu" use-default-filters="true">
    
    
context:component-scan>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

情况三：仅扫描指定组件

<context:component-scan base-package="com.edu" use-default-filters="true">
    
    
context:component-scan>
1
2
3
4
5
6
7
8
9
10
11
12
13

⑧测试

@Test
public void test() {
    ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");

    UserController userController = ioc.getBean("controller",UserController.class);
    userController.saveUser();

    /*UserService userService = ioc.getBean("userService",UserService.class);
        System.out.println(userService);

        UserDao userDao = ioc.getBean("userDao",UserDao.class);
        System.out.println(userDao);*/
}
1
2
3
4
5
6
7
8
9
10
11
12
13

⑨组件所对应的bean的id

在我们使用XML方式管理bean的时候，每个bean都有一个唯一标识，便于在其他地方引用。现在使用

注解后，每个组件仍然应该有一个唯一标识。

默认情况

类名首字母小写就是bean的id。例如：UserController类对应的bean的id就是userController。

自定义bean的id可通过标识组件的注解的value属性设置自定义的bean的id

@Service(“userService”)//默认为userServiceImpl

public class UserServiceImpl implements UserService {}

3.2、实验二：基于注解的自动装配

①场景模拟

参考基于xml的自动装配

在UserController中声明UserService对象

在UserServiceImpl中声明UserDao对象

②@Autowired注解

在成员变量上直接标记@Autowired注解即可完成自动装配，不需要提供setXxx()方法。以后我们在项

目中的正式用法就是这样。

@Controller("controller")
public class UserController {
    @Autowired
    //@Qualifier("userController")
    private UserService userService;
    
    public void saveUser(){
        userService.saveUser();
    }
}

public interface UserService {
    void saveUser();
}

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;

    public void saveUser() {
        userDao.saveUser();
    }
}

public interface UserDao {
    /**
     * 保存用户信息
     * */
    void saveUser();
}

@Repository
public class UserDaoImpl implements UserDao {
    public void saveUser() {
        System.out.println("保存成功");
    }
}
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
35
36
37
38

③@Autowired注解其他细节

@Autowired注解可以标记在构造器和set方法上

@Controller
public class UserController {
    private UserService userService;
    @Autowired
    public UserController(UserService userService){
        this.userService = userService;
    }
    public void saveUser(){
        userService.saveUser();
    }
}

@Controller
public class UserController {
    private UserService userService;
    @Autowired
    public void setUserService(UserService userService){
        this.userService = userService;
    }
    public void saveUser(){
        userService.saveUser();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

④@Autowired工作流程

• 首先根据所需要的组件类型到IOC容器中查找
  • 能够找到唯一的bean：直接执行装配
  • 如果完全找不到匹配这个类型的bean：装配失败
  • 和所需类型匹配的bean不止一个
    • 没有@Qualifier注解：根据@Autowired标记位置成员变量的变量名作为bean的id进行匹配
    • 能够找到：执行装配
    • 找不到：装配失败
    • 使用@Qualifier注解：根据@Qualifier注解中指定的名称作为bean的id进行匹配
    • 能够找到：执行装配
    • 找不到：装配失败

@Controller
public class UserController {
    @Autowired
    @Qualifier("userServiceImpl")
    private UserService userService;
    public void saveUser(){
        userService.saveUser();
    }
}
1
2
3
4
5
6
7
8
9

@Autowired中有属性required，默认值为true，因此在自动装配无法找到相应的bean时，会装配失败，可以将属性required的值设置为true，则表示能装就装，装不上就不装，此时自动装配的属性为默认值，但是实际开发时，基本上所有需要装配组件的地方都是必须装配的，用不上这个属性。

三、AOP

1、场景模拟

1.1、声明接口

声明计算器接口Calculator，包含加减乘除的抽象方法

public interface Calculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}
1
2
3
4
5
6

1.2、创建实现类

@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}
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

1.3、创建带日志功能的实现类

public class CalculatorLogImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] add 方法结束了，结果是：" + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] sub 方法结束了，结果是：" + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] mul 方法结束了，结果是：" + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] div 方法结束了，结果是：" + result);
        return result;
    }
}
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

1.4、提出问题

①现有代码缺陷

针对带日志功能的实现类，我们发现有如下缺陷：

• 对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力
• 附加功能分散在各个业务功能方法中，不利于统一维护

②解决思路

解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

③困难

解决问题的困难：要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方式没法解决。所以需要引入新的技术。

2、代理模式

2.1、概念

①介绍

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

②生活中的代理

• 广告商找大明星拍广告需要经过经纪人
• 合作伙伴找大老板谈合作要约见面时间需要经过秘书
• 房产中介是买卖双方的代理

③相关术语

• 代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。
• 目标：被代理“套用”了非核心逻辑代码的类、对象、方法。

2.2、静态代理

创建静态代理类：

public class CalculatorStaticProxy implements Calculator {
    // 将被代理的目标对象声明为成员变量
    private Calculator target;

    public CalculatorStaticProxy(Calculator target) {
        this.target = target;
    }

    @Override
    public int add(int i, int j) {
        int result = 0;
        try {
            // 附加功能由代理类中的代理方法来实现
            System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
            // 通过目标对象来实现核心业务逻辑
            result = target.add(i, j);
            System.out.println("[日志] add 方法结束了，结果是：" + result);

        } catch (Exception e) {
            e.printStackTrace();

        } finally {

        }
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
        int result = target.sub(i, j);
        System.out.println("[日志] sub 方法结束了，结果是：" + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
        int result = target.mul(i, j);
        System.out.println("[日志] mul 方法结束了，结果是：" + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
        int result = target.div(i, j);
        System.out.println("[日志] div 方法结束了，结果是：" + result);
        return result;
    }
}
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。

提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。

2.3、动态代理

动态代理有两种：
1.jdk动态代理
  要求必须有接口
  最终生成的代理类和目标类实现相同的接口
  在com.sun.proxy包下，类名$proxy2
2.cglib动态代理
  最终生成的代理类会继承目标类
  并且和目标类在相同的包下
1
2
3
4
5
6
7
8

生产代理对象的工厂类：

public class ProxyFactory {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        /**
         * ClassLoader loader：指定加载动态生成的代理类的类加载器
         * Class[] interfaces：获取目标对象实现的所有接口的class对象的数组
         * InvocationHandler h：设置代理类中的抽象方法如何重写
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * Object proxy：表示代理对象
                 * Method method：表示要执行的方法
                 * Object[] args：表示要执行的方法到参数列表
                 */
                Object result = null;
                try {
                    System.out.println("[日志] " + method.getName() + " 方法开始了，参数是：" + Arrays.toString(args));
                    result = method.invoke(target, args);
                    System.out.println("[日志] " + method.getName() + " 方法开始了，结果是：" + result);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("[日志] " + method.getName() + " 方法开始了，异常是：" + e);
                } finally {
                    System.out.println("[日志] " + method.getName() + " 方法执行完毕");
                }
                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader, interfaces, h);
    }
}
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
35
36
37
38
39
40
41

2.4、测试

@Test
public void testProxy() {
    ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
    Calculator proxy = (Calculator) proxyFactory.getProxy();
    proxy.add(1, 2);
    //proxy.div(1, 0);
}
1
2
3
4
5
6
7

3、AOP概念及相关术语

3.1、概述

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。

3.2、相关术语

①横切关注点

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

②通知

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

• 前置通知：在被代理的目标方法前执行
• 返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
• 异常通知：在被代理的目标方法异常结束后执行（死于非命）
• 后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
• 环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置封装通知方法的类。

④目标

被代理的目标对象。

⑤代理

向目标对象应用通知之后创建的代理对象。

⑥连接点

这也是一个纯逻辑概念，不是语法定义的。

把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。

⑦切入点

定位连接点的方式。

每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。

如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。

Spring 的 AOP 技术可以通过切入点定位到特定的连接点。

切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

3.3、作用

• 简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。
• 代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

4、基于注解的AOP

4.1、技术说明

• 动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。

• cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。

• AspectJ：本质上是静态代理，将代理逻辑“织入”被代理的目标类编译得到的字节码文件，所以最终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解。

4.2、准备工作

①添加依赖

在IOC所需依赖基础上再加入下面依赖即可：

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.0.2.RELEASEversion>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-aspectsartifactId>
    <version>5.3.1version>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12

②准备被代理的目标资源

接口：

public interface Calculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}
1
2
3
4
5
6

实现类：

@Component
public class CalculatorPureImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}
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

4.3、创建切面类并配置

@Component
@Aspect //将当前组件标识为切面
public class LoggerAspect {

    @Pointcut("execution(* com.edu.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut() {
    }

    //@Before("execution(public int com.edu.aop.annotation.CalculatorImpl.add(int,int))")
    //@Before("execution(* com.edu.aop.annotation.CalculatorImpl.*(..))")
    @Before("pointCut()")
    public void beforeAdviceMethod(JoinPoint joinPoint) {
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        //获取连接点所对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect，前置通知 方法:" + signature.getName() + " ，参数:" + Arrays.toString(args));
    }

    @After("pointCut()")
    public void afterAdviceMethod(JoinPoint joinPoint) {
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect，后置通知 方法:" + signature.getName() + " ，执行完毕");
    }

    /*在返回通知中若要获取目标对象方法的返回值
    只需要@AfterReturning注解的returning属性
    就可以将通知方法的某个参数指定为接收目标对象方法的返回值参数
    */
    @AfterReturning(value = "pointCut()", returning = "result")
    public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result) {
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect，返回通知 方法:" + signature.getName() + " ，结果:" + result);
    }

    /*在异常通知中若要获取目标对象方法的异常
    只需要@AfterThrowing注解的throwing属性
    就可以将通知方法的某个参数指定为接收目标对象方法出现异常的参数
    */
    @AfterThrowing(value = "pointCut()", throwing = "e")
    //public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable e) {
    public void afterThrowingAdviceMethod(JoinPoint joinPoint, Exception e) {
        //获取连接点所对应方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect，异常通知 方法:" + signature.getName() + " ，异常:" + e);
    }

    /*
    * 环绕通知的方法的返回值一定要和目标对象方法的返回值一致
    * */
    @Around("pointCut()")
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint) {
        Object result = null;
        try {
            System.out.println("环绕通知-->前置通知");
            //表示目标对象方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知-->返回通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("环绕通知-->异常通知");
        } finally {
            System.out.println("环绕通知-->后置通知");
        }
        return result;
    }
}
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

在Spring的配置文件中配置：

<context:component-scan base-package="com.edu.aop.annotation"/>

<aop:aspectj-autoproxy/>
1
2
3
4
5
6
7
8
9

4.4、各种通知

• 前置通知：使用@Before注解标识，在被代理的目标方法前执行
• 返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）
• 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）
• 后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）
• 环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包

括上面四种通知对应的所有位置

各种通知的执行顺序：

• Spring版本5.3.x以前：
  • 前置通知
  • 目标操作
  • 后置通知
  • 返回通知或异常通知
• Spring版本5.3.x以后：
  • 前置通知
  • 目标操作
  • 返回通知或异常通知
  • 后置通知

4.5、切入点表达式语法

①作用

设置在标识通知的注解的value属性中

②语法细节

• 用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限

• 在包名的部分，一个“.”号只能代表包的层次结构中的一层，表示这一层是任意的。

  • 例如：.Hello匹配com.Hello，不匹配com.edu.Hello

• 在包名的部分，使用“…”表示包名任意、包的层次深度任意

• 在类名的部分，类名部分整体用号代替，表示类名任意

• 在类名的部分，可以使用

  号代替类名的一部分

  • *例如：*Service匹配所有名称以Service结尾的类或接口

• 在方法名部分，可以使用号表示方法名任意

• 在方法名部分，可以使用

  号代替方法名的一部分

  • 例如：*Operation匹配所有方法名以Operation结尾的方法

• 在方法参数列表部分，使用(…)表示参数列表任意

• 在方法参数列表部分，使用(int,…)表示参数列表以一个int类型的参数开头

• 在方法参数列表部分，基本数据类型和对应的包装类型是不一样的

  • 切入点表达式中使用 int 和实际方法中 Integer 是不匹配的

• 在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符

  • 例如：execution(public int …*Service.*(…, int)) 正确
  • 例如：execution( int *…Service.(…, int)) 错误

4.6、重用切入点表达式

①声明

@Pointcut("execution(* com.edu.aop.annotation.CalculatorImpl.*(..))")
public void pointCut() {}
1
2

②在同一个切面中使用

@Before("pointCut()")
public void beforeAdviceMethod(JoinPoint joinPoint) {
    //获取连接点所对应方法的签名信息
    Signature signature = joinPoint.getSignature();
    //获取连接点所对应方法的参数
    Object[] args = joinPoint.getArgs();
    System.out.println("LoggerAspect，前置通知 方法:" + signature.getName() + " ，参数:" + Arrays.toString(args));
}
1
2
3
4
5
6
7
8

③在不同切面中使用

@Before("com.edu.aop.annotation.LoggerAspect.pointCut()")
public void beforeMethod(){
    System.out.println("ValidateAspect-->前置通知");
}
1
2
3
4

4.7、获取通知的相关信息

①获取连接点信息

获取连接点信息可以在通知方法的参数位置设置JoinPoint类型的形参

@Before("execution(* com.edu.aop.annotation.CalculatorImpl.*(..))")
public void beforeAdviceMethod(JoinPoint joinPoint) {
    //获取连接点所对应方法的签名信息
    Signature signature = joinPoint.getSignature();
    //获取连接点所对应方法的参数
    Object[] args = joinPoint.getArgs();
    System.out.println("LoggerAspect，前置通知 方法:" + signature.getName() + " ，参数:" + Arrays.toString(args));
}
1
2
3
4
5
6
7
8

②获取目标方法的返回值

@AfterReturning中的属性returning，用来将通知方法的某个形参，接收目标方法的返回值

/*在返回通知中若要获取目标对象方法的返回值
  只需要@AfterReturning注解的returning属性
  就可以将通知方法的某个参数指定为接收目标对象方法的返回值参数
*/
@AfterReturning(value = "pointCut()", returning = "result")
public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result) {
    //获取连接点所对应方法的签名信息
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect，返回通知 方法:" + signature.getName() + " ，结果:" + result);
}
1
2
3
4
5
6
7
8
9
10

③获取目标方法的异常

@AfterThrowing中的属性throwing，用来将通知方法的某个形参，接收目标方法的异常

/*在异常通知中若要获取目标对象方法的异常
只需要@AfterThrowing注解的throwing属性
就可以将通知方法的某个参数指定为接收目标对象方法出现异常的参数
*/
@AfterThrowing(value = "pointCut()", throwing = "e")
//public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable e) {
public void afterThrowingAdviceMethod(JoinPoint joinPoint, Exception e) {
    //获取连接点所对应方法的签名信息
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect，异常通知 方法:" + signature.getName() + " ，异常:" + e);
}
1
2
3
4
5
6
7
8
9
10
11

4.8、环绕通知

/*
* 环绕通知的方法的返回值一定要和目标对象方法的返回值一致
* */
@Around("pointCut()")
public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint) {
    Object result = null;
    try {
        System.out.println("环绕通知-->前置通知");
        //表示目标对象方法的执行
        result = joinPoint.proceed();
        System.out.println("环绕通知-->返回通知");
    } catch (Throwable throwable) {
        throwable.printStackTrace();
        System.out.println("环绕通知-->异常通知");
    } finally {
        System.out.println("环绕通知-->后置通知");
    }
    return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.9、切面的优先级

相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

• 优先级高的切面：外面
• 优先级低的切面：里面

使用@Order注解可以控制切面的优先级：

• @Order(较小的数)：优先级高
• @Order(较大的数)：优先级低

可以通过@Order注解的value属性设置优先级，默认值是Interger的最大值
@Order注解的value属性值越小，优先级越高

5，基于XML的AOP（了解）

5.1、准备工作

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.0.2.RELEASEversion>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-aspectsartifactId>
    <version>5.3.1version>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12

5.2、实现

<context:component-scan base-package="com.edu.aop.xml"/>

<aop:config>
    
    <aop:pointcut id="pointCut" expression="execution(* com.edu.aop.xml.CalculatorImpl.*(..))"/>
    
    
    <aop:aspect ref="loggerAspect">
        <aop:before method="beforeAdviceMethod" pointcut-ref="pointCut"/>
        <aop:after method="afterAdviceMethod" pointcut-ref="pointCut"/>
        <aop:after-returning method="afterReturningAdviceMethod" returning="result" pointcut-ref="pointCut"/>
        <aop:after-throwing method="afterThrowingAdviceMethod" throwing="e" pointcut-ref="pointCut"/>
        <aop:around method="aroundAdviceMethod" pointcut-ref="pointCut"/>
    aop:aspect>
    
    <aop:aspect ref="validateAspect" order="1">
        <aop:before method="beforeMethod" pointcut-ref="pointCut"/>
    aop:aspect>
    
aop:config>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

四、声明式事务

1、JdbcTemplate

1.1、简介

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

1.2、准备工作

①加入依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.3.1version>
dependency>



<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-ormartifactId>
    <version>5.3.1version>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>5.3.1version>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-aspectsartifactId>
    <version>5.3.1version>
dependency>

<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.47version>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.0.31version>
dependency>

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.10version>
    <scope>providedscope>
dependency>
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

②创建jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_exercise
jdbc.username=root
jdbc.password=123456
1
2
3
4

③配置Spring的配置文件

<context:component-scan base-package="com.edu"/>


<context:property-placeholder location="classpath:jdbc.properties"/>


<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
bean>


<bean class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.3、测试

①在测试类装配 JdbcTemplate

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring-jdbc.xml")
public class JDBCTemplateTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}
1
2
3
4
5
6

②测试增删改功能

@Test
//测试增删改功能
public void testUpdate(){
    String sql = "insert into t_user values(null,?,?,?,?,?)";
    jdbcTemplate.update(sql, "tom", "123456", 23, "女", "123456@qq.com");
}
1
2
3
4
5
6

③查询一条数据为实体类对象

@Test
public void testGetUserById() {
    String sql = "select * from t_user where id = ?";
    User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), 1);
    System.out.println(user);
}
1
2
3
4
5
6

④查询多条数据为一个list集合

@Test
public void testGetAllUser() {
    String sql = "select * from t_user";
    List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
    users.forEach(user -> System.out.println(user));
}
1
2
3
4
5
6

⑤查询单行单列的值

@Test
public void testGetCount() {
    String sql = "select count(*) from t_user";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    System.out.println(count);
}
1
2
3
4
5
6

2、声明式事务概念

2.1、编程式事务

事务功能的相关操作全部通过自己编写代码来实现：

Connection conn = ...;
try {
    // 开启事务：关闭事务的自动提交
    conn.setAutoCommit(false);
    // 核心操作
    // 提交事务
    conn.commit();
}catch(Exception e){
    // 回滚事务
    conn.rollBack();
}finally{
    // 释放数据库连接
    conn.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

编程式的实现方式存在缺陷：

• 细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。
• 代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

2.2、声明式事务

既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出来，进行相关的封装。

封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。

• 好处1：提高开发效率
• 好处2：消除了冗余的代码
• 好处3：框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性能等各个方面的优化

所以，我们可以总结下面两个概念：

• 编程式：自己写代码实现功能
• 声明式：通过配置让框架实现功能

2.2.1声明式事务的配置步骤

1.在spring的配置文件中配置事务管理器
2.开启事务的注解驱动
在需要被事务管理的方法上，添加@Transactional注解，该方法就会被事物管理
1
2
3

3、基于注解的声明式事务

3.1、准备工作

①加入依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.3.1version>
dependency>



<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-ormartifactId>
    <version>5.3.1version>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>5.3.1version>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-aspectsartifactId>
    <version>5.3.1version>
dependency>

<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.47version>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.0.31version>
dependency>

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.10version>
    <scope>providedscope>
dependency>
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

②创建jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_exercise
jdbc.username=root
jdbc.password=123456
1
2
3
4

③配置Spring的配置文件

<context:component-scan base-package="com.edu"/>


<context:property-placeholder location="classpath:jdbc.properties"/>

<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
bean>

<bean class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
bean>


<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
bean>


<tx:annotation-driven transaction-manager="transactionManager"/>
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

④创建表

CREATE TABLE `t_book` (
    `book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
    `book_name` varchar(20) DEFAULT NULL COMMENT '图书名称',
    `price` int(11) DEFAULT NULL COMMENT '价格',
    `stock` int(10) unsigned DEFAULT NULL COMMENT '库存（无符号）',
    PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
insert into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1,'斗破苍穹',80,100),(2,'斗罗大陆',50,100);

CREATE TABLE `t_user` (
    `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
    `username` varchar(20) DEFAULT NULL COMMENT '用户名',
    `balance` int(10) unsigned DEFAULT NULL COMMENT '余额（无符号）',
    PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
insert into `t_user`(`user_id`,`username`,`balance`) values (1,'admin',50);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

⑤创建组件

创建BookController：

@Controller()
public class BookController {
    @Autowired
    private BookService bookService;

    public void buyBook(Integer userId, Integer bookId) {
        bookService.buyBook(userId, bookId);
    }
}
1
2
3
4
5
6
7
8
9

创建接口BookService：

public interface BookService {
    void buyBook(Integer userId, Integer bookId);
}
1
2
3

创建实现类BookServiceImpl：

@Service
//@Transactional
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    
    /*@Transactional(
            //readOnly = false,
            //timeout = -1,
            //noRollbackFor = {ArithmeticException.class},
            //noRollbackForClassName = "java.lang.ArithmeticException"
            //isolation = Isolation.DEFAULT
            //Propagation.REQUIRES_NEW使用被调用者的事务
            //默认使用调用者的事务
            propagation = Propagation.REQUIRES_NEW
    )*/
    public void buyBook(Integer userId, Integer bookId) {
        //查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId, price);
    }
}
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

创建接口BookDao：

public interface BookDao {
    /**
     * 根据图书的id查询图书的价格
     */
    Integer getPriceByBookId(Integer bookId);

    /**
     * 更新图书的库存
     */
    void updateStock(Integer bookId);

    /**
     * 更新用户的余额
     */
    void updateBalance(Integer userId, Integer price);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

创建实现类BookDaoImpl：

@Repository
public class BookDaoImpl implements BookDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public Integer getPriceByBookId(Integer bookId) {
        String sql = "select price from t_book where book_id = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class, bookId);
    }

    public void updateStock(Integer bookId) {
        String sql = "update t_book set stock = stock-1 where book_id = ? ";
        jdbcTemplate.update(sql, bookId);
    }

    public void updateBalance(Integer userId, Integer price) {
        String sql = "update t_user set balance = balance-? where user_id = ? ";
        jdbcTemplate.update(sql, price, userId);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.2、测试无事务情况

①创建测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx-annotation.xml")
public class TxByAnnotationTest {
    @Autowired
    private BookController bookController;
    
    @Test
    public void testBuyBook(){
        bookController.buyBook(1, 1);
    }
}
1
2
3
4
5
6
7
8
9
10
11

②模拟场景

用户购买图书，先查询图书的价格，再更新图书的库存和用户的余额

假设用户id为1的用户，购买id为1的图书

用户余额为50，而图书价格为80

购买图书之后，用户的余额为-30，数据库中余额字段设置了无符号，因此无法将-30插入到余额字段

此时执行sql语句会抛出SQLException

③观察结果

因为没有添加事务，图书的库存更新了，但是用户的余额没有更新

显然这样的结果是错误的，购买图书是一个完整的功能，更新库存和更新余额要么都成功要么都失败

3.3、加入事务

①添加事务配置

在Spring的配置文件中添加配置：

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
bean>


<tx:annotation-driven transaction-manager="transactionManager"/>
1
2
3
4
5
6
7
8
9
10
11
12

注意：导入的名称空间需要 tx 结尾的那个。

xmlns:tx=“http://www.springframework.org/schema/tx”

②添加事务注解

因为service层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在service层处理在BookServiceImpl的buybook()添加注解@Transactional

③观察结果

由于使用了Spring的声明式事务，更新库存和更新余额都没有执行

3.4、@Transactional注解标识的位置

@Transactional标识在方法上，咋只会影响该方法

@Transactional标识的类上，咋会影响类中所有的方法

3.5、事务属性：只读

①介绍

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这样数据库就能够针对查询操作来进行优化。

readOnly：只读 默认值是false
只有在全是查询时才可以使用，有增删改时使用会报错

②使用方式

//readOnly：只读 默认值是false
@Transactional(readOnly = true)
public void buyBook(Integer bookId, Integer userId) {
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    //更新图书的库存
    bookDao.updateStock(bookId);
    //更新用户的余额
    bookDao.updateBalance(userId, price);
    //System.out.println(1/0);
}
1
2
3
4
5
6
7
8
9
10
11

③注意

对增删改操作设置只读会抛出下面异常：java.sql.SQLException

3.6、事务属性：超时

①介绍

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。

此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

概括来说就是一句话：超时回滚，释放资源。

②使用方式

//timeout：超时 默认值是-1
@Transactional(timeout = 3)
public void buyBook(Integer bookId, Integer userId) {
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    //更新图书的库存
    bookDao.updateStock(bookId);
    //更新用户的余额
    bookDao.updateBalance(userId, price);
    //System.out.println(1/0);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

③观察结果

执行过程中抛出异常：TransactionTimedOutException

3.7、事务属性：回滚策略

①介绍

声明式事务默认只针对运行时异常回滚，编译时异常不回滚。

可以通过@Transactional中相关属性设置回滚策略

• rollbackFor属性：需要设置一个Class类型的对象
• rollbackForClassName属性：需要设置一个字符串类型的全类名
• noRollbackFor属性：需要设置一个Class类型的对象
• rollbackFor属性：需要设置一个字符串类型的全类名

②使用方式

@Transactional(noRollbackFor = ArithmeticException.class)
//@Transactional(noRollbackForClassName = "java.lang.ArithmeticException")
public void buyBook(Integer bookId, Integer userId) {
    //查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    //更新图书的库存
    bookDao.updateStock(bookId);
    //更新用户的余额
    bookDao.updateBalance(userId, price);
    System.out.println(1/0);
}
1
2
3
4
5
6
7
8
9
10
11

③观察结果

虽然购买图书功能中出现了数学运算异常（ArithmeticException），但是我们设置的回滚策略是，当出现ArithmeticException不发生回滚，因此购买图书的操作正常执行

3.8、事务属性：事务隔离级别

①介绍

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。SQL标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

隔离级别一共有四种：

• 读未提交：READ UNCOMMITTED

允许Transaction01读取Transaction02未提交的修改。

• 读已提交：READ COMMITTED、

要求Transaction01只能读取Transaction02已提交的修改。

• 可重复读：REPEATABLE READ

确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它

事务对这个字段进行更新。

• 串行化：SERIALIZABLE

确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它

事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

各个隔离级别解决并发问题的能力见下表：

各种数据库产品对事务隔离级别的支持程度：

②使用方式

@Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别
@Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交
@Transactional(isolation = Isolation.READ_COMMITTED)//读已提交
@Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读
@Transactional(isolation = Isolation.SERIALIZABLE)//串行化
1
2
3
4
5

3.9、事务属性：事务传播行为

①介绍

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

②测试

创建接口CheckoutService：

public interface CheckoutService {
    /**
     * 结账
     */
    void checkout(Integer userId, Integer[] bookIds);
}
1
2
3
4
5
6

创建实现类CheckoutServiceImpl：

@Service
public class CheckoutServiceImpl implements CheckoutService {
    @Autowired
    private BookService bookService;

    @Transactional
    public void checkout(Integer userId, Integer[] bookIds) {
        for (Integer bookId : bookIds) {
            bookService.buyBook(userId,bookId);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

在BookController中添加方法：

public void checkout(Integer userId, Integer[] bookIds) {
    checkoutService.checkout(userId,bookIds);
}
1
2
3

在数据库中将用户的余额修改为100元

③观察结果

可以通过@Transactional中的propagation属性设置事务传播行为

修改BookServiceImpl中buyBook()上，注解@Transactional的propagation属性

@Transactional(propagation = Propagation.REQUIRED)，默认情况，表示如果当前线程上有已经开启的事务可用，那么就在这个事务中运行。经过观察，购买图书的方法buyBook()在checkout()中被调用，checkout()上有事务注解，因此在此事务中执行。所购买的两本图书的价格为80和50，而用户的余额为100，因此在购买第二本图书时余额不足失败，导致整个checkout()回滚，即只要有一本书买不

了，就都买不了。

@Transactional(propagation = Propagation.REQUIRES_NEW)，表示不管当前线程上是否有已经开启的事务，都要开启新事务。同样的场景，每次购买图书都是在buyBook()的事务中执行，因此第一本图书购买成功，事务结束，第二本图书购买失败，只在第二次的buyBook()中回滚，购买第一本图书不受影响，即能买几本就买几本

4、基于XML的声明式事务

4.1、场景模拟

参考基于注解的声明式事务

4.2、修改Spring配置文件

将Spring配置文件中去掉tx:annotation-driven 标签，并添加配置：

<context:component-scan base-package="com.edu"/>


<context:property-placeholder location="classpath:jdbc.properties"/>

<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
bean>

<bean class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
bean>


<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
bean>



<tx:advice id="tx" transaction-manager="transactionManager">
    <tx:attributes>
        
        <tx:method name="buyBooks" read-only="false"/>
        <tx:method name="*" />
    tx:attributes>
tx:advice>

<aop:config>
    
    <aop:advisor advice-ref="tx" pointcut="execution(* com.edu.service.impl.*.*(..))"/>
aop:config>
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

注意：基于xml实现的声明式事务，必须引入aspectJ的依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-aspectsartifactId>
    <version>5.3.1version>
dependency>
1
2
3
4
5