从前慢现在也慢

这个屌丝很懒，什么也没留下！

热门标签

学习Spring，这篇就够了_spring学习

作者：从前慢现在也慢 | 2024-04-21 06:17:31

踩

spring学习

第一章 Spring概述

1.1 概述

Spring：出现在2002年左右，降低企业级开发难度。帮助进行模块之间、类与类之间的管理，帮助开发人员创建对象，管理对象之间的关系。
2003年传入国内，被大量使用。
2017出现新的流行框架SpringBoot，核心思想与Spring相同。
核心技术：IoC、AOP，能使模块之间、类之间解耦合。
依赖：class A使用class B的属性或方法，称之为class A依赖class B。
官网：spring.io

1.2 优点

（1）轻量：Spring的所需要的jar包都非常小，一般1M以下，几百kb。核心功能所需要的jar包总共3M左右。
Spring框架运行占有资源少，运行效率高，不依赖其他jar。
（2）针对接口编程，解耦合
（3） AOP 编程的支持
（4）方便集成各种优秀框架
2，3，4的优点在接下来的学习中体会。

1.3 Spring 体系结构

Spring 由 20 多个模块组成，它们可以分为数据访问/集成（Data Access/Integration）、 Web、面向切面编程（AOP, Aspects）、提供JVM的代理（Instrumentation）、消息发送（Messaging）、核心容器（Core Container）和测试（Test）。

Spring体系结构

第二章 IoC控制反转

控制反转（IoC，Inversion of Control），是一个概念，是一种思想。指将传统上由程序代码直接操控的对象调用权交给容器，通过容器来实现对象的装配和管理。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。通过容器实现对象的创建，属性赋值，依赖的管理。
控制：创建对象，对象的属性赋值，对象之间的关系管理。
反转：把原来的开发人员管理，创建对象的权限转移给代码之外的容器实现。由容器代替开发人员管理对象。创建对象，给属性赋值。
正转：由开发人员在代码中，使用new 构造方法创建对象，开发人员主动管理对象。

public static void main(String args[]){
            Student student = new Student(); // 在代码中， 创建对象。--正转。
}
1
2
3

容器：是一个服务器软件，一个框架（spring）

java中创建对象有哪些方式：

1. 构造方法 ， new Student（）
2. 反射
3. 序列化
4. 克隆
5. ioc ：容器创建对象
6. 动态代理
1
2
3
4
5
6

为什么要使用 ioc ：目的就是减少对代码的改动，也能实现不同的功能。实现解耦合。

Ioc 的实现：
➢ 依赖查找：DL( Dependency Lookup ),容器提供回调接口和上下文环境给组件。
➢ 依赖注入：DI(Dependency Injection)，程序代码不做定位查询，这些工作由容器自行完成。

Spring 框架使用依赖注入（DI）实现 IoC。
spring底层创建对象，使用的是反射机制。spring是一个容器，管理对象，给属性赋值，底层是反射创建对象。
之前学习到的应用控制反转的实例：Servlet对象的创建管理，这一工作完全交给了Web容器。

2.1 Spring的第一个程序

在这里插入图片描述

2.1.1 创建Maven项目，导入Spring依赖

(Maven项目采用quickstart模板，建立好resources目录)

<dependencies>
     <!--Spring的依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
  </dependencies>
1
2
3
4
5
6
7
8

2.1.2 创建业务接口与实现类

接口：

public interface SomeService {
    void doSome();
}
1
2
3

实现类：

public class SomeServiceImpl implements SomeService {

    public SomeServiceImpl() {
        System.out.println("SomeServiceImpl的无参数构造方法");
    }

