SSM 之 Spring（上）-阿里云开发者社区

二、Spring

1、Spring简介

1.1、Spring概述

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

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

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

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

1.2、Spring家族

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

1.3、Spring Framework

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

1.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 来实现。

1.3.2、Spring Framework五大功能模块

功能模块	功能介绍
Core Contianer	核心容器，在spring环境下使用任何功能都必须基于IOC容器
AOP&Aspects	面向切面编程
Testing	提供了对junit或TestNG测试框架的整合
Data AccessIntegration	提供了对数据访问、集成的功能
Spring MVC	提供了面向Web的应用程序的集成功能

2、IOC

2.1、IOC容器

2.1.1、IOC思想

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

① 获取资源的传统方式

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

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

② 反转控制方式获取资源

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

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

③ DI

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

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

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

2.1.2、IOC容器在Spring中实现

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

① BeanFactory

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

② ApplicationContext

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

③ ApplicationContext的主要实现类

类型名简介

类型名	简介
classpathxmlapplicationcontext	通过读取类路径下的XML格式的配置文件创建IOC容器对象
filesystemxmlapplicationcontext	通过文件系统路径读取xml格式的配置文件创建IOC容器对象
configurableapplicationcontext	applicationcontext的子接口，包含一些扩展方法refresh（）和close（），让applicationcontext具有启动、关闭和刷新上下文的能力
webapplicationcontext	专门为Web应用准备，基于web环境创建IOC容器对象，并将对象引入存入servletcontext域中

2.2、基于XML管理bean

2.2.1、实验一：入门案例

① 创建Maven Module

② 引入依赖

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所有需要的jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.18</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

③ 创建类 HelloWorld

package com.jingchao.spring.pojo;
public class HelloWorld {
    public void sayHello(){
        System.out.println("Hello World!");
    }
}

④ 创建Spring的配置文件
⑤ 在Spring的配置文件中配置bean

说明

bean：配置一个bean对象，将HelloWorld的对象交给Spring的IOC容器管理

属性：

id：bean的唯一标识

class：设置bean对象所对应的类型

示例

<bean id="helloworld" class="com.jingchao.spring.pojo.HelloWorld"></bean>

⑥ 创建测试类

@Test
public void test(){
    // 获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 获取IOC容器中的bean
    HelloWorld helloworld = (HelloWorld) ioc.getBean("helloworld");
    helloworld.sayHello();
}

⑦ 思路
⑧ 注意

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

org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘studentOne’ defined in class path resource [spring-ioc.xml]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.jingchao.spring.pojo.Student]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.jingchao.spring.pojo.Student.()

2.2.2、实验二：获取bean

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

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

@Test
public void testIOC(){
    // 获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
    // 获取bean
    Student student = (Student) ioc.getBean("studentOne");
    System.out.println(student);
}

② 方式二：根据bean的类型获取（常用）

@Test
public void testIOC(){
    // 获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
    // 获取bean
    Student student = ioc.getBean(Student.class);
    System.out.println(student);
}

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

@Test
public void testIOC(){
    // 获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
    // 获取bean
    Student student = ioc.getBean("studentOne", Student.class);
    System.out.println(student);
}

④ 注意

当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个

当IOC容器配置两个：

<bean id="studentOne" class="com.jingchao.spring.pojo.Student"/>
<bean id="studentTwo" class="com.jingchao.spring.pojo.Student"/>

根据类型获取时会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type ‘com.jingchao.spring.pojo.Student’ available: expected single matching bean but found 2: studentOne,studentTwo

⑤ 扩展

问题一：如果组件类实现的接口，根据接口类型可以获取bean吗？

可以，前提是bean必须唯一

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

不能，因为bean不唯一

⑥ 结论

根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到。

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

① 创建学生类Student

package com.jingchao.spring.pojo;
public class Student {
    private Integer sid;
    private String sname;
    private Integer age;
    private String gender;
    public Student() {
    }
    public Integer getSid() {
        return sid;
    }
    public void setSid(Integer sid) {
        this.sid = sid;
    }
    public String getSname() {
        return sname;
    }
    public void setSname(String sname) {
        this.sname = sname;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

② 配置bean时为属性赋值

<bean id="studentTwo" class="com.jingchao.spring.pojo.Student">
    <property name="sid" value="1001"/>
    <property name="sname" value="张三"/>
    <property name="age" value="18"/>
    <property name="gender" value="女"/>
</bean>

property标签：通过组件类的setXxx()方法给组件对象设置属性

属性：

name：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关

value：指定属性值

③ 测试

 @Test
public void testDI(){
    // 获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
    // 获取bean
    Student student = ioc.getBean("studentTwo", Student.class);
    System.out.println(student);
}

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

① 在Student类中添加带参构造器

public Student(Integer sid, String sname, Integer age, String gender) {
    this.sid = sid;
    this.sname = sname;
    this.age = age;
    this.gender = gender;
}

② 配置bean

<bean id="studentThree" class="com.jingchao.spring.pojo.Student">
    <constructor-arg value="1002"/>
    <constructor-arg value="李四"/>
    <constructor-arg value="20"/>
    <constructor-arg value="男"/>
</bean>

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

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

name属性：指定参数名

③ 测试

@Test
public void testDI(){
    // 获取IOC容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
    // 获取bean
    Student student = ioc.getBean("studentThree", Student.class);
    System.out.println(student);
}

2.2.5、实验五：特殊值处理

① 字面量赋值

什么是字面量？

int a = 10;

声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a 的时候，我们实际上拿到的值是10。

而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="sname" value="张三"/>

② null值

<property name="gender">
    <null/>
</property>

注意：下面的写法为gender赋的值为字符串 null

<property name="gender" value="null"/>

③ xml实体

<property name="gender" value="&lt;男&gt;"/>

备注：大于小于符号在xml中意味着标签的结束和开始，不能使用，需要使用XML实体代替
④ CDATA节

<property name="gender">
  <value><![CDATA[<男>]]></value>
</property>

备注：XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析

所以CDATA节中可以写任意的符号

CDATA节是xml中一个特殊的标签，因此不能写在属性中

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

① 创建班级类Clazz

package com.jingchao.spring.pojo;
public class Clazz {
    private Integer  cid;
    private String cname;
    public Clazz() {
    }
    public Clazz(Integer cid, String cname) {
        this.cid = cid;
        this.cname = cname;
    }
    public Integer getCid() {
        return cid;
    }
    public void setCid(Integer cid) {
        this.cid = cid;
    }
    public String getCname() {
        return cname;
    }
    public void setCname(String cname) {
        this.cname = cname;
    }
    @Override
    public String toString() {
        return "Clazz{" +
                "cid=" + cid +
                ", cname='" + cname + '\'' +
                '}';
    }
}

② 修改Student类

在Student类中添加如下代码

private Clazz clazz;
public Clazz getClazz(){
    return clazz;
}
public void setClazz(Clazz clazz){
    this.clazz = clazz;
}
@Override
public String toString() {
    return "Student{" +
        "sid=" + sid +
        ", sname='" + sname + '\'' +
        ", age=" + age +
        ", gender='" + gender + '\'' +
        ", clazz=" + clazz +
        '}';
}

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

配置Clazz类型的bean

<bean id="clazzOne" class="com.jingchao.spring.pojo.Clazz">
    <property name="cid" value="1111"/>
    <property name="cname" value="最强王者班"/>
</bean>

为Student中的clazz属性赋值

<bean id="studentSix" class="com.jingchao.spring.pojo.Student">
    <property name="sid" value="1005"/>
    <property name="sname" value="赵六"/>
    <property name="age" value="24"/>
    <property name="gender" value="男"/>
    <property name="clazz" ref="clazzOne"/>
</bean>

说明：ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值

④ 方式二：内部bean

<bean id="studentEight" class="com.jingchao.spring.pojo.Student">
    <property name="sid" value="1005"/>
    <property name="sname" value="赵六"/>
    <property name="age" value="24"/>
    <property name="gender" value="男"/>
    <property name="clazz">
        <bean id="clazzInner" class="com.jingchao.spring.pojo.Clazz">
            <property name="cid" value="333"/>
            <property name="cname" value="暴富班"/>
        </bean>
    </property>
</bean>

说明：内部bean只能用于给属性赋值，不能再外部通过IOC容器获取，因此可以省略id属性

⑤ 方式三：级联属性赋值

<bean id="studentSeven" class="com.jingchao.spring.pojo.Student">
    <property name="sid" value="1005"/>
    <property name="sname" value="赵六"/>
    <property name="age" value="24"/>
    <property name="gender" value="男"/>
    <!-- 必须先引用某个bean为属性赋值，才可以使用级联方式更新属性 -->
    <property name="clazz" ref="clazzOne"/>
    <property name="clazz.cid" value="2222"/>
    <property name="clazz.cname" value="完胜班"/>
</bean>

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

① 修改Student类

在Student类中添加如下代码

private String[] hobby;
public String[] getHobby() {
    return hobby;
}
public void setHobby(String[] hobby) {
    this.hobby = hobby;
}
@Override
public String toString() {
    return "Student{" +
        "sid=" + sid +
        ", sname='" + sname + '\'' +
        ", age=" + age +
        ", gender='" + gender + '\'' +
        ", hobby=" + Arrays.toString(hobby) +
        ", clazz=" + clazz +
        '}';
}

② 配置bean

<bean id="studentNine" class="com.jingchao.spring.pojo.Student">
    <property name="sid" value="1005"/>
    <property name="sname" value="赵六"/>
    <property name="age" value="24"/>
    <property name="gender" value="男"/>
    <property name="clazz">
        <bean class="com.jingchao.spring.pojo.Clazz">
            <property name="cid" value="333"/>
            <property name="cname" value="暴富班"/>
        </bean>
    </property>
    <property name="hobby">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>烫头</value>
        </array>
    </property>
</bean>

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

① 为List集合类型属性赋值

在Clazz类中添加如下代码

private List<Student> students;
public List<Student> getStudents() {
    return students;
}
public void setStudents(List<Student> students) {
    this.students = students;
}
@Override
public String toString() {
    return "Clazz{" +
        "cid=" + cid +
        ", cname='" + cname + '\'' +
        ", students=" + students +
        '}';
}

配置bean

<bean id="clazzTwo" class="com.jingchao.spring.pojo.Clazz">
    <property name="cid" value="1111"/>
    <property name="cname" value="最强王者班"/>
    <property name="students">
        <list>
            <ref bean="studentOne"/>
            <ref bean="studentTwo"/>
            <ref bean="studentThree"/>
            <ref bean="studentFour"/>
        </list>
    </property>
</bean>

<bean id="clazzTwo" class="com.jingchao.spring.pojo.Clazz">
    <property name="cid" value="1111"/>
    <property name="cname" value="最强王者班"/>
    <property name="students" ref="studentList"/>
</bean>
<!-- 配置一个集合类型的bean -->
<util:list id="studentList">
    <ref bean="studentOne"/>
    <ref bean="studentTwo"/>
    <ref bean="studentThree"/>
    <ref bean="studentFour"/>
</util:list>

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

② 为Map集合类型属性赋值

创建Teacher教师类

package com.jingchao.spring.pojo;
public class Teacher {
    private Integer tid;
    private String tname;
    public Teacher() {
    }
    public Teacher(Integer tid, String tname) {
        this.tid = tid;
        this.tname = tname;
    }
    public Integer getTid() {
        return tid;
    }
    public void setTid(Integer tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "tid=" + tid +
                ", tname='" + tname + '\'' +
                '}';
    }
}

在Student类中添加如下代码

private Map<String, Teacher> teacherMap;
public Map<String, Teacher> getTeacherMap() {
    return teacherMap;
}
public void setTeacherMap(Map<String, Teacher> teacherMap) {
    this.teacherMap = teacherMap;
}
@Override
public String toString() {
    return "Student{" +
        "sid=" + sid +
        ", sname='" + sname + '\'' +
        ", age=" + age +
        ", gender='" + gender + '\'' +
        ", hobby=" + Arrays.toString(hobby) +
        ", clazz=" + clazz +
        ", teacherMap=" + teacherMap +
        '}';
}

配置bean

<bean id="studentTen" class="com.jingchao.spring.pojo.Student">
    <property name="sid" value="1005"/>
    <property name="sname" value="赵六"/>
    <property name="age" value="24"/>
    <property name="gender" value="男"/>
    <property name="clazz">
        <bean class="com.jingchao.spring.pojo.Clazz">
            <property name="cid" value="333"/>
            <property name="cname" value="暴富班"/>
        </bean>
    </property>
    <property name="hobby">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>烫头</value>
        </array>
    </property>
    <property name="teacherMap">
        <map>
            <entry key="1245" value-ref="teacherOne"/>
            <entry key="1249" value-ref="teacherTwo"/>
        </map>
    </property>
</bean>
<bean id="teacherOne" class="com.jingchao.spring.pojo.Teacher">
    <property name="tid" value="1245"/>
    <property name="tname" value="张三"/>
</bean>
<bean id="teacherTwo" class="com.jingchao.spring.pojo.Teacher">
    <property name="tid" value="1249"/>
    <property name="tname" value="栗子"/>
</bean>

③ 引用集合类型的bean

<bean id="studentTen" class="com.jingchao.spring.pojo.Student">
    <property name="sid" value="1005"/>
    <property name="sname" value="赵六"/>
    <property name="age" value="24"/>
    <property name="gender" value="男"/>
    <property name="clazz">
        <bean class="com.jingchao.spring.pojo.Clazz">
            <property name="cid" value="333"/>
            <property name="cname" value="暴富班"/>
        </bean>
    </property>
    <property name="hobby">
        <array>
            <value>抽烟</value>
            <value>喝酒</value>
            <value>烫头</value>
        </array>
    </property>
    <property name="teacherMap" ref="teacherMap"/>
</bean>
<bean id="teacherOne" class="com.jingchao.spring.pojo.Teacher">
    <property name="tid" value="1245"/>
    <property name="tname" value="张三"/>
</bean>
<bean id="teacherTwo" class="com.jingchao.spring.pojo.Teacher">
    <property name="tid" value="1249"/>
    <property name="tname" value="栗子"/>
</bean>
<util:map id="teacherMap">
    <entry key="1245" value-ref="teacherOne"/>
    <entry key="1249" value-ref="teacherTwo"/>
</util:map>

使用util:list、util:map标签必须引入相应的命名空间

2.2.9、实验九：p命名空间

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

<bean id="studentEleven"
      class="com.jingchao.spring.pojo.Student"
      p:sid="1006" p:sname="王哈哈" p:teacherMap-ref="teacherMap">
</bean>

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

① 引入依赖

<!-- MySQL驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version>
</dependency>
<!-- 数据源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.9</version>
</dependency>

② 创建外部属性文件

文件名为 jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

③ 引入属性文件

<!-- 引入jdbc.properties，之后可以通过${key}的方式访问value -->
<context:property-placeholder location="jdbc.properties"/>

④ 配置bean

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <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>

⑤ 测试

@Test
public void testDataSource() throws SQLException {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-datasource.xml");
    DruidDataSource dataSource = ioc.getBean(DruidDataSource.class);
    System.out.println(dataSource.getConnection());
}

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

① 概念

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

取值	含义	创建对象的时机
singleton（默认）	在IOC容器中，这个bean的对象始终为单实例	IOC容器初始化时
prototype	这个bean在IOC容器中有多个实例	获取bean时

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

取值	含义
request	在一个请求范围内有效
session	在一个会话范围内有效

② 配置bean

<bean id="student" class="com.jingchao.spring.pojo.Student" scope="prototype">
    <property name="sid" value="1001"/>
    <property name="sname" value="张三"/>
</bean>

说明：

scope=“singleton” （默认值）时，bean在IOC容器中只有一个实例，IOC容器初始化时创建对象

scope=“prototype” 时，bean在IOC容器中可以有多个实例，getBean()时创建对象

③ 测试

@Test
public void testScope(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-scope.xml");
    Student student = ioc.getBean(Student.class);
    Student student1 = ioc.getBean(Student.class);
    System.out.println(student == student1);
}

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

① 具体生命周期过程

bean对象创建（调用无参构造器）

给bean对象设置属性

bean对象初始化之前操作（由bean的后置处理器负责）

bean对象初始化（需在配置bean时指定初始化方法）

bean对象初始化之后操作（由bean的后置处理器负责）

bean对象就绪可以使用 bean对象销毁（需在配置bean时指定销毁方法）

IOC容器关闭

② 创建User类

package com.jingchao.spring.pojo;
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    public User() {
        System.out.println("生命周期：1、创建对象");
    }
    public User(Integer id, String username, String password, Integer age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }
    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、销毁");
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

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

③ 配置bean

<bean id="user"
      class="com.jingchao.spring.pojo.User"
      init-method="initMethod"
      destroy-method="destroyMethod">
    <property name="id" value="1001"/>
    <property name="username" value="admin"/>
    <property name="password" value="123456"/>
    <property name="age" value="18"/>
</bean>

④ 测试

@Test
public void testLifeCycle(){
    ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
    User user = ioc.getBean(User.class);
    System.out.println(user);
    ioc.close();
}

说明：

ConfigurableApplicationContext是ApplicationContext的子接口，其中扩展了刷新和关闭容器的方法。

生命周期：

实例化

依赖注入

后置处理器的postProcessBeforeInitialization

初始化，需要通过bean的init-method属性指定初始化的方法

后置处理器的postProcessAfterInitialization

IOC容器关闭时销毁，需要通过bean的destroy-method属性指定销毁的方法

⑤ bean的后置处理器

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

创建bean的后置处理器：

package com.jingchao.spring.process;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 此方法在bean的生命周期初始化之前执行
        System.out.println("MyBeanPostProcessor 后置处理器postProcessBeforeInitialization");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 此方法在bean的生命周期初始化之后执行
        System.out.println("MyBeanPostProcessor 后置处理器postProcessAfterInitialization");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

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

<!-- bean的后置处理器需要放在IOC容器中才能生效 -->
<bean id="myBeanPostProcessor" class="com.jingchao.spring.process.MyBeanPostProcessor"></bean>

2.2.13、实验十三：FactoryBean

① 简介

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

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

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
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;
    }
}