    @Override
    public void doSome() {
        System.out.println("执行了SomeServiceImpl的doSome()方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11

2.1.3 创建spring配置文件

在 src/main/resources/目录现创建一个 xml 文件，文件名可以随意，但 Spring 建议的名称为 applicationContext.xml。 IDEA已经为我们设计好了Spring配置文件的模板：
右击resources–>new–>XML configuration file–>Spring Config
模板如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>
1
2
3
4
5
6
7

注意，Spring 配置文件中使用的约束文件为 xsd 文件。作用与Mybatis的sql映射文件的dtd约束文件类似，但xsd约束作用更强：

<beans/>是配置文件的根标签。在Spring中，java对象称之为bean。在这个标签下进行java对象的注册：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--告诉spring创建对象
        声明bean ， 就是告诉spring要创建某个类的对象
        id:对象的自定义名称，唯一值。 spring通过这个名称找到对象
        class:类的全限定名称（不能是接口，因为spring是反射机制创建对象，必须使用类）

        spring就完成 SomeService someService = new SomeServiceImpl();
        spring是把创建好的对象放入到map中， spring框架有一个map存放对象的。
           springMap.put(id的值， 对象）；
           例如 springMap.put("someService", new SomeServiceImpl());

        一个bean标签声明一个对象。
    -->
    <bean id="someService" class="com.bjpowernode.service.impl.SomeServiceImpl" />

    <bean id="someService1" class="com.bjpowernode.service.impl.SomeServiceImpl" scope="prototype"/>

    <!--
       spring能创建一个非自定义类的对象吗， 创建一个存在的某个类的对象。
    -->
    <bean id="mydate" class="java.util.Date" />

</beans>
<!--
   spring的配置文件
   1.beans : 是根标签，spring把java对象成为bean。
   2.spring-beans.xsd 是约束文件，和mybatis指定  dtd是一样的。
-->
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

声明java对象交给Spring创建和管理，这个步骤称之为声明bean。

< bean>等同于: SomeService someService = new com.bjpowernode.service.SomeServiceImpl();

然后将创建的对象是放入到Spring的容器（Map<id,对象>）：
```
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap(16);
factoryBeanObjectCache.put("service",someService);
1
2
```
< bean/>标签的属性：
class:类的全限定名称，不能是接口（Spring使用反射创建对象）；class可以是非自定义的对象，例如”java.util.Date“,依然可以被Spring创建对象。
id:自定义的对象名称，要求是唯一值。表示在Spring中的对象名称，通过这个名称可以从Spring中找到对象，获取对象。
scope：指定bean对象的作用域（对象的存在范围和可见性）。可取值：
1. 单例：singleton , 默认值，表示叫这个名称的对象在spring容器中只有一个。
2. 原型：prototype , 表示每次使用getBean()都创建一个新的对象。

类路径的根目录：类路径就是在编译生成后的target目标目录下的classes作为根目录。

2.1.4 创建测试类

 /**
  * spring默认创建对象的时间：在创建spring的容器时，会创建配置文件中的所有的对象。
  * spring创建对象：默认调用的是无参数构造方法
  */
@Test
 public void test02(){
     //使用spring容器创建的对象
    //1.指定spring配置文件的名称，配置文件是在类路径的根目录之下
    String config="beans.xml";
    //2.创建表示spring容器的对象， ApplicationContext
    // ApplicationContext就是表示Spring容器，通过容器获取对象了
    // ClassPathXmlApplicationContext:表示从类路径中加载spring的配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);

    //从容器中获取某个对象， 你要调用对象的方法
    //getBean("配置文件中的bean的id值")
    SomeService service = (SomeService) ac.getBean("someService");

    //使用spring创建好的对象
    service.doSome();

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

创建Spring的容器对象.根据Spring配置文件的位置，使用接口的不同实现类
1.如果Spring的配置文件是在类路径(classpath)，使用ClassPathXmlApplicationContext
2.如果Spring的配置文件是放在项目的根之下(与src、target同级目录)，使用FileSystemXmlApplicationContext

2.1.5 Spring创建对象的时机

请添加图片描述
进入Application ac = new ClassPathXmlApplicationContext(config);
在这个类的构造方法执行时会去读取类路径下的这个config配置文件

然后就来到了config这个配置文件，从上到下读取，当读取到bean标签时，spring就会完成对象的创建工作，通过反射机制来调用这个Impl这个类的构造方法创建对象，对象的名字叫someService并且把创建好的对象放到map之中，那么这样这个标签的功能就实现了，对象就创建好了。当创建ac对象时，通过构造方法读取配置文件时，就已经创建了java对象。
请添加图片描述

当到ac.getBean()的时候，我们是从容器中拿到someService这个对象，也就是从容器的map中去获取，把它赋值给我们的程序代码中。然后就可以调用方法了。

spring默认创建对象的时间：在创建spring的容器时，会创建配置文件中的所有的对象。
spring创建对象：默认调用的是无参数构造方法

2.2 Bean的装配

2.2.1 默认装配方式

当我们创建ApplicationContext对象时（2.1.4中）,Spring会读取配置文件的< bean/>并执行对应类的无参构造器。
在这些类的无参构造器中加一条输出语句可以验证以上结论。

2.2.2 容器中Bean的作用域

当通过 Spring 容器创建一个 Bean 实例时，不仅可以完成 Bean 的实例化，还可以通过 scope 属性，为 Bean 指定特定的作用域。Spring 支持多种作用域。
（1）singleton：单例模式。即在整个 Spring 容器中，使用 singleton 定义的 Bean 将是单例的，叫这个名称的对象只有一个实例。默认为单例的。
（2）prototype：原型模式。即每次使用 getBean 方法获取的同一个的实例都是一个新的实例。
（3）request：对于每次 HTTP 请求，都将会产生一个不同的 Bean 实例。（4）session：对于每个不同的 HTTP session，都将产生一个不同的 Bean 实例。

注意：

对于 scope 的值 request、session 只有在 Web 应用中使用 Spring 时，该作用域才有效。
对于 scope 为 singleton 的单例模式，该 Bean 是在容器被创建时即被装配好了；对于 scope 为 prototype的原型模式，Bean 实例是在代码中使用该 Bean 实例时才进行装配的。

现在我们只是自动创建了对象，没有给对象的属性赋值。2.3和2.4介绍了两种给属性赋值的方法。

2.3 基于XML的DI

2.3.1 注入分类

1.set注入

set 注入也叫设值注入，是指通过 setter 方法传入被调用者的实例属性进行赋值。这种注入方式简单、直观，因而在 Spring 的依赖注入中大量使用。

A.简单类型（基本类型和String类型）

每一个property标签，完成一个属性的赋值。
注意：Spring执行property标签的原理，是执行对象属性值对应的set方法。而并不关心set方法的具体实现和属性是否真的存在。也就是就算属性不存在，但是提供了其setter方法，就可以执行调用其setter方法进行操作，不会报错。

配置文件：

    <!--声明student对象
        注入：就是赋值的意思
        简单类型： spring中规定java的基本数据类型和String都是简单类型。
        di:给属性赋值
        1. set注入（设值注入） ：spring调用类的set方法， 你可以在set方法中完成属性赋值
         1）简单类型的set注入
            <bean id="xx" class="yyy">
               <property name="属性名字" value="此属性的值"/>
               一个property只能给一个属性赋值
               <property....>
            </bean>
    -->
    <bean id="myStudent" class="com.bjpowernode.ba01.Student" >
        <property name="name" value="李四lisi" /><!--setName("李四")-->
        <property name="age" value="22" /><!--setAge(21)-->
        <property name="email" value="lisi@qq.com" /><!--setEmail("lisi@qq.com")-->
    </bean>

    <bean id="mydate" class="java.util.Date">
        <property name="time" value="8364297429" /><!--setTime(8364297429)-->
    </bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

测试类：

@Test
 public void test01(){
    System.out.println("=====test01========");
    String config="ba01/applicationContext.xml";
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);
    //从容器中获取Student对象
    Student myStudent =  (Student) ac.getBean("myStudent");
    System.out.println("student对象="+myStudent);
    Date myDate = (Date) ac.getBean("mydate");
    System.out.println("myDate="+myDate);
}
1
2
3
4
5
6
7
8
9
10
11

B.引用类型

当指定 bean 的某属性值为另一 bean 的实例时，通过 ref 指定它们间的引用关系。ref 的值必须为某 bean 的 id 值。例如：创建一个学校类;

注意：这里的 name=“school” 和 ref="school"的名字没有关系，可以一样，他两不冲突。name是对象的属性，ref是另一个对象的变量名。

并且他们在配置文件的bean中没有位置定义顺序的要求（声明对象不用关心顺序）。因为spring的处理方式很智能，配置文件会加载两次，第一次会把遇到的所以bean标签的对象都创建出，如果在执行过程中发现属性里面的对象找不到，他会第二次扫描这个配置文件，找到创建好的对象再赋值。

public class School {

    private String name;
    private String address;

    public void setName(String name) {
        this.name = name;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

然后再在学生类中添加School类型的属性：

public class Student {
    private String name;
    private int age;
    //声明一个引用类型
    private School school;
    public Student() {
        System.out.println("spring会调用类的无参数构造方法创建对象");
    }
    // 包名.类名.方法名称
    // com.bjpowernode.ba02.Student.setName()
    public void setName(String name) {
        System.out.println("setName:"+name);
        this.name = name;
    }
    public void setAge(int age) {
        System.out.println("setAge:"+age);
        this.age = age;
    }
    public void setSchool(School school) {
        System.out.println("setSchool:"+school);
        this.school = school;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}
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

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--声明student对象
    注入：就是赋值的意思
    简单类型： spring中规定java的基本数据类型和String都是简单类型。
    di:给属性赋值
    1. set注入（设值注入） ：spring调用类的set方法， 你可以在set方法中完成属性赋值
     1）简单类型的set注入
        <bean id="xx" class="yyy">
           <property name="属性名字" value="此属性的值"/>
           一个property只能给一个属性赋值
           <property....>
        </bean>
     2) 引用类型的set注入 ： spring调用类的set方法
       <bean id="xxx" class="yyy">
          <property name="属性名称" ref="bean的id(对象的名称)" />
       </bean>
-->
<bean id="myStudent" class="com.bjpowernode.ba02.Student" >
    <property name="name" value="李四" />
    <property name="age" value="26" />
    <!--引用类型-->
    <property name="school" ref="mySchool" /><!--setSchool(mySchool)-->
</bean>
<!--声明School对象-->
<bean id="mySchool" class="com.bjpowernode.ba02.School">
    <property name="name" value="北京大学"/>
    <property name="address" value="北京的海淀区" />
</bean>
</beans>   
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

2.构造注入

执行类的有参构造，在构造对象的同时给属性赋值。

< constructor-arg />标签中用于指定参数的属性有：
➢ name：指定参数名称,指的是构造方法中的形参。
➢ index：指明该参数对应着构造器的第几个参数，从 0 开始。不过，该性不要也行，但要注意，若参数类型相同，或之间有包含关系，则需要保证赋值顺序要与构造器中的参数顺序一致。

注意：这里使用name属性时，顺序可以打乱，不必按构造方法的顺序给对象的属性赋值。但是在使用index且缺省index属性定义时，不能打乱顺序给属性赋值，要严格按照构造方法的参数顺序给属性赋值。

1.给student添加有参构造

/**
 * 创建有参数构造方法
 */
public Student(String myname,int myage, School mySchool){
    System.out.println("=====Student有参数构造方法======");
    //属性赋值
    this.name  = myname;
    this.age  = myage;
    this.school = mySchool;

}
1
2
3
4
5
6
7
8
9
10
11

2.配置文件

<!--
	2.构造注入：spring调用类有参数构造方法，在创建对象的同时，在构造方法中给属性赋值。
      构造注入使用 <constructor-arg> 标签。
          <constructor-arg> 标签：一个<constructor-arg>表示构造方法一个参数。
          <constructor-arg> 标签属性：
             name:表示构造方法的形参名
             index:表示构造方法的参数的位置，参数从左往右位置是 0 ， 1 ，2的顺序
             value：构造方法的形参类型是简单类型的，使用value
             ref：构造方法的形参类型是引用类型的，使用ref
-->
<!--使用name属性实现构造注入-->
<bean id="myStudent" class="com.bjpowernode.ba03.Student" >
    <constructor-arg name="myage" value="20" />
    <constructor-arg name="mySchool" ref="myXueXiao" />
    <constructor-arg name="myname" value="周良"/>
</bean>
<!--声明School对象-->
<bean id="myXueXiao" class="com.bjpowernode.ba03.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京的海淀区" />
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<!--使用index属性-->
<bean id="myStudent2" class="com.bjpowernode.ba03.Student">
    <constructor-arg index="1" value="22" />
    <constructor-arg index="0" value="李四" />
    <constructor-arg index="2" ref="myXueXiao" />
</bean>

<!--省略index-->
<bean id="myStudent3" class="com.bjpowernode.ba03.Student">
    <constructor-arg  value="张强强" />
    <constructor-arg  value="22" />
    <constructor-arg  ref="myXueXiao" />
</bean>
<!--声明School对象-->
<bean id="myXueXiao" class="com.bjpowernode.ba03.School">
    <property name="name" value="清华大学"/>
    <property name="address" value="北京的海淀区" />
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.3.2引用类型自动注入

对于引用类型属性的注入，也可不在配置文件中显示的注入。可以通过为< bean/>标签设置 autowire 属性值，为引用类型属性进行隐式自动注入（默认是不自动注入引用类型属性）。根据自动注入判断标准的不同，可以分为两种：

byName：根据名称自动注入
byType：根据类型自动注入

1.byname方式自动注入

当配置文件中被调用者 bean 的 id 值与代码中调用者 bean 类的（set方法后缀的）属性名相同时，可使用 byName 方式，让容器自动将被调用者 bean 注入给调用者 bean。容器是通过调用者的 bean 类的属性名与配置文件的被调用者 bean 的 id 进行比较而实现自动注入的。
请添加图片描述

<!--
        引用类型的自动注入： spring框架根据某些规则可以给引用类型赋值。不用你在给引用类型赋值了
   使用的规则常用的是byName, byType.
   1.byName(按名称注入) ： java类中引用类型的属性名和spring容器中（配置文件）<bean>的id名称一样，
                          且数据类型是一致的，这样的容器中的bean，spring能够赋值给引用类型。
     语法：
     <bean id="xx" class="yyy" autowire="byName">
        简单类型属性赋值
     </bean>
-->
 <!--byName-->
    <bean id="myStudent" class="com.bjpowernode.ba04.Student"  autowire="byName">
        <property name="name" value="李四" />
        <property name="age" value="26" />
        <!--引用类型-->
        <!--<property name="school" ref="mySchool" />-->
    </bean>

    <!--声明School对象-->
    <bean id="school" class="com.bjpowernode.ba04.School">
        <property name="name" value="清华大学"/>
        <property name="address" value="北京的海淀区" />
    </bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.bytype方式自动注入

使用 byType 方式自动注入，要求：配置文件中被调用者 bean 的 class 属性指定的类，要与代码中调用者 bean 类的某引用类型属性类型同源。即要么相同，要么有 is-a 关系（子类，或是实现类）。但这样的同源的被调用 bean 只能有一个。多于一个，容器就不知该匹配哪一个了。就会报错。
请添加图片描述

同源就是一类的意思：
1.java类中引用类型的数据类型和bean的class的值是一样的。
2.java类中引用类型的数据类型和bean的class的值父子类关系的。
3.java类中引用类型的数据类型和bean的class的值接口和实现类关系的

<!--
   2.byType(按类型注入) ： java类中引用类型的数据类型和spring容器中（配置文件）<bean>的class属性
                          是同源关系的，这样的bean能够赋值给引用类型
     同源就是一类的意思：
      1.java类中引用类型的数据类型和bean的class的值是一样的。
      2.java类中引用类型的数据类型和bean的class的值父子类关系的。
      3.java类中引用类型的数据类型和bean的class的值接口和实现类关系的
     语法：
     <bean id="xx" class="yyy" autowire="byType">
        简单类型属性赋值
     </bean>

     注意：在byType中， 在xml配置文件中声明bean只能有一个符合条件的，
          多余一个是错误的
-->
<!--byType-->
<bean id="myStudent" class="com.bjpowernode.ba05.Student"  autowire="byType">
    <property name="name" value="张飒" />
    <property name="age" value="26" />
    <!--引用类型-->
    <!--<property name="school" ref="mySchool" />-->
</bean>

<!--声明School对象-->
<bean id="mySchool" class="com.bjpowernode.ba05.School">
    <property name="name" value="人民大学"/>
    <property name="address" value="北京的海淀区" />
</bean>

<!--声明School的子类-->
<!--<bean id="primarySchool" class="com.bjpowernode.ba05.PrimarySchool">
    <property name="name" value="北京小学" />
    <property name="address" value="北京的大兴区" />
</bean>-->
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

2.3.3为应用指定多个Spring配置文件

在实际应用里，随着应用规模的增加，系统中 Bean 数量也大量增加，导致配置文件变得非常庞大、臃肿。为了避免这种情况的产生，提高配置文件的可读性与可维护性，可以将 Spring 配置文件分解成多个配置文件。
包含关系的配置文件：多个配置文件中有一个总文件，总配置文件将各其它子文件通过**< import/>**引入。在 Java 代码中只需要使用总配置文件对容器进行初始化即可。例如：
请添加图片描述

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
         包含关系的配置文件：
         spring-total表示主配置文件 ： 包含其他的配置文件的，主配置文件一般是不定义对象的。
         语法：<import resource="其他配置文件的路径" />
         关键字："classpath:" 表示类路径（class文件所在的目录），
               在spring的配置文件中要指定其他文件的位置， 需要使用classpath，告诉spring到哪去加载读取文件。
    -->
    <!--加载的是文件列表-->
    <!--
    <import resource="classpath:ba06/spring-school.xml" />
    <import resource="classpath:ba06/spring-student.xml" />
    -->
    <!--
       在包含关系的配置文件中，可以通配符（*：表示任意字符）
       注意： 主的配置文件名称不能包含在通配符的范围内（不能叫做spring-total.xml）
    -->
    <import resource="classpath:ba06/spring-*.xml" />
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

也可使用通配符 *。但，此时要求父配置文件名不能满足*所能匹配的格式，否则将出现循环递归包含。就本例而言，父配置文件不能匹配 spring-*.xml 的格式，即不能起名为 spring-total.xml。
请添加图片描述

如果直接在类路径下是包含不到其他包的

2.4基于注解的DI

请添加图片描述

通过以下四个步骤实现DI：
1. 创建Maven项目，在pom.xml 加入 AOP 依赖：

<!--spring依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>
1
2
3
4
5
6

如果你在pom.xml中添加了spring-context，那此依赖自动下载包含AOP，无需再次添加。

2.在类中添加注解

@Component("myStudent")
public class Student {

    private String name;
    private Integer age;
    public Student() {
        System.out.println("==student无参数构造方法===");
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.创建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">
    <!--声明组件扫描器(component-scan),组件就是java对象
        base-package：指定注解在你的项目中的包名。
        component-scan工作方式： spring会扫描遍历base-package指定的包，
           把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

       加入了component-scan标签，配置文件的变化：
        1.加入一个新的约束文件spring-context.xsd
        2.给这个新的约束文件起个命名空间的名称
    -->
    <context:component-scan base-package="com.bjpowernode.ba02" />
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.使用注解创建对象，创建容器ApplicationContext

public class MyTest01 {
    @Test
    public void test01(){
        String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取对象
        Student student = (Student) ctx.getBean("myStudent");
        System.out.println("student="+student);
    }
}
1
2
3
4
5
6
7
8
9
10

2.4.1 指定包的三种方式

<!--声明组件扫描器(component-scan),组件就是java对象
    base-package：指定注解在你的项目中的包名。
    component-scan工作方式： spring会扫描遍历base-package指定的包，
       把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

   加入了component-scan标签，配置文件的变化：
    1.加入一个新的约束文件spring-context.xsd
    2.给这个新的约束文件起个命名空间的名称
-->
<context:component-scan base-package="com.bjpowernode.ba01" />

<!--指定多个包的三种方式-->
<!--第一种方式：使用多次组件扫描器，指定不同的包-->
<context:component-scan base-package="com.bjpowernode.ba01"/>
<context:component-scan base-package="com.bjpowernode.ba02"/>

<!--第二种方式：使用分隔符（;或,）分隔多个包名 还可以使用空格，不建议使用空格。-->
<context:component-scan base-package="com.bjpowernode.ba01;com.bjpowernode.ba02" />

<!--第三种方式：指定父包-->
<context:component-scan base-package="com.bjpowernode" />
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.4.2 定义Bean的注解@Component

@Component: 创建类的对象，等同于< bean />，默认是单例对象
属性： value 表示对象的名称（的id）
位置：在类定义的上面，表示创建此类的对象。

例如：@Component(value = “myStudent”)等价于< bean id=“myStudent” class=“com.bjpowernode.ba01.Student”/>

/**
 * @Component: 创建对象的， 等同于<bean>的功能
 *     属性：value 就是对象的名称，也就是bean的id值，
 *          value的值是唯一的，创建的对象在整个spring容器中就一个
 *     位置：在类的上面
 *
 *  @Component(value = "myStudent")等同于
 *   <bean id="myStudent" class="com.bjpowernode.ba01.Student" />
 *
 *  spring中和@Component功能一致，创建对象的注解还有：
 *  1.@Repository（用在持久层类的上面） : 放在dao的实现类上面，
 *               表示创建dao对象，dao对象是能访问数据库的。
 *  2.@Service(用在业务层类的上面)：放在service的实现类上面，
 *              创建service对象，service对象是做业务处理，可以有事务等功能的。
 *  3.@Controller(用在控制器的上面)：放在控制器（处理器）类的上面，创建控制器对象的，
 *              控制器对象，能够接受用户提交的参数，显示请求的处理结果。
 *  以上三个注解的使用语法和@Component一样的。 都能创建对象，但是这三个注解还有额外的功能。
 *  @Repository，@Service，@Controller是给项目的对象分层的。
 */
//使用value属性，指定对象名称
//@Component(value = "myStudent")

//省略value
@Component("myStudent")

//不指定对象名称，由spring提供默认名称: 类名的首字母小写
//@Component
public class Student {
    private String name;
    private Integer age;
    public Student() {
        System.out.println("==student无参数构造方法===");
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
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

另外，Spring 还提供了 3 个创建对象的注解：
➢ @Repository 用于对 DAO 实现类进行注解
➢ @Service 用于对 Service 实现类进行注解
➢ @Controller 用于对 Controller 实现类进行注解

这三个注解与@Component 都可以创建对象，但这三个注解还有其他的含义，@Service 创建业务层对象，业务层对象可以加入事务功能，@Controller 注解创建的对象可以作为处理器接收用户的请求。
@Repository，@Service，@Controller 是对@Component 注解的细化，标注不同层的对象。即持久层对象，业务层对象，控制层对象。

@Component 不指定 value 属性，bean 的 id 是类名的首字母小写。

2.4.4 简单类型属性注入@Value

需要在属性上使用注解@Value，该注解的 value 属性用于指定要注入的值。

@Value: 简单类型的属性赋值
属性： value 是String类型的，表示简单类型的属性值
位置： 1.在属性定义的上面，无需set方法，推荐使用。
2.在set方法的上面

@Component("myStudent")
public class Student {

    /**
     * @Value: 简单类型的属性赋值
     *   属性： value 是String类型的，表示简单类型的属性值
     *   位置： 1.在属性定义的上面，无需set方法，推荐使用。
     *         2.在set方法的上面
     */
    @Value("李四" )
    private String name;
    private Integer age;
    public Student() {
        System.out.println("==student无参数构造方法===");
    }
    @Value("30")
    public void setAge(Integer age) {
        System.out.println("setAge:"+age);
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age;
    }
}
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

2.4.5 byType自动注入@Autowired

需要在引用属性上使用注解@Autowired，该注解默认使用按类型自动装配 Bean 的方式。

@Autowired:默认使用的是byType自动注入。（优先自动匹配相同数据类型的对象，找不到再找同源类型的对象，而不是像xml一样同时找同源类。）
位置：1）在属性定义的上面，无需set方法，推荐使用
2）在set方法的上面

@Component("myStudent")
public class Student {
    @Value("李四" )
    private String name;
    @Value("20" )
    private Integer age;
    /**
     * 引用类型
     * @Autowired: spring框架提供的注解，实现引用类型的赋值。
     * spring中通过注解给引用类型赋值，使用的是自动注入原理 ，支持byName, byType
     * @Autowired:默认使用的是byType自动注入。
     *  位置：1）在属性定义的上面，无需set方法， 推荐使用
     *       2）在set方法的上面
     */
    @Autowired
    private School school;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.4.6 byName自动注入@Autowired与@Qualifier

需要在引用属性上联合使用注解@Autowired 与@Qualifier。@Qualifier 的 value 属性用于指定要匹配的 Bean 的 id 值。类中无需 set 方法，也可加到 set 方法上。

spring中通过注解给引用类型赋值，使用的是自动注入原理，支持byName, byType，如果要使用byName方式，需要做的是：
1.在属性上面加入@Autowired
2.在属性上面加入@Qualifier(value=“bean的id”) ：表示使用指定名称的bean完成赋值。

@Component("myStudent")
public class Student {
    @Value("李四" )
    private String name;
    @Value("30")
    private Integer age;
    /**
     * 引用类型
     * @Autowired: spring框架提供的注解，实现引用类型的赋值。
     * spring中通过注解给引用类型赋值，使用的是自动注入原理 ，支持byName, byType
     *  如果要使用byName方式，需要做的是：
     *  1.在属性上面加入@Autowired
     *  2.在属性上面加入@Qualifier(value="bean的id") ：表示使用指定名称的bean完成赋值。
     */
    //byName自动注入
    @Autowired
    @Qualifier("mySchool")
    private School school;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Component("mySchool")
public class School {
    @Value("人民大学")
    private String name;
    @Value("北京的海淀区")
    private String address;   
}
1
2
3
4
5
6
7

@Autowired 还有一个属性 required，默认值为 true，表示当匹配失败后，会终止程序运行。若将其值设置为 false，则匹配失败，将被忽略，未匹配的属性值为 null。

@Component("myStudent")
public class Student {
    @Value("李四" )
    private String name;
    @Value("30")
    private Integer age;
    //byName自动注入
    @Autowired(required = false)
    @Qualifier("mySchool")
    private School school;   
}
1
2
3
4
5
6
7
8
9
10
11

2.4.7 JDK注解@Resource自动注入

Spring提供了对 jdk中@Resource注解的支持。@Resource 注解既可以按名称匹配Bean，也可以按类型匹配 Bean。默认是按名称注入。使用该注解，要求 JDK 必须是 6 及以上版本。 @Resource 可在属性上，也可在 set 方法上。

1.byType注入引用类型属性

@Resource 注解若不带任何参数，采用默认按名称的方式注入，按名称不能注入 bean，则会按照类型进行 Bean 的匹配注入。

@Resource
private School school;
1
2

请添加图片描述

2.byName注入引用类型属性

@Resource 注解指定其 name 属性，则 name 的值即为按照名称进行匹配的 Bean 的 id。

@Resource("mySchool")
private School school;
1
2

请添加图片描述

2.4.8 注解与XML的对比

注解优点是：

方便
直观
高效（代码少，没有配置文件的书写那么复杂）。

其弊端也显而易见：以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的。

XML 方式优点是：

配置和代码是分离的
在 xml 中做修改，无需编译代码，只需重启服务器即可将新的配置加载。

xml 的缺点是：编写麻烦，效率低，大型项目过于复杂。

2.4.9 属性配置文件注入

<!--加载属性配置文件-->
<context:property-placeholder location="classpath:test.properties" />
1
2

@Component("myStudent")
public class Student {
    @Value("${myname}") //使用属性配置文件中的数据
    private String name;

    @Value("${myage}")  //使用属性配置文件中的数据
    private Integer age;

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(Integer age) {
        System.out.println("setAge:"+age);
        this.age = age;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

myname=lisi
myage=20
1
2

请添加图片描述

第三章 AOP面向切面编程

3.1不使用OP的开发方式

3.1.1动态代理

实现方式：

jdk动态代理：使用jdk中的Proxy，Method，InvocaitonHanderl创建代理对象。
jdk动态代理要求目标类必须实现接口

cglib动态代理：第三方的工具库，创建代理对象，原理是继承。通过继承目标类，创建子类。
子类就是代理对象。要求目标类不能是final的，方法也不能是final的

3.1.2.动态代理的作用

1）在目标类源代码不改变的情况下，增加功能。
2）减少代码的重复
3）专注业务逻辑代码
4）解耦合，让你的业务功能和日志，事务非业务功能分离。

3.2AOP概述

3.2.1AOP简介

AOP（Aspect Orient Programming），面向切面编程。面向切面编程是从动态角度考虑程序运行过程。 AOP 底层，就是采用动态代理模式实现的。采用了两种代理：JDK 的动态代理，与 CGLIB 的动态代理。Aop就是动态代理的规范化，把动态代理的实现步骤，方式都定义好了，让开发人员用一种统一的方式，使用动态代理。

AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，可通过运行期动态代理实现程序功能的统一维护的一种技术。AOP 是 Spring 框架中的一个重要内容。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

面向切面编程，就是将交叉业务逻辑封装成切面，利用 AOP 容器的功能将切面织入到主业务逻辑中。所谓交叉业务逻辑是指，通用的、与主业务逻辑无关的代码，如安全检查、事务、日志、缓存等。若不使用 AOP，则会出现代码纠缠，即交叉业务逻辑与主业务逻辑混合在一起。这样，会使主业务逻辑变的混杂不清。

例如，转账，在真正转账业务逻辑前后，需要权限控制、日志记录、加载事务、结束事务等交叉业务逻辑，而这些业务逻辑与主业务逻辑间并无直接关系。但，它们的代码量所占比重能达到总代码量的一半甚至还多。它们的存在，不仅产生了大量的“冗余”代码，还大大干扰了主业务逻辑—转账。

3.2.2面向切面编程对有什么好处？

1.减少重复；

2.专注业务；

注意：面向切面编程只是面向对象编程的一种补充。

请添加图片描述

3.2.3AOP相关术语

Aspect: 切面，给你的目标类增加的功能，就是切面。像上面用的日志，事务都是切面。切面的特点：一般都是非业务方法，独立使用的。
Orient：面向，对着。
Programming：编程。

iop面向接口编程、oop: 面向对象编程

怎么理解面向切面编程？
1）需要在分析项目功能时，找出切面。
2）合理的安排切面的执行时间（在目标方法前，还是目标方法后）
3）合理的安全切面执行的位置，在哪个类，哪个方法增加增强功能

说一个切面有三个关键的要素：
1）切面的功能代码，切面干什么。（what）
2）切面的执行位置，使用Pointcut表示切面执行的位置。（where）
3）切面的执行时间，使用Advice表示时间，在目标方法之前，还是目标方法之后。（when）

请添加图片描述

1.切面（Aspect）

切面泛指交叉业务逻辑。上例中的事务处理、日志处理就可以理解为切面。常用的切面是通知（Advice）。实际就是对主业务逻辑的一种增强。

表示增强的功能，就是一堆代码，完成某个一个功能。非业务功能，常见的切面功能有日志，事务，统计信息，参数检查，权限验证。

2.连接点（JoinPoint）

连接点指可以被切面织入的具体方法。通常业务接口中的方法均为连接点。

连接业务方法和切面的位置。就某类中的业务方法

3.切入点（Pointcut）

切入点指声明的一个或多个连接点的集合。通过切入点指定一组方法。

被标记为 final 的方法是不能作为连接点与切入点的。因为最终的是不能被修改的，不能被增强的。

4.目标对象（Target）

目标对象指将要被增强的对象。即包含主业务逻辑的类的对象。上例中的 StudentServiceImpl 的对象若被增强，则该类称为目标类，该类对象称为目标对象。当然，不被增强，也就无所谓目标不目标了。

5.通知（Advice）

通知表示切面的执行时间，Advice 也叫增强。上例中的 MyInvocationHandler 就可以理解为是一种通知。换个角度来说，通知定义了增强代码切入到目标代码的时间点，是目标方法执行之前执行，还是之后执行等。通知类型不同，切入时间不同。

切入点定义切入的位置，通知定义切入的时间。

3.4 AOP实现

AOP是一个规范，是动态的一个规范化，一个标准
AOP的技术实现框架：

Spring：Spring的AOP实现较为笨重，一般用在事务处理。
aspectJ:一个开源，专门做AOP的框架，隶属于Eclipse基金会。spring框架中集成了aspectj框架。

aspectJ框架实现AOP有两种方式：
1）使用xml配置文件，一般用于配置全局事务。
2）使用注解。一般在项目开发中使用这种方式。

3.5 AspectJ对AOP的实现

3.5.1 AspectJ 的通知类型

切面的执行时间，这个执行时间在规范中叫做Advice(通知，增强)，在aspectj框架中使用注解表示的。也可以使用xml配置文件中的标签：
（1）前置通知
（2）后置通知
（3）环绕通知
（4）异常通知
（5）最终通知

3.5.2 AspectJ 的切入点表达式

AspectJ 定义了专门的表达式用于指定切入点。表达式的原型是：

execution(modifiers-pattern? ret-type-pattern  
					declaring-type-pattern?name-pattern(param-pattern) 
					throws-pattern?)
1
2
3

解释：

modifiers-pattern] 访问权限类型

ret-type-pattern 返回值类型

declaring-type-pattern 包名类名

name-pattern(param-pattern) 方法名(参数类型和参数个数)

throws-pattern 抛出异常类型

？表示可选的部分

以上表达式共 4 个部分。

execution(访问权限 方法返回值 方法声明(参数) 异常类型)

切入点表达式要匹配的对象就是目标方法的方法名。所以，execution 表达式中明显就是方法的签名。注意，表达式中黑色文字表示可省略部分，各部分间用空格分开。在其中可以使用以下符号：

请添加图片描述

3.5.3 AspectJ的开发环境

1.maven 依赖

<dependencies>
<!--单元测试：通过单元测试可以测试每一个方法-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>
<!--Spring的依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.16.RELEASE</version>
</dependency>
<!--aspectj的依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>4.3.16.RELEASE</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.引入AOP约束

在 AspectJ 实现 AOP 时，要引入 AOP 的约束。配置文件中使用的 AOP 约束中的标签，均是 AspectJ 框架使用的，而非 Spring 框架本身在实现 AOP 时使用的。 AspectJ 对于 AOP 的实现有注解和配置文件两种方式，常用是注解方式。（第4、7、8行）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.springframework.org/schema/aop"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>
1
2
3
4
5
6
7
8
9
10

在IDEA中开发，可以省略这一步。在添加aop标签时会自动引入约束文件。

3.5.4 AspectJ 基于注解的 AOP 实现

（1）实现步骤

请添加图片描述

1.创建目标类

业务接口与实现类

public interface SomeService {
    void doSome(String name,Integer age);
}
1
2
3

//目标类
public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name,Integer age) {
        //给doSome方法增加一个功能，在doSome()执行之前， 输出方法的执行时间
        System.out.println("====目标方法doSome()====");
    }
}
1
2
3
4
5
6
7
8

2.创建切面类

类中定义了若干普通方法，将作为不同的通知方法，用来增强功能。

/**
 *  @Aspect : 是aspectj框架中的注解。
 *     作用：表示当前类是切面类。
 *     切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码
 *     位置：在类定义的上面
 */
@Aspect
public class MyAspect {
    /**
     * 定义方法，方法是实现切面功能的。
     * 方法的定义要求：
     * 1.公共方法 public
     * 2.方法没有返回值
     * 3.方法名称自定义
     * 4.方法可以有参数，也可以没有参数。
     *   如果有参数，参数不是自定义的，有几个参数类型可以使用。
     */
    /**
     * @Before: 前置通知注解
     *   属性：value ，是切入点表达式，表示切面的功能执行的位置。
     *   位置：在方法的上面
     * 特点：
     *  1.在目标方法之前先执行的
     *  2.不会改变目标方法的执行结果
     *  3.不会影响目标方法的执行。
     */
    @Before(value = "execution(public void com.bjpowernode.ba01.SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(){
        //就是你切面要执行的功能代码
        System.out.println("前置通知， 切面功能：在目标方法之前输出执行时间："+ new Date());
    }
}
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

3.创建spring配置文件

在定义好切面 Aspect 后，需要通知 Spring 容器，让容器生成“目标类+ 切面”的代理对象。这个代理是由容器自动生成的。只需要在 Spring 配置文件中注册一个基于 aspectj 的自动代理生成器，其就会自动扫描到@Aspect 注解，并按通知类型与切入点，将其织入，并生成代理。

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

    <!--把对象交给spring容器，由spring容器统一创建，管理对象-->
    <!--声明目标对象-->
    <bean id="someService" class="com.bjpowernode.ba08.SomeServiceImpl" />

    <!--声明切面类对象-->
    <bean id="myAspect" class="com.bjpowernode.ba08.MyAspect" />

    <!--声明自动代理生成器：使用aspectj框架内部的功能，创建目标对象的代理对象。
        创建代理对象是在内存中实现的， 修改目标对象的内存中的结构。 创建为代理对象
        所以目标对象就是被修改后的代理对象.
        aspectj-autoproxy:会把spring容器中的所有的目标对象，一次性都生成代理对象。
    -->
    <aop:aspectj-autoproxy />

</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

其工作原理是，<aop:aspectj-autoproxy/>通过扫描找到@Aspect 定义的切面类，再由切面类根据切入点找到目标类的目标方法，再由通知类型找到切入的时间点。

4.创建测试类

public class MyTest01 {

    @Test
    public void test01(){
        String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeService proxy = (SomeService) ctx.getBean("someService");
        //com.sun.proxy.$Proxy8 :jdk动态代理
        System.out.println("proxy:"+proxy.getClass().getName());
        //通过代理的对象执行方法，实现目标方法执行时，增强了功能
        proxy.doSome("lisi",20);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（2）AspectJ 通知注解

请添加图片描述

当连接点匹配成功时，创建的是一个代理对象
请添加图片描述

当匹配不成功时，创建的是一个实现类

1.@Before前置通知-方法有JoinPoint参数

在目标方法执行之前执行。被注解为前置通知的方法，可以包含一个 JoinPoint 类型参数。该类型的对象本身就是切入点表达式。通过该参数，可获取切入点表达式、方法签名、 目标对象等。不光前置通知的方法，可以包含一个 JoinPoint 类型参数，所有的通知方法均可包含该参数。JoinPoint必须是形式参数的第一个。

JoinPoint 代表的是业务方法，这个方法中要加入切面功能，在下面这个例子中，JoinPoint 就是具体的doSome方法。

/**
 *  @Aspect : 是aspectj框架中的注解。
 *     作用：表示当前类是切面类。
 *     切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码
 *     位置：在类定义的上面
 */
@Aspect
public class MyAspect {
    /**
     * 定义方法，方法是实现切面功能的。
     * 方法的定义要求：
     * 1.公共方法 public
     * 2.方法没有返回值
     * 3.方法名称自定义
     * 4.方法可以有参数，也可以没有参数。
     *   如果有参数，参数不是自定义的，有几个参数类型可以使用。
     */
    /**
     * @Before: 前置通知注解
     *   属性：value ，是切入点表达式，表示切面的功能执行的位置。
     *   位置：在方法的上面
     * 特点：
     *  1.在目标方法之前先执行的
     *  2.不会改变目标方法的执行结果
     *  3.不会影响目标方法的执行。
     *
     * 指定通知方法中的参数 ： JoinPoint
     * JoinPoint:业务方法，要加入切面功能的业务方法。（这里实际上代表的就是doSome这个业务方法）
     *    作用是：可以在通知方法中获取方法执行时的信息， 例如方法名称，方法的实参。
     *    如果你的切面功能中需要用到方法的信息，就加入JoinPoint.
     *    这个JoinPoint参数的值是由框架赋予， 必须是第一个位置的参数
     */
    @Before(value = "execution(void *..SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(JoinPoint jp){
        //获取方法的完整定义
        System.out.println("方法的签名（定义）="+jp.getSignature());
        System.out.println("方法的名称="+jp.getSignature().getName());
        //获取方法的实参
        Object args [] = jp.getArgs();
        for (Object arg:args){
            System.out.println("参数="+arg);
        }
        //就是你切面要执行的功能代码
        System.out.println("2=====前置通知， 切面功能：在目标方法之前输出执行时间："+ new Date());
 }
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

2.@AfterReturning后置通知-注解有returning属性

在目标方法执行之后执行。由于是目标方法之后执行，所以可以获取到目标方法的返回值。该注解的 returning 属性就是用于指定接收方法返回值的变量名的。所以，被注解为后置通知的方法，除了可以包含 JoinPoint 参数外，还可以包含用于接收返回值的变量。该变量最好为 Object 类型，因为目标方法的返回值可能是任何类型。

注意：returning 属性自定义变量名必须和通知方法的形参名一样。
例如，在业务接口中定义一个有返回值的抽象方法：

public interface SomeService {
    void doSome(String name, Integer age);
    String doOther(String name,Integer age);   
}
1
2
3
4

实现类：

//目标类
public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name,Integer age) {
        //给doSome方法增加一个功能，在doSome()执行之前， 输出方法的执行时间
        System.out.println("====目标方法doSome()====");
    }

    @Override
    public String doOther(String name, Integer age) {
        System.out.println("====目标方法doOther()====");
        return "abcd";
    }   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

切面类：

@Aspect
public class MyAspect {
    /**
     * @AfterReturning:后置通知
     *    属性：1.value 切入点表达式
     *         2.returning 自定义的变量，表示目标方法的返回值的。
     *          自定义变量名必须和通知方法的形参名一样。
     *    位置：在方法定义的上面
     * 特点：
     *  1。在目标方法之后执行的。
     *  2. 能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能
     *      Object res = doOther();
     *  3. 可以修改这个返回值
     *
     *  后置通知的执行
     *    Object res = doOther();
     *    参数传递： 传值， 传引用
     *    myAfterReturing(res);
     *    System.out.println("res="+res)
     */
    @AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",
                    returning = "res")
    public void myAfterReturing(JoinPoint jp,Object res){
        // Object res:是目标方法执行后的返回值，根据返回值做你的切面的功能处理
        System.out.println("后置通知：方法的定义"+ jp.getSignature());
        System.out.println("后置通知：在目标方法之后执行的，获取的返回值是："+res);
        if(res.equals("abcd")){
            //做一些功能
        } else{
            //做其它功能
        }
        //修改目标方法的返回值， 看一下是否会影响 最后的方法调用结果
        if( res != null){
            res = "Hello Aspectj";
        }
    }
}
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

3.@Around 环绕通知-增强方法有 ProceedingJoinPoint 参数

在目标方法执行之前之后执行。被注解为环绕增强的方法要有返回值，Object 类型。并且方法可以包含一个 ProceedingJoinPoint 类型的参数。接口 ProceedingJoinPoint 其有一个 proceed()方法，用于执行目标方法。若目标方法有返回值，则该方法的返回值就是目标方法的返回值。最后，环绕增强方法将其返回值返回。该增强方法实际是拦截了目标方法的执行。接口增加方法：

注意：环绕通知的返回值就是目标方法的执行结果，可以被修改。ProceedingJoinPoint继承了JoinPoint。

public interface SomeService {
    void doSome(String name, Integer age);
    String doOther(String name, Integer age);
    String doFirst(String name,Integer age);
}
1
2
3
4
5

接口方法实现：

@Override
public String doFirst(String name, Integer age) {
    System.out.println("====业务方法doFirst()====");
    return "doFirst";
}
1
2
3
4
5

定义切面：

@Aspect
public class MyAspect {
    /**
     * 环绕通知方法的定义格式
     *  1.public
     *  2.必须有一个返回值，推荐使用Object
     *  3.方法名称自定义
     *  4.方法有参数，固定的参数 ProceedingJoinPoint
     */
    /**
     * @Around: 环绕通知
     *    属性：value 切入点表达式
     *    位置：在方法的定义什么
     * 特点：
     *   1.它是功能最强的通知
     *   2.在目标方法的前和后都能增强功能。
     *   3.控制目标方法是否被调用执行
     *   4.修改原来的目标方法的执行结果。 影响最后的调用结果
     *
     *  环绕通知，等同于jdk动态代理的，InvocationHandler接口
     *
     *  参数：  ProceedingJoinPoint 就等同于 Method
     *         作用：执行目标方法的
     *  返回值： 就是目标方法的执行结果，可以被修改。
     *  环绕通知： 经常做事务， 在目标方法之前开启事务，执行目标方法， 在目标方法之后提交事务
     */
    @Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        String name = "";
        //获取第一个参数值
        Object args [] = pjp.getArgs();
        if( args!= null && args.length > 1){
              Object arg=  args[0];
              name =(String)arg;
        }
        //实现环绕通知
        Object result = null;
        System.out.println("环绕通知：在目标方法之前，输出时间："+ new Date());
        //1.目标方法调用
        if( "zhangsan".equals(name)){
            //符合条件，调用目标方法
            result = pjp.proceed(); //method.invoke(); Object result = doFirst();
        }
        System.out.println("环绕通知：在目标方法之后，提交事务");
        //2.在目标方法的前或者后加入功能
        //修改目标方法的执行结果， 影响方法最后的调用结果
        if( result != null){
              result = "Hello AspectJ AOP";
        }
        //返回目标方法的执行结果
        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

4.@AfterThrowing 异常通知-注解中有 throwing 属性

在目标方法抛出异常后执行。该注解的 throwing 属性用于指定所发生的异常类对象。当然，被注解为异常通知的方法可以包含一个参数 Throwable，参数名称为 throwing 指定的名称，表示发生的异常对象。

接口实现类：

@Override
public void doSecond() {
    System.out.println("执行业务方法doSecond()" + (10/0));
}
1
2
3
4

切面类：

@Aspect
public class MyAspect {
    /**
     * 异常通知方法的定义格式
     *  1.public
     *  2.没有返回值
     *  3.方法名称自定义
     *  4.方法有个一个Exception， 如果还有就是JoinPoint。
     */
    /**
     * @AfterThrowing:异常通知
     *     属性：1. value 切入点表达式
     *          2. throwinng 自定义的变量，表示目标方法抛出的异常对象。
     *             变量名必须和方法的参数名一样
     * 特点：
     *   1. 在目标方法抛出异常时执行的
     *   2. 可以做异常的监控程序， 监控目标方法执行时是不是有异常。
     *      如果有异常，可以发送邮件，短信进行通知
     *
     *  执行就是：
     *   try{
     *       SomeServiceImpl.doSecond(..)
     *   }catch(Exception e){
     *       myAfterThrowing(e);
     *   }
     */
    @AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",
            throwing = "ex")
    public void myAfterThrowing(Exception ex) {
        System.out.println("异常通知：方法发生异常时，执行："+ex.getMessage());
        //发送邮件，短信，通知开发人员
    }
}
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

5.@After 最终通知

无论目标方法是否抛出异常，该增强均会被执行。

切面类：

@Aspect
public class MyAspect {
    /**
     * 最终通知方法的定义格式
     *  1.public
     *  2.没有返回值
     *  3.方法名称自定义
     *  4.方法没有参数，如果有可以是JoinPoint。
     */
    /**
     * @After :最终通知
     *    属性： value 切入点表达式
     *    位置： 在方法的上面
     * 特点：
     *  1.总是会执行
     *  2.在目标方法之后执行的
     *
     *  try{
     *      SomeServiceImpl.doThird(..)
     *  }catch(Exception e){
     *  }finally{
     *      myAfter()
     *  }
     */
    @After(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public  void  myAfter(){
        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

6.@Pointcut 定义切入点

当较多的通知增强方法使用相同的 execution 切入点表达式时，编写、维护均较为麻烦。 AspectJ 提供了@Pointcut 注解，用于定义 execution 切入点表达式。其用法是，将@Pointcut 注解在一个方法之上，以后所有的 execution 的 value 属性值均可使用该方法名作为切入点。代表的就是@Pointcut 定义的切入点。这个使用@Pointcut 注解的方法一般使用 private 的标识方法，即没有实际作用的方法。

@Aspect
public class MyAspect {
    @After(value = "mypt()")
    public  void  myAfter(){
        System.out.println("执行最终通知，总是会被执行的代码");
        //一般做资源清除工作的。
     }
    /**
     * @Pointcut: 定义和管理切入点， 如果你的项目中有多个切入点表达式是重复的，可以复用的。
     *            可以使用@Pointcut
     *    属性：value 切入点表达式
     *    位置：在自定义的方法上面
     * 特点：
     *   当使用@Pointcut定义在一个方法的上面 ，此时这个方法的名称就是切入点表达式的别名。
     *   其它的通知中，value属性就可以使用这个方法名称，代替切入点表达式了
     */
    @Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))" )
    private void mypt(){
        //无需代码，
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

（3）Spring对AOP实现方式的管理

1.当有接口时，默认使用的是JDK动态代理

请添加图片描述

切面类：

@Before(value = "execution(void *..*.do*(..))")
public void myBefore(JoinPoint jp) {
    System.out.println("前置通知，切面功能，在目标方法之前输出执行时间" + new Date());
}
1
2
3
4

配置文件：

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="someService" class="com.gz.service.impl.SomeServiceImpl"/>
    <bean id="myAspect" class="com.gz.service.MyAspect"/>
    <aop:aspectj-autoproxy/>

</beans>
1
2
3
4
5
6
7
8
9

测试类：

@Test
public void shouldAnswerWithTrue()
{
    String config = "applicationContext.xml";
    ApplicationContext proxy = new ClassPathXmlApplicationContext(config);
    SomeService someService = (SomeService) proxy.getBean("someService");
    System.out.println(someService.getClass().getName());
    someService.doSome("lisi",20);
}
1
2
3
4
5
6
7
8
9

执行结果：

请添加图片描述

2.当没有接口时，默认使用的是cglib动态代理

请添加图片描述

切面类：

@Before(value = "execution(void *..*.do*(..))")
public void myBefore(JoinPoint jp) {
    System.out.println("前置通知，切面功能，在目标方法之前输出执行时间" + new Date());
}
1
2
3
4

配置文件：

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="someService" class="com.gz.service.impl.SomeServiceImpl"/>
    <bean id="myAspect" class="com.gz.service.MyAspect"/>
    <aop:aspectj-autoproxy/>

</beans>
1
2
3
4
5
6
7
8
9

测试类：

public class MyTest07 {
    @Test
    public void test01(){
        String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeServiceImpl proxy = (SomeServiceImpl) ctx.getBean("someService");
        /**
         * 目标类没有接口，使用cglib动态代理， spring框架会自动应用cglib
         * com.bjpowernode.ba07.SomeServiceImpl$$EnhancerBySpringCGLIB$$575c8b90
         */
        System.out.println("proxy:"+proxy.getClass().getName());
        //通过代理的对象执行方法，实现目标方法执行时，增强了功能
        proxy.doThird();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

执行结果：
请添加图片描述

3.当有接口时，还是想强制使用cglib动态代理

那么就要对配置文件进行声明，需要使用cglib动态代理。这种方式在程序执行时的效率会比较高一些。

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="someService" class="com.bjpowernode.ba08.SomeServiceImpl" />
    <bean id="myAspect" class="com.bjpowernode.ba08.MyAspect" />
    <!--
       如果你期望目标类有接口，使用cglib代理
       proxy-target-class="true":告诉框架，要使用cglib动态代理
    -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

请添加图片描述

3.5.5 AspectJ 基于XML的 AOP 实现

3.6 Spring对AOP的实现

第四章 Spring集成Mybatis

可以把mybatis框架和spring集成在一起，向一个框架一样使用。用的技术是ioc 。将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory 对象交由 Spring 来管理。所以，该整合，只需要将 SqlSessionFactory 的对象生成器 SqlSessionFactoryBean 注册在 Spring 容器中，再将其注入给 Dao 的实现类即可完成整合。

实现 Spring 与 MyBatis 的整合常用的方式：扫描的 Mapper 动态代理

Spring 像插线板一样，mybatis 框架是插头，可以容易的组合到一起。插线板 spring 插上 mybatis，两个框架就是一个整体。

回顾mybatis使用步骤
1.定义dao接口，StudentDao
2.定义mapper文件 StudentDao.xml
3.定义mybatis的主配置文件 mybatis.xml
4.创建dao的代理对象， StudentDao dao = SqlSession.getMapper(StudentDao.class);

List< Student> students = dao.selectStudents();

请添加图片描述

4.1MySQL新建表 Student

4.2创建Maven项目加入依赖

<dependencies>
  <!--单元测试-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <!--spring核心ioc-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
  <!--做spring事务用到的-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
  <!--mybatis依赖-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.1</version>
  </dependency>
  <!--mybatis和spring集成的依赖-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
  </dependency>
  <!--mysql驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.9</version>
  </dependency>
  <!--阿里公司的数据库连接池-->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
  </dependency>
</dependencies>
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

4.3创建实体类

public class Student {
    //属性名和列名一样。
    private Integer id;
    private String name;
    private String email;
    private Integer age;
}
1
2
3
4
5
6
7

4.4创建StudentDao

public interface StudentDao {
    int insertStudent(Student student);
    List<Student> selectStudents();
}
1
2
3
4

4.5创建映射文件mapper

在Dao接口的包中创建MyBatis的映射文件 mapper，命名与接口名相同，本例为StudentDao.xml。mapper中的namespace取值也为Dao接口的全限定性名。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.dao.StudentDao">
    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{email},#{age})
    </insert>

    <select id="selectStudents" resultType="Student">
        select id,name,email,age from student order by id desc
    </select>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13

4.6创建Service接口和实现类

public interface StudentService {
    int addStudent(Student student);
    List<Student> queryStudents();
}
1
2
3
4

public class StudentServiceImpl implements StudentService {

    //引用类型
    private StudentDao studentDao;

    //使用set注入，赋值
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }

    @Override
    public int addStudent(Student student) {
        int nums = studentDao.insertStudent(student);
        return nums;
    }

    @Override
    public List<Student> queryStudents() {
        List<Student> students = studentDao.selectStudents();
        return students;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.7创建mybatis主配置文件

在 src 下定义 MyBatis 的主配置文件，命名为 mybatis.xml。

这里有两点需要注意：
（1）主配置文件中不再需要数据源的配置了。因为数据源要交给 Spring 容器来管理了。由于使用阿里的数据库连接池，所以不需要<environments/>
（2）这里对 mapper 映射文件的注册，使用标签，即只需给出 mapper 映射文件所在的包即可。因为 mapper 的名称与 Dao 接口名相同。这种方式的好处是，若有多个映射文件，这里的配置也是不用改变的。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>   
    <!--设置别名-->
    <typeAliases>
        <!--name:实体类所在的包名
            表示com.bjpowernode.domain包中的列名就是别名
            你可以使用Student表示com.bjpowenrode.domain.Student
        -->
        <package name="com.bjpowernode.domain"/>
    </typeAliases>
    
    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--
          name：是包名，这个包中的所有mapper.xml一次都能加载
        -->
        <package name="com.bjpowernode.dao"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.8创建Spring配置文件

要使用dao对象，需要使用getMapper()方法，

怎么能使用getMapper()方法，需要哪些条件？

1.获取SqlSession对象，需要使用SqlSessionFactory的openSession()方法。

2.创建SqlSessionFactory对象。通过读取mybatis的主配置文件，能创建SqlSessionFactory对象需要SqlSessionFactory对象，使用Factory能获取SqlSession ，有了SqlSession就能有dao ，目的就是获取dao对象。Factory创建需要读取主配置文件。

我们会使用独立的连接池类替换mybatis默认自己带的，把连接池类也交给spring创建。

通过以上的说明，我们需要让spring创建以下对象

1.独立的连接池类的对象，使用阿里的druid连接池

2.SqlSessionFactory对象

3.创建出dao对象

4.8.1从属性文件读取数据库连接信息

Spring 配置文件从属性文件中读取数据时，需要在的 value 属性中使用${ }，将在属性文件中定义的 key 括起来，以引用指定属性的值。

< context:property-placeholder/>方式声明属性配置文件在哪，标签中有一个属性 location，用于指定属性文件的位置。

<!--
   把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容
   spring知道jdbc.properties文件的位置
-->
<context:property-placeholder location="classpath:jdbc.properties" />
1
2
3
4
5

4.8.2数据源的配置

Druid 数据源 DruidDataSource Druid 是阿里的开源数据库连接池。是 Java 语言中最好的数据库连接池。Druid 能够提供强大的监控和扩展功能。

配置DataSource连接池：

<!--声明数据源DataSource, 作用是连接数据库的-->
<bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
      init-method="init" destroy-method="close">
    <!--set注入给DruidDataSource提供连接数据库信息 -->
    <!--    使用属性配置文件中的数据，语法 ${key} -->
    <property name="url" value="${jdbc.url}" /><!--setUrl()-->
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.passwd}" />
    <property name="maxActive" value="${jdbc.max}" />
</bean>
1
2
3
4
5
6
7
8
9
10

请添加图片描述

4.8.3注册SqlSessionFactoryBean

这个类内部创建SqlSessionFactory，因为SqlSessionFactory这个类需要读取到mybatis主配置文件的内容，而之前mybatis主配置文件里面的内容主要包含两个：

数据库信息（数据源）
mapper文件的位置

所以我们需要为这个SqlSessionFactoryBean标签设置两个属性。

<!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
    SqlSessionFactory  sqlSessionFactory = new ..
-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!--set注入，把数据库连接池付给了dataSource属性-->
    <property name="dataSource" ref="myDataSource" />
    <!--mybatis主配置文件的位置
       configLocation属性是Resource类型，读取配置文件
       它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
    -->
    <property name="configLocation" value="classpath:mybatis.xml" />
</bean>
1
2
3
4
5
6
7
8
9
10
11
12

4.8.4定义Mapper扫描配置器

Mapper 扫描配置器 MapperScannerConfigurer 会自动生成指定的基本包中 mapper 的代理对象。该 Bean 无需设置 id 属性。basePackage 使用分号或逗号设置多个包。

因为MapperScannerConfigurer类内部调用getMapper()生成dao的代理对象。

而在之前的例子中需要sqlSessionFactory对象调用openSession()来获取Session对象，从而调用getMapper(dao.class)来创建dao接口的代理对象。所以我们需要给MapperScannerConfigurer标签传入两个属性：

sqlSessionFactory
在此处我们用basePackage，他会自动扫描在此包下的所有dao接口。

<!--创建dao对象，使用SqlSession的getMapper（StudentDao.class）
    MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!--指定SqlSessionFactory对象的id-->
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    <!--指定包名， 包名是dao接口所在的包名。
        MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
        一次getMapper()方法，得到每个接口的dao对象。
        创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写
    -->
    <property name="basePackage" value="com.bjpowernode.dao"/>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12

4.1.9向 Service 注入接口名

向 Service 注入 Mapper 代理对象时需要注意，由于通过 Mapper 扫描配置器 MapperScannerConfigurer 生成的 Mapper 代理对象没有名称，所以在向 Service 注入 Mapper 代理时，无法通过名称注入。但可通过接口的简单类名注入，因为生成的是这个 Dao 接口的对象。

创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是接口名首字母小写

<!--声明service-->
<bean id="studentService" class="com.bjpowernode.service.impl.StudentServiceImpl">
    <property name="studentDao" ref="studentDao" />
</bean>
1
2
3
4

4.1.10Spring 配置文件全部配置

<?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:property-placeholder location="classpath:jdbc.properties" />

    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}" /><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.passwd}" />
        <property name="maxActive" value="${jdbc.max}" />
    </bean>
  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource" />
        <property name="configLocation" value="classpath:mybatis.xml" />
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <property name="basePackage" value="com.bjpowernode.dao"/>
    </bean>

    <bean id="studentService" class="com.bjpowernode.service.impl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao" />
    </bean>
</beans>
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

第五章 Spring 事务

5.1理论知识

1.什么是事务
讲mysql的时候，提出了事务。事务是指一组sql语句的集合，集合中有多条sql语句
可能是insert ， update ，select ，delete，我们希望这些多个sql语句都能成功，
或者都失败，这些sql语句的执行是一致的，作为一个整体执行。

2.在什么时候想到使用事务
当我的操作，涉及得到多个表，或者是多个sql语句的insert，update，delete。需要保证
这些语句都是成功才能完成我的功能，或者都失败，保证操作是符合要求的。

在java代码中写程序，控制事务，此时事务应该放在那里呢？
service类的业务方法上，因为业务方法会调用多个dao方法，执行多个sql语句

3.通常使用JDBC访问数据库，还是mybatis访问数据库怎么处理事务
jdbc访问数据库，处理事务 Connection conn ; conn.commit(); conn.rollback();
mybatis访问数据库，处理事务， SqlSession.commit(); SqlSession.rollback();
hibernate访问数据库，处理事务， Session.commit(); Session.rollback();

4.问题中事务的处理方式，有什么不足
1)不同的数据库访问技术，处理事务的对象，方法不同，需要了解不同数据库访问技术使用事务的原理
2)掌握多种数据库中事务的处理逻辑。什么时候提交事务，什么时候回顾事务
3)处理事务的多种方法。

总结：就是多种数据库的访问技术，有不同的事务处理的机制，对象，方法。

5.怎么解决不足
spring提供一种处理事务的统一模型，能使用统一步骤，方式完成多种不同数据库访问技术的事务处理。

使用spring的事务处理机制，可以完成mybatis访问数据库的事务处理
使用spring的事务处理机制，可以完成hibernate访问数据库的事务处理。

请添加图片描述

6.处理事务，需要怎么做，做什么
spring处理事务的模型，使用的步骤都是固定的。把事务使用的信息提供给spring就可以了

事务内部提交，回滚事务，使用的事务管理器对象，代替你完成commit，rollback
事务管理器是一个接口和他的众多实现类。
接口：PlatformTransactionManager ，定义了事务重要方法 commit ，rollback
实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了。
mybatis访问数据库—spring创建好的是DataSourceTransactionManager
hibernate访问数据库----spring创建的是HibernateTransactionManager

怎么使用：你需要告诉spring 你用是那种数据库的访问技术，怎么告诉spring呢？
声明数据库访问技术对于的事务管理器实现类，在spring的配置文件中使用声明就可以了
例如，你要使用mybatis访问数据库，你应该在xml配置文件中
<bean id=“xxx" class=“…DataSourceTransactionManager”>
你的业务方法需要什么样的事务，说明需要事务的类型。
说明方法需要的事务：

1）事务的隔离级别：有4个值。
DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
➢ READ_UNCOMMITTED：读未提交。未解决任何并发问题。
➢ READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
➢ REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
➢ SERIALIZABLE：串行化。不存在并发问题。

2）事务的超时时间：表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。
单位是秒，整数值，默认是 -1.

3）事务的传播行为：控制业务方法是不是有事务的，是什么样的事务的。
行为，表示你的业务方法调用时，事务在方法之间是如何使用的。

PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS
以上三个需要掌握的

PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED

事务提交事务，回滚事务的时机

1）当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。事务管理器commit

2）当你的业务方法抛出运行时异常或ERROR， spring执行回滚，调用事务管理器的rollback
运行时异常的定义： RuntimeException 和他的子类都是运行时异常，例如NullPointException , NumberFormatException

3）当你的业务方法抛出非运行时异常，主要是受查异常时，提交事务
受查异常：在你写代码中，必须处理的异常。例如IOException, SQLException

总结spring的事务

管理事务的是事务管理和他的实现类
spring的事务是一个统一模型
1）指定要使用的事务管理器实现类，使用< bean>
2）指定哪些类，哪些方法需要加入事务的功能
3）指定方法需要的隔离级别，传播行为，超时

你需要告诉spring，你的项目中类信息，方法的名称，方法的事务传播行为。

5.2Spring的事务管理分类

在 Spring 中通常可以通过以下两种方式来实现对事务的管理：

（1）使用 Spring 的事务注解管理事务

（2）使用 AspectJ 的 AOP 配置管理事务

5.3Spring 事务管理 API

5.3.1事务管理器接口

事务管理器是 PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回滚，及获取事务的状态信息。

请添加图片描述

1.常用的两个实现类

PlatformTransactionManager 接口有两个常用的实现类：

➢ DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用。

➢ HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用。

Spring 的回滚方式

Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交。不过，对于受查异常，程序员也可以手工设置其回滚方式。

请添加图片描述

异常的分类：

运行时异常，是 RuntimeException 类或其子类，即只有在运行时才出现的异常。如， NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等均属于运行时异常。这些异常由 JVM 抛出，在编译时不要求必须处理（捕获或抛出）。但，只要代码编写足够仔细，程序足够健壮，运行时异常是可以避免的。

受查异常，也叫编译时异常，即在代码编写时要求必须捕获或抛出的异常，若不处理，则无法通过编译。如 SQLException，ClassNotFoundException，IOException 等都属于受查异常。

5.3.2.事务定义接口

事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作

1.定义了五个事务隔离级别常量

DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。
➢ READ_UNCOMMITTED：读未提交。未解决任何并发问题。
➢ READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
➢ REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
➢ SERIALIZABLE：串行化。不存在并发问题。

2. 定义了七个事务传播行为常量

所谓事务传播行为是指，处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的。

事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX。

PROPAGATION_REQUIRED
PROPAGATION_REQUIRES_NEW
PROPAGATION_SUPPORTS
以上三个需要掌握的

PROPAGATION_MANDATORY
PROPAGATION_NESTED
PROPAGATION_NEVER
PROPAGATION_NOT_SUPPORTED

PROPAGATION_REQUIRED

指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。如该传播行为加在 doOther()方法上。

若 doSome()方法在调用 doOther()方法时就是在事务内运行的，则 doOther()方法的执行也加入到该事务内执行。

若 doSome()方法在调用 doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行。
请添加图片描述

PROPAGATION_SUPPORTS

指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。
请添加图片描述

PROPAGATION_REQUIRES_NEW

总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕。

请添加图片描述

3.定义了默认事务超时时限

常量 TIMEOUT_DEFAULT 定义了事务底层默认的超时时限，sql 语句的执行时长。注意，事务的超时时限起作用的条件比较多，且超时的时间计算点较复杂。所以，该值一般就使用默认值即可。

5.4程序搭建

5.4.1创建数据库表

goods表：

请添加图片描述

sale表：

请添加图片描述

5.4.2加入maven依赖

<dependencies>
  <!--单元测试-->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <!--spring核心ioc-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
  <!--做spring事务用到的-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.5.RELEASE</version>
  </dependency>
  <!--mybatis依赖-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.1</version>
  </dependency>
  <!--mybatis和spring集成的依赖-->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
  </dependency>
  <!--mysql驱动-->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.20</version>
  </dependency>
  <!--阿里公司的数据库连接池-->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
  </dependency>
</dependencies>
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

5.4.3创建实体类

public class Goods {

    private Integer id;
    private String name;
    private Integer amount;
    private Float price;
}
1
2
3
4
5
6
7

public class Sale {
    private Integer id;
    private Integer gid;
    private Integer nums;
}
1
2
3
4
5

5.4.4创建dao接口和mapper文件

public interface GoodsDao {
    //更新库存
    //goods表示本次用户购买的商品信息， id， 购买数量
    int updateGoods(Goods goods);

    //查询商品的信息
    Goods selectGoods(Integer id);
}
1
2
3
4
5
6
7
8

public interface SaleDao {
    //增加销售记录
    int insertSale(Sale sale);
}
1
2
3
4

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.dao.GoodsDao">
    <select id="selectGoods" resultType="com.bjpowernode.domain.Goods">
        select id,name,amount,price from goods where id=#{gid}
    </select>

    <update id="updateGoods">
        update goods set amount = amount - #{amount} where id=#{id}
    </update>
</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.dao.SaleDao">
    <insert id="insertSale">
        insert into sale(gid,nums) values(#{gid},#{nums})
    </insert>
</mapper>
1
2
3
4
5
6
7
8
9

5.4.5创建mybatis主配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--设置别名-->
    <typeAliases>
        <!--name:实体类所在的包名
            表示com.bjpowernode.domain包中的列名就是别名
            你可以使用Student表示com.bjpowenrode.domain.Student
        -->
        <package name="com.bjpowernode.domain"/>
    </typeAliases>


    <!-- sql mapper(sql映射文件)的位置-->
    <mappers>
        <!--
          name：是包名， 这个包中的所有mapper.xml一次都能加载
        -->
        <package name="com.bjpowernode.dao"/>
    </mappers>
</configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5.4.5创建Service接口和实现类

public interface BuyGoodsService {

    //购买商品的方法， goodsId：购买商品的编号， nums：购买的数量
    void buy(Integer goodsId,Integer nums);
}
1
2
3
4
5

public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("=====buy方法的开始====");
        //记录销售信息，向sale表添加记录
        Sale sale  = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);

        //更新库存
        Goods goods  = goodsDao.selectGoods(goodsId);
        if( goods == null){
            //商品不存在
            throw  new  NullPointerException("编号是："+goodsId+",商品不存在");
        } else if( goods.getAmount() < nums){
            //商品库存不足
            throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
        }
        //修改库存了
        Goods buyGoods = new Goods();
        buyGoods.setId( goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);
        System.out.println("=====buy方法的完成====");
    }

    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }

    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }
}
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

5.4.5创建spring配置文件

声明mybatis的对象交给spring创建
1）数据源DataSource
2）SqlSessionFactory
3) Dao对象
4）声明自定义的service
1
2
3
4
5

<?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">

    <!--
       把数据库的配置信息，写在一个独立的文件，编译修改数据库的配置内容
       spring知道jdbc.properties文件的位置
    -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!--声明数据源DataSource, 作用是连接数据库的-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库信息 -->
        <!--    使用属性配置文件中的数据，语法 ${key} -->
        <property name="url" value="${jdbc.url}" /><!--setUrl()-->
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.passwd}" />
        <property name="maxActive" value="${jdbc.max}" />
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的
        SqlSessionFactory  sqlSessionFactory = new ..
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池付给了dataSource属性-->
        <property name="dataSource" ref="myDataSource" />
        <!--mybatis主配置文件的位置
           configLocation属性是Resource类型，读取配置文件
           它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper（StudentDao.class）
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。

    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名， 包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
            一次getMapper()方法，得到每个接口的dao对象。
            创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写
        -->
        <property name="basePackage" value="com.bjpowernode.dao"/>
    </bean>

    <!--声明service-->
    <bean id="buyService" class="com.bjpowernode.service.impl.BuyGoodsServiceImpl">
        <property name="goodsDao" ref="goodsDao" />
        <property name="saleDao" ref="saleDao" />
    </bean>

</beans>
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

5.4.6创建测试类

public class MyTest {
    @Test
    public void test01(){
        String config="applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器获取service
        BuyGoodsService service = (BuyGoodsService) ctx.getBean("buyService");
        //调用方法
        service.buy(1001,200);
    }
}
1
2
3
4
5
6
7
8
9
10
11

5.5使用 Spring 的事务注解管理事务

spring框架中提供的事务处理方案
1.适合中小项目使用的，注解方案。
spring框架自己用aop实现给业务方法增加事务的功能，使用@Transactional注解增加事务。
@Transactional注解是spring框架自己注解，放在public方法的上面，表示当前方法具有事务。
可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等等

使用@Transactional的步骤：

需要声明事务管理器对象
开启事务注解驱动，告诉spring框架，我要使用注解的方式管理事务。
spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。
spring给业务方法加入事务：
在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知

	 @Around("你要增加的事务功能的业务方法名称")
	 Object myAround(){
       开启事务，spring给你开启
		  try{
		     buy(1001,10);
			  spring的事务管理器.commit();
		  }catch(Exception e){
         spring的事务管理器.rollback();
		  }
	 }
1
2
3
4
5
6
7
8
9
10

在你的方法的上面加入@Trancational

通过@Transactional 注解方式，可将事务织入到相应 public 方法中，实现事务管理。 @Transactional 的所有可选属性如下所示：

➢ propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为Propagation.REQUIRED。

➢ isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为 Isolation.DEFAULT。

➢ readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值为 false。

➢ timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为 -1，即没有时限。

➢ rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

➢ rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

➢ noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

➢ noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，默认值为空数组。

当然，若只有一个异常类时，可以不使用数组。需要注意的是，@Transactional 若用在方法上，只能用于 public 方法上。对于其他非 public 方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该方法中。因为 Spring 会忽略掉所有非 public 方法上的@Transaction 注解。

若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

5.5.1声明事务管理器

<!--使用spring的事务处理-->
<!--1. 声明事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--连接的数据库， 指定数据源-->
    <property name="dataSource" ref="myDataSource" />
</bean>
1
2
3
4
5
6

5.5.2开启注解驱动

<!--2. 开启事务注解驱动，告诉spring使用注解管理事务，创建代理对象
       transaction-manager:事务管理器对象的id
-->
<tx:annotation-driven transaction-manager="transactionManager" />
1
2
3
4

5.5.3业务层 public 方法加入事务属性

事务注解可以放在类上，这样所有公共方法都会具有事务功能，但是意义不大，因为有些方法不需要事务。所以我们只需要放到有需要事务处理的方法上面。

rollbackFor:表示发生指定的异常一定回滚.
处理逻辑是：
1) spring框架会首先检查方法抛出的异常是不是在rollbackFor的属性值中
如果异常在rollbackFor列表中，不管是什么类型的异常，一定回滚。
2) 如果你的抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException,
如果是一定回滚。

public class BuyGoodsServiceImpl implements BuyGoodsService {
    private SaleDao saleDao;
    private GoodsDao goodsDao;
    /**
     *
     * rollbackFor:表示发生指定的异常一定回滚.
     *   处理逻辑是：
     *     1) spring框架会首先检查方法抛出的异常是不是在rollbackFor的属性值中
     *         如果异常在rollbackFor列表中，不管是什么类型的异常，一定回滚。
     *     2) 如果你的抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException,
     *         如果是一定回滚。
     *
     */
   /* @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                    NullPointerException.class,  NotEnoughException.class
            }
    )*/

    //使用的是事务控制的默认值， 默认的传播行为是REQUIRED，默认的隔离级别DEFAULT
    //默认抛出运行时异常，回滚事务。
    @Transactional
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("=====buy方法的开始====");
        //记录销售信息，向sale表添加记录
        Sale sale  = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);

        //更新库存
        Goods goods  = goodsDao.selectGoods(goodsId);
        if( goods == null){
            //商品不存在
            throw  new  NullPointerException("编号是："+goodsId+",商品不存在");
        } else if( goods.getAmount() < nums){
            //商品库存不足
            throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
        }
        //修改库存了
        Goods buyGoods = new Goods();
        buyGoods.setId( goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);
        System.out.println("=====buy方法的完成====");
    }

    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }

    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }
}
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

5.6使用 AspectJ 的 AOP 配置管理事务

适合大型项目，有很多的类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中
声明类，方法需要的事务。这种方式业务方法和事务配置完全分离。

实现步骤：都是在xml配置文件中实现。
1)要使用的是aspectj框架，需要加入依赖