② 创建UserFactoryBean

package com.jingchao.spring.factory;
import com.jingchao.spring.pojo.User;
import org.springframework.beans.factory.FactoryBean;
public class UserFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        return new User();
    }
    @Override
    public Class<?> getObjectType() {
        return User.class;
    }
}

③ 配置bean

<bean id="user" class="com.jingchao.spring.factory.UserFactoryBean"/>

④ 测试

@Test
public void testFactoryBean(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-factory.xml");
    User user = ioc.getBean(User.class);
    System.out.println(user);
}

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

自动装配：

根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值

① 场景模拟

创建UserController类

package com.jingchao.spring.controller;
import com.jingchao.spring.service.UserService;
public class UserController {
    private UserService userService;
    public UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public void  saveUser(){
        userService.saveUser();
    }
}

创建UserService接口

package com.jingchao.spring.service;
public interface UserService {
    /**
     * 保存用户信息
     */
    void saveUser();
}

创建UserServiceImpl类实现UserService接口

package com.jingchao.spring.service.impl;
import com.jingchao.spring.dao.UserDao;
import com.jingchao.spring.service.UserService;
public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public UserDao getUserDao() {
        return userDao;
    }
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void saveUser() {
        userDao.saveUser();
    }
}

创建UserDao接口

package com.jingchao.spring.dao;
public interface UserDao {
    /**
     * 保存用户信息
     */
    void saveUser();
}

创建UserDaoImpl类实现UserDao接口

package com.jingchao.spring.dao.impl;
import com.jingchao.spring.dao.UserDao;
public class UserDaoImpl implements UserDao {
    @Override
    public void saveUser() {
        System.out.println("保存成功！");
    }
}

② 配置bean

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

自动装配方式：byType

byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值 null

若在IOC中，有多个兼容类型的bean能够为属性赋值，则抛出异常 NoUniqueBeanDefinitionException

<bean id="userController" class="com.jingchao.spring.controller.UserController" autowire="byType"/>
<bean id="userService" class="com.jingchao.spring.service.impl.UserServiceImpl" autowire="byType"/>
<bean id="userDao" class="com.jingchao.spring.dao.impl.UserDaoImpl"/>

自动装配：byName

byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的bean进行赋值

<bean id="userController" class="com.jingchao.spring.controller.UserController" autowire="byName"/>
<bean id="userService" class="com.jingchao.spring.service.impl.UserServiceImpl" autowire="byName"/>
<bean id="userServiceImpl" class="com.jingchao.spring.service.impl.UserServiceImpl" autowire="byName"/>
<bean id="userDao" class="com.jingchao.spring.dao.impl.UserDaoImpl"/>
<bean id="userDaoImpl" class="com.jingchao.spring.dao.impl.UserDaoImpl"/>

③ 测试

@Test
public void testAutowire(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-autowire-xml.xml");
    UserController controller = ioc.getBean(UserController.class);
    controller.saveUser();
}

2.3、基于注解管理bean

2.2.1、实验一：标记与扫描

① 注解

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

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

举例：元旦联欢会要布置教室，蓝色的地方贴上元旦快乐四个字，红色的地方贴上拉花，黄色的地方贴上气球。

班长做了所有标记，同学们来完成具体工作。墙上的标记相当于我们在代码中使用的注解，后面同学们做的工作，相当于框架的具体操作。

② 扫描

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

③ 新建Maven Module

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需要的jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.18</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

④ 创建Spring配置文件

文件名为 spring-ioc-annotaion.xml

⑤ 标识组件的常用注解

@Component：将类表示为普通组件

@Controller：将类表示为控制层组件

@Service：将类表示为业务层组件

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

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

通过查看源码我们得知，@Controller、@Service、@Repository这三个注解只是在@Component注解的基础上起了三个新的名字。

对于Spring使用IOC容器管理这些组件来说没有区别。所以@Controller、@Service、@Repository这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。

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

⑥ 创建组件

创建控制层

package com.jingchao.spring.controller;
import org.springframework.stereotype.Controller;
@Controller
public class UserController {
}