<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aspects</artifactId>
		<version>5.2.5.RELEASE</version>
	</dependency>
1
2
3
4
5

2）声明事务管理器对象

< bean id=“xx” class=“DataSourceTransactionManager”>

3）声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）

4）配置aop：指定哪些哪类要创建代理。

5.6.1加入maven 依赖

<!--做spring事务用到的-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>
1
2
3
4
5
6

5.6.2在容器中添加事务管理器

<!--声明式事务处理：和源代码完全分离的-->
<!--1.声明事务管理器对象-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="myDataSource" />
</bean>
1
2
3
4
5

5.6.3配置事务通知

优先级匹配顺序：

请添加图片描述

为事务通知设置相关属性。用于指定要将事务以什么方式织入给哪些方法。

例如，应用到 buy 方法上的事务要求是必须的，且当 buy 方法发生异常后要回滚业务。

<!--2.声明业务方法它的事务属性（隔离级别，传播行为，超时时间）
      id:自定义名称，表示 <tx:advice> 和 </tx:advice>之间的配置内容的
      transaction-manager:事务管理器对象的id
-->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
    <!--tx:attributes：配置事务属性-->
    <tx:attributes>
        <!--tx:method：给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
            name:方法名称，1）完整的方法名称，不带有包和类。
                          2）方法可以使用通配符,* 表示任意字符
            propagation：传播行为，枚举值
            isolation：隔离级别
            rollback-for：你指定的异常类名，全限定类名。 发生异常一定回滚
        -->
        <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                   rollback-for="java.lang.NullPointerException,com.bjpowernode.excep.NotEnoughException"/>

        <!--使用通配符，指定很多的方法-->
        <tx:method name="add*" propagation="REQUIRES_NEW" />
        <!--指定修改方法-->
        <tx:method name="modify*" />
        <!--删除方法-->
        <tx:method name="remove*" />
        <!--查询方法，query，search，find-->
        <tx:method name="*" propagation="SUPPORTS" read-only="true" />
    </tx:attributes>
</tx:advice>
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

5.6.4配置增强器

指定将配置好的事务通知，织入给谁。

<!--配置aop-->
<aop:config>
    <!--配置切入点表达式：指定哪些包中的类，要使用事务
        id:切入点表达式的名称，唯一值
        expression：切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象

        com.bjpowernode.service
        com.crm.service
        com.service
    -->
    <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

    <!--配置增强器：关联adivce和pointcut
       advice-ref:通知，上面tx:advice哪里的配置
       pointcut-ref：切入点表达式的id
    -->
    <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt" />
</aop:config>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5.6.5测试类

@Test
public void test01(){
    String config="applicationContext.xml";
    ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
    //从容器获取service
    BuyGoodsService service = (BuyGoodsService) ctx.getBean("buyService");

    //com.sun.proxy.$Proxy12
    System.out.println("service是代理："+service.getClass().getName());
    //调用方法
    service.buy(1001,10);
}
1
2
3
4
5
6
7
8
9
10
11
12

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/461498