创建UserService接口

package com.jingchao.spring.service;
public interface UserService {
}

创建业务层组件UserServiceImpl

package com.jingchao.spring.service.impl;
import com.jingchao.spring.service.UserService;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
}

创建UserDao接口

package com.jingchao.spring.dao;
public interface UserDao {
}

创建持久层组件UserDaoImpl

package com.jingchao.spring.dao.impl;
import com.jingchao.spring.dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoImpl implements UserDao {
}

⑦ 扫描组件

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

<!-- 扫描组件 -->
<context:component-scan base-package="com.jingchao.spring"/>

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

<context:component-scan base-package="com.jingchao.spring">
  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    <!-- <context:exclude-filter type="assignable" expression="com.jingchao.spring.controller.UserController"/> -->
</context:component-scan>

说明：context:exclude-filter标签：指定排除规则

type：设置排除或包含的依据

type=“annotation”：根据注解排除，expression中设置要排除的注解的全类名

type=“assignable”：根据类型排除，expression中设置要排除的类的全类名

情况三：仅扫描指定的组件

<context:component-scan base-package="com.jingchao.spring" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  <!-- <context:include-filter type="assignable" expression="com.jingchao.spring.controller.UserController"/> -->
</context:component-scan>

说明：context:include-filter标签：指定在原有扫描基础上追加的规则

use-default-filters属性：false表示关闭默认的扫描规则（此时必须设置为false，因为默认规则下扫描指定包下的所有类）

type：设置排除或包含的依据

type=“annotation”：根据注解排除，expression中设置要排除的注解的全类名

type=“assignable”：根据类型排除，expression中设置要排除的类的全类名

⑧ 测试

@Test
public void test(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");
    UserController controller = ioc.getBean(UserController.class);
    System.out.println(controller);
    UserService service = ioc.getBean(UserService.class);
    System.out.println(service);
    UserDao dao = ioc.getBean(UserDao.class);
    System.out.println(dao);
}

⑨ 组件所对应的bean的id

在我们使用XML方式管理bean的时候，每个bean都有一个唯一标识，便于在其他地方引用。现在使用注解后，每个组件仍然应该有一个唯一标识。

默认情况

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

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

@Service(“userService”) 默认为userServiceImpl 自定义后为userService

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

① 场景模拟

参考基于xml的自动装配

在UserController中声明UserService对象

在UserServiceImpl中声明UserDao对象

② @Autowired注解

在成员变量上直接标记@Autowired注解即可完成自动装配，不需要提供setXxx()方法。以后我们在项目中的正式用法就是这样。

修改UserController类

ackage com.jingchao.spring.controller;
import com.jingchao.spring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller("controller")
public class UserController {
    @Autowired
    private UserService userService;
    public void savaUser(){
        userService.saveUser();
    };
}

修改UserService接口

package com.jingchao.spring.service;
public interface UserService {
    /**
     * 保存用户信息
     */
    void saveUser();
}

修改UserService接口的实现类UserServiceImpl

package com.jingchao.spring.service.impl;
import com.jingchao.spring.dao.UserDao;
import com.jingchao.spring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Override
    public void saveUser() {
        userDao.saveUser();
    }
}

修改UserDao接口

package com.jingchao.spring.dao;
public interface UserDao {
    /**
     * 保存用户信息
     */
    void saveUser();
}

修改UserDao接口的实现类UserDaoImpl

package com.jingchao.spring.dao.impl;
import com.jingchao.spring.dao.UserDao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void saveUser() {
        System.out.println("保存成功！");
    }
}

测试

@Test
public void test(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");
    UserController controller = ioc.getBean("controller",UserController.class);
    controller.savaUser();
}

③ Autowired注解其他细节

@Autowire注解可以标记在构造器

package com.jingchao.spring.controller;
import com.jingchao.spring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller("controller")
public class UserController {
    private UserService userService;
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
    public void savaUser(){
        userService.saveUser();
    };
}

@Autowire注解可以标记在set方法上

package com.jingchao.spring.controller;
import com.jingchao.spring.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller("controller")
public class UserController {
    private UserService userService;
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public void savaUser(){
        userService.saveUser();
    };
}

注意：

Autowired注解能够标识的位置

标识在成员变量上，此时不需要设置成员变量的set方法

表示在set方法上

表示在为当前成员变量赋值的构造器上

④ @Autowired工作流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XZ8UKwPw-1665225002152)(https://cdn.jsdelivr.net/gh/a-jingchao/picture-bed/BlogImages/202209231048114.png)]

首先根据所需要的组件类型到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();
    }
}

3、AOP

3.1、场景模拟

3.1.1、声明接口

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

package com.jingchao.spring.proxy;
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);
}

3.1.2、创建实现类

package com.jingchao.spring.proxy;
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;
    }
}

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

package com.jingchao.spring.proxy;
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;
    }
}

3.1.4、提出问题

① 现有代码缺陷

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

对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力

附加功能分散在各个业务功能方法中，不利于统一维护

② 解决思路

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

③ 困难

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

3.2、代理模式

3.2.1、概念

① 介绍

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

② 生活中的代理

广告商找大明星拍广告需要经过经纪人

合作伙伴找大老板谈合作要约见面时间需要经过秘书

房产中介是买卖双方的代理

③ 相关术语

代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。

目标：被代理“套用”了非核心逻辑代码的类、对象、方法。

3.2.2、静态代理

创建静态代理类：

package com.jingchao.spring.proxy;
public class CalculatorStaticProxy implements Calculator{
    private CalculatorImpl target;
    public CalculatorStaticProxy(CalculatorImpl target) {
        this.target = target;
    }
    @Override
    public int add(int i, int j) {
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
        int result = target.add(i, j);
        System.out.println("[日志] add 方法结束了，结果是：" + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
        int result = 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;
    }
}

测试

@Test
public  void testProxy(){
    CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
    proxy.add(2,4);
}

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

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

3.2.3、动态代理

生产代理对象的工厂类

package com.jingchao.spring.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    public Object getProxy(){
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object result = null;
                try {
                    // proxy代理对象    method要执行的方法    args 要执行的方法用到的参数列表
                    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,invocationHandler);
    }
}

测试

@Test
public  void testProxy(){
    ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
    Calculator proxy = (Calculator) proxyFactory.getProxy();
    proxy.add(2,4);
}

3.3、AOP概念即相关术语

3.3.1、概述

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

3.3.2、相关术语

① 横切关注点

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

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

② 通知

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

前置通知：在被代理的目标方法前执行

返回通知：在被代理的目标方法成功结束后执行（寿终正寝）

异常通知：在被代理的目标方法异常结束后执行（死于非命）

后置通知：在被代理的目标方法最终结束后执行（盖棺定论）

环绕通知：使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

③ 切面

封装通知方法的类
④ 目标

被代理的目标对象。

⑤ 代理

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

⑥ 连接点

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

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

⑦ 切入点

定位连接点的方式。

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

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

Spring 的 AOP 技术可以通过切入点定位到特定的连接点。切点通过org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

3.3.3、作用

简化代码：把方法中固定位置的重复的代码抽取出来，让被抽取的方法更专注于自己的核心功能，提高内聚性。

代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被套用了切面逻辑的方法就被切面给增强了。

3.4、基于注解的AOP

3.4.1、技术说明

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

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

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

3.4.2、准备工作

① 添加依赖

在IOC所需依赖基础上在加入如下依赖

<!-- spring-aspects会帮助我们传递过来aspectjweaver -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.22</version>
</dependency>

② 准备被代理的目标资源

接口：

package com.jingchao.spring.aop.annotation;
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);
}

实现类

package com.jingchao.spring.aop.annotation;
@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;
    }
}

3.4.3、创建切面类并配置

package com.jingchao.spring.aop.annotation;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
// 保证这个切面类能够放入IOC容器中
@Component
// 标识这是一个切面类
@Aspect
public class LoggerAspect {
    @Pointcut("execution(* com.jingchao.spring.aop.annotation.CalculatorImpl.*(..))")
    public void pointCut(){}
    // @Before("execution(public int com.jingchao.spring.aop.annotation.CalculatorImpl.add(int, int ))")
    @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();
        // 获取连接点对应方法的参数
        Object[] args = joinPoint.getArgs();
        System.out.println("LoggerAspect, 方法 " + signature.getName()+"，执行完毕");
    }
    @AfterReturning(value = "pointCut()", returning = "result")
    public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result){
        // 获取连接点对应的方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect, 方法 "+signature.getName() + "，结果："+ result);
    }
    @AfterThrowing(value = "pointCut()", throwing = "exception")
    public void afterThrowAdviceMethod(JoinPoint joinPoint, Exception exception){
        // 获取连接点对应的方法的签名信息
        Signature signature = joinPoint.getSignature();
        System.out.println("LoggerAspect, 方法 "+signature.getName()+"，异常: " + exception);
    }
    @Around("pointCut()")
    public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
        Object result = null;
        try {
            System.out.println("环绕通知 ——> 前置通知");
            // 表示目标对象方法的执行
            result = joinPoint.proceed();
            System.out.println("环绕通知 ——> 返回通知");
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("环绕通知 ——> 异常通知");
        }finally {
            System.out.println("环绕通知 ——> 后置通知");
        }
        return result;
    }
}

在spring的配置文件中配置：

<context:component-scan base-package="com.jingchao.spring.aop.annotation"/>
<!-- 开启基于注解的AOP -->
<aop:aspectj-autoproxy/>

注意AOP注意事项

切面类和目标类都需要交给IOC容器管理

切面类必须通过@Aspect注解标识为一个切面

在Spring的配置文件中设置aop:aspectj-autoproxy/标签开启居于注解的AOP

3.4.4、各种通知

前置通知：使用@Before注解标识，在被代理的目标方法前执行

返回通知：使用@AfterReturning注解标识，在被代理的目标方法成功结束后执行（寿终正寝）

异常通知：使用@AfterThrowing注解标识，在被代理的目标方法异常结束后执行（死于非命）

后置通知：使用@After注解标识，在被代理的目标方法最终结束后执行（盖棺定论）

环绕通知：使用@Around注解标识，使用try…catch…finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

各种通知的执行顺序

Spring版本5.3.x以前：

前置通知

目标操作

后置通知

返回通知或异常通知

Spring版本5.3.x以后：

前置通知

目标操作

返回通知或异常通知

后置通知

3.4.5、切入点表达式语法

① 作用② 语法细节

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

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

例如：*.Hello匹配com.Hello，不匹配com.jingchao.Hello

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

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

在类名的部分，可以使用*号代替类名的一部分

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

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

在方法名部分，可以使用*号代替方法名的一部分

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

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

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

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

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

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

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

例如：execution(* int …Service.*(…, int)) 错误

3.4.6、重用切入点表达式

① 声明

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

② 在同一个切面中使用

@Before("pointCut()")
public void beforeAdviceMethod(JoinPoint joinPoint){
    // 获取连接点对应的方法的签名信息
    Signature signature = joinPoint.getSignature();
    // 获取连接点对应方法的参数
    Object[] args = joinPoint.getArgs();
    System.out.println("LoggerAspect, 方法 " + signature.getName() + "，参数：" + Arrays.toString(args));
}

③ 在不同切面中使用

@Before("com.jingchao.spring.aop.annotation.LoggerAspect.pointCut()")
public void beforeMethod(JoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
  String args = Arrays.toString(joinPoint.getArgs());
  System.out.println("Logger——>前置通知，方法名："+methodName+"，参数："+args);
}

3.4.7、获取通知的相关消息

① 获取连接点消息

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

@Before("pointCut()")
public void beforeAdviceMethod(JoinPoint joinPoint){
    // 获取连接点对应的方法的签名信息
    Signature signature = joinPoint.getSignature();
    // 获取连接点对应方法的参数
    Object[] args = joinPoint.getArgs();
    System.out.println("LoggerAspect, 方法 " + signature.getName() + "，参数：" + Arrays.toString(args));
}

② 获取目标方法的返回值

@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 = "exception")
public void afterThrowAdviceMethod(JoinPoint joinPoint, Exception exception){
    // 获取连接点对应的方法的签名信息
    Signature signature = joinPoint.getSignature();
    System.out.println("LoggerAspect, 方法 "+signature.getName()+"，异常: " + exception);
}

3.4.8、环绕通知

@Around("pointCut()")
public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
    String methodName = joinPoint.getSignature().getName();
  String args = Arrays.toString(joinPoint.getArgs());
    Object result = null;
    try {
        System.out.println("环绕通知 ——> 前置通知");
        // 表示目标对象方法的执行
        result = joinPoint.proceed();
        System.out.println("环绕通知 ——> 返回通知");
    } catch (Throwable e) {
        e.printStackTrace();
        System.out.println("环绕通知 ——> 异常通知");
    }finally {
        System.out.println("环绕通知 ——> 后置通知");
    }

3.4.9、切面的优先级

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

优先级高的切面：外面

优先级低的切面：里面

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

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

@Order(较大的数)：优先级低3.5、基于XML的AOP（了解）

3.5.1、准备工作

参考基于注解的AOP环境

3.5.1、实现

<!-- 扫描组件 -->
<context:component-scan base-package="com.jingchao.spring.aop.xml"></context:component-scan>
<aop:config>
    <!-- 设置一个公共切入点表达式 -->
    <aop:pointcut id="pointCut" expression="execution(* com.jingchao.spring.aop.xml.CalculatorImpl.*(..))"/>
    <!-- 将IOC容器中某个bean设置为切面 -->
    <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="afterThrowAdviceMethod" throwing="exception" pointcut-ref="pointCut"/>
        <aop:around method="aroundAdviceMethod" pointcut-ref="pointCut"/>
    </aop:aspect>
</aop:config>
<aop:config>
    <aop:aspect ref="validateAspect" order="0">
        <aop:before method="beforeMethod" pointcut-ref="pointCut"/>
    </aop:aspect>
</aop:config>

4、声明式事务

4.1、JdbcTemplate

4.1.1、简介

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

4.1.2、准备工作

① 加入依赖

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所有需要的jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.19</version>
    </dependency>
    <!-- Spring持久化层支持jar包 -->
    <!--  Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个jar包 -->
    <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.22</version>
    </dependency>
    <!-- Spring 测试相关 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.22</version>
    </dependency>
    <!-- MySQL 驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
  <!-- 数据源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.9</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

② 创建jdbc.properites

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

③ 配置Spring的配置文件

<!-- 引入jdbc.properties文件 -->
<context:property-placeholder location="jdbc.properties"/>
<!-- 配置数据源 -->
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <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>
<!-- 配置JdbcTemplate -->
<bean class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="druidDataSource"/>
</bean>

4.1.3、测试

① 在测试类装配JdbcTemplate

// 指定当前环境测试类在Spring的测试环境中执行，此时可以通过注入的方式直接获取IOC容器中的bean
@RunWith(SpringJUnit4ClassRunner.class)
// 设置Spring测试环境的配置文件
@ContextConfiguration("classpath:spring-jdbc.xml")
public class JdbcTemplateTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

② 测试增删改功能

@Test
public void testInsert(){
  String sql = "insert into t_user values(null, ?, ?, ?, ?, ?)";
  jdbcTemplate.update(sql,"root","1236","18","女","j8912@qq.com");
}

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

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

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

@Test
public void testGetAllUser(){
    String sql = "select * from t_user";
    List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
    userList.forEach(System.out::println);
}

⑤ 查询单行单列的值

@Test
public void testCount(){
    String sql = "select count(*) from t_user";
    Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
    System.out.println(integer);
}

4.2、声明式事务概念

4.2.1、编程式事务

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

Connection conn = ...;
try {
    // 开启事务：关闭事务的自动提交
    conn.setAutoCommit(false);
    // 核心操作
    // 提交事务
    conn.commit();
}catch(Exception e){
    // 回滚事务
    conn.rollBack();
}finally{
    // 释放数据库连接
  conn.close();
}

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

细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。

代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复用。

4.2.2、声明式事务

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

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

好处1：提高开发效率

好处2：消除了冗余的代码

好处3：框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性能等各个方面的优化

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

编程式：自己写代码实现功能

声明式：通过配置让框架实现功能

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

4.3.1、准备工作

① 加入依赖

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所有需要的jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.19</version>
    </dependency>
    <!-- Spring持久化层支持jar包 -->
    <!--  Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个jar包 -->
    <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.22</version>
    </dependency>
    <!-- Spring 测试相关 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.22</version>
    </dependency>
    <!-- MySQL 驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.9</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

② 创建jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

③ 配置Spring的配置文件

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 扫描组件 -->
  <context:component-scan base-package="com.jingchao.spring"/>
  <!-- 引入jdbc.properties文件 -->
  <context:property-placeholder location="jdbc.properties"/>
  <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <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="druidDataSource"/>
  </bean>
</beans>

④ 创建表

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);

⑤ 创建组件

创建BookController

package com.jingchao.spring.controller;
import com.jingchao.spring.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class BookController {
    @Autowired
    private BookService bookService;
    public void buyBook(Integer userId, Integer bookId){
        bookService.buyBook(userId, bookId);
    }
}

创建BookService接口

package com.jingchao.spring.service;
public interface BookService {
    void buyBook(Integer userId, Integer bookId);
}

创建BookServiceImpl实现类

package com.jingchao.spring.service.impl;
import com.jingchao.spring.dao.BookDao;
import com.jingchao.spring.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    @Override
    public void buyBook(Integer userId, Integer bookId) {
        // 查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        // 更新图书的库存
        bookDao.updateStock(bookId);
        // 更新用户余额
        bookDao.updateBalance(userId, price);
    }
}

创建BookDao接口

package com.jingchao.spring.dao;
public interface BookDao {
    /**
     * 根据图书id查询图书价格
     * @param bookId
     * @return
     */
    Integer getPriceByBookId(Integer bookId);
    /**
     * 更新图书的库存
     * @param bookId
     */
    void updateStock(Integer bookId);
    /**
     * 更新用户余额
     * @param userId
     * @param price
     */
    void updateBalance(Integer userId, Integer price);
}

创建BookDaoImpl实现类

package com.jingchao.spring.dao.impl;
import com.jingchao.spring.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public Integer getPriceByBookId(Integer bookId) {
        String sql = "select price from t_book where book_id = ?";
        Integer result = jdbcTemplate.queryForObject(sql, Integer.class, bookId);
        return result;
    }
    @Override
    public void updateStock(Integer bookId) {
        String sql = "update t_book set stock = stock - 1 where book_id = ?";
        jdbcTemplate.update(sql, bookId);
    }
    @Override
    public void updateBalance(Integer userId, Integer price) {
        String sql = "update t_user set balance = balance - ? where user_id = ?";
        jdbcTemplate.update(sql, price, userId);
    }
}

4.3.2、测试无事务情况

① 创建测试类

package com.jingchao.spring.test;
import com.jingchao.spring.controller.BookController;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx-annotation.xml")
public class TxByAnnotationTest {
    @Autowired
    private BookController bookController;
    @Test
    public void testButBook(){
        bookController.buyBook(1,1);
    }
}

② 模拟场景

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

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

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

购买图书之后，用户的余额为-30，数据库中余额字段设置了无符号，因此无法将-30插入到余额字段此时执行sql语句会抛出SQLException

③ 观察结果

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

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

4.3.3、加入事务

① 添加事务配置

在Spring配置文件中添加如下配置

<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="druidDataSource"/>
</bean>
<!--
  开启事务的注解驱动
  将使用@Transactional注解的所标识的方法或类中所有的方法使用事务进行管理
  transaction-manager属性：设置事务管理的id
  若事务管理器的bean的id默认是transactionManager，则该属性可以不写
  -->
<tx:annotation-driven transaction-manager="transactionManager"/>

注意：导入的名称空间需要tx结尾，如下
② 添加事务注解

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

③ 观查结果

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

4.3.4、@Transactional注解标识的位置

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

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

4.3.5、事务属性：只读

① 介绍

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

② 使用方式

@Transactional(readOnly = true)
public void buyBook(Integer userId, Integer bookId) {
    // 查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    // 更新图书的库存
    bookDao.updateStock(bookId);
    // 更新用户余额
    bookDao.updateBalance(userId, price);
}

③ 注意

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

Caused by: java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed

4.3.6、事务属性：超时

① 介绍

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

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

② 使用方式

@Transactional(timeout = 3)
public void buyBook(Integer userId, Integer bookId) {
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    // 更新图书的库存
    bookDao.updateStock(bookId);
    // 更新用户余额
    bookDao.updateBalance(userId, price);
}

③ 观察结果

执行过程中抛出异常：

org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Thu Sep 08 14:57:12 CST 2022

4.3.7、事务属性：回滚策略

① 介绍

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

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

rollbackFor属性：需要设置一个Class类型的对象

rollbackForClassName属性：需要设置一个字符串类型的全类名

noRollbackFor属性：需要设置一个Class类型的对象

rollbackFor属性：需要设置一个字符串类型的全类名

② 使用方式

@Transactional(noRollbackFor = ArithmeticException.class)
public void buyBook(Integer userId, Integer bookId) {
    // 查询图书的价格
    Integer price = bookDao.getPriceByBookId(bookId);
    // 更新图书的库存
    bookDao.updateStock(bookId);
    // 更新用户余额
    bookDao.updateBalance(userId, price);
    System.out.println(1/0);
}

③ 观察结果

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

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

① 介绍

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

隔离级别一共有四种：

读未提交：READ UNCOMMITTED

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

读已提交：READ COMMITTED、

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

可重复读：REPEATABLE READ

确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。

串行化：SERIALIZABLE

确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

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

隔离级别	脏读	不可重复读	幻读
READ UNCOMMITTED	有	有	有
READ COMMITTED	无	有	有
REPEATABLE READ	无	无	有
SERIALIZABLE	无	无	无

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

隔离级别	Oracle	MySQL
READ UNCOMMITTED	×	√
READ COMMITTED	√（默认）	√
REPEATABLE READ	×	√（默认）
SERIALIZABLE	√	√

② 使用方式

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

SSM 之 Spring（上）

热门文章

最新文章

相关课程

相关电子书

相关实验场景