AOP面向切面编程思想。

本文介绍: ▶ 相关概念● 事务作用：在数据层保障一系列的数据库操作同成功同失败● Spr in g 事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败▷ 数据层有事务我们可以理解，为什么业务层也需要处理事务呢?举个简单的例子：● 转账业务会有两次数据层的调用，一次是加钱一次是减钱● 把事务放在数据层，加钱和减钱就有两个事务● 没办法保证加钱和减钱同时成功或者同时失败● 这个时候就需要将事务放在业务层进行处理。

一、AOP工作流程

一、AOP工作 流程

1、基本概念

▶ 什么是AOP?

● AOP(As pe ct Or ie n t e d Pro g ram ming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
● OOP(Obje ct Or ie n t ed Program ming)面向对象编程

我们都知道OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的`编程范式`。

▶ AOP作用

AOP是OOP的延续，是软件开发中的一个热点，也是Spr ing框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

▶ 核心概念

● 连接点(Jo inPo int)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等，在Spr ingAOP中，理解为方法的执行。
● 切入点(Po int cut) : 匹配连接点的式子
○ 在Spr ingAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法：
① 一个具体的方法 : 如com.i t he i m a.dao包下的BookDao接口中的无形参无返回值的save 方法
② 匹配多个方法 : 所有的save方法，所有的get 开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
○ 连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
● 通知(Advi ce): 在切入点处执行的操作，也就是共性功能。在Spr ingAOP中，功能最终以方法的形式呈现。
● 通知类：定义通知的类
● 切面(As pe ct): 描述通知与切入点的对应关系。

(1) Spr ing的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的图示中中有`save`,`update`,`delete`和`select`方法,这些方法我们给起了一个名字叫连接点

(2) 在四个方法中，`update`和`delete`只有打印没有计算万次执行消耗时间，但是在运行的时候已经有该功能，那也就是说`update`和`de let e`方法都已经被增强，所以对于需要增强的方法我们给起了一个名字叫切入点

(3) 执行 update和de let e方法的时候都被添加了一个计算万次执行消耗时间的功能，将这个功能抽取到一个方法中，换句话说就是存放共性功能的方法，我们给起了个名字叫通知

(4) 通知是要增强的内容，会有多个，切入点是需要被增强的方法，也会有多个，那哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述，我们给起了个名字叫切面

(5) 通知是一个方法，方法不能独立存在需要被写在一个类中，这个类我们也给起了个名字叫通知类

▶ 知识点

@EnableAs pe ctJAutoPro x y

@As pe ct

@Point cut

@Be fore

▶ AOP实现步骤

▷ 步骤1 : pom.xml 添加依赖
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>
● 因为`spring–context`中已经导入了`spring–aop`,所以不需要再单独导入`spring-aop`
● 导入AspectJ的jar包,Asp ectJ是AOP思想的一个具体实现，Spr ing有自己的AOP实现，但是相比于AspectJ来说比较麻烦，所以直接采用Spr ing整合ApsectJ的方式进行AOP开发。

▷ 步骤2 : 定义接口与实现类

前面写的业务层service的代码类似。

▷ 步骤3 : 定义通知类和通知

通知就是将共性功能抽取出来后形成的方法，共性功能指的就是当前系统时间的打印。类名和方法名没有要求，可以任意。
public class MyAdvice {
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
▷ 步骤4 : 定义切入点
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
注意：切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑。

▷ 步骤5 : 制作切面

切面是用来描述通知和切入点之间的关系，如何进行关系的绑定?
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置

注意: @Before翻译过来是之前，也就是说通知会在切入点方法执行之前执行。

▷ 步骤6 : 将通知类配给容器并标识其为切面类
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}
▷ 步骤7 : 开启注解格式AOP功能
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}
▷ 步骤8 : 运行程序
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}
看到在执行up date方法之前打印了系统时间戳，说明对原始方法进行了增强，AOP编程成功。

2、AOP工作流程

▶ 流程1 : Spring容器启动

● 容器启动就需要去加载 bean,哪些类需要被加载呢?
● 需要被增强的类，如:BookServiceImpl
● 通知类，如:MyAdvice
● 注意此时bean 对象还没有创建成功

▶ 流程2 : 读取所有切面配置中的切入点

● 上面这个例子中有两个切入点的配置，但是第一个`ptx()`并没有被使用，所以不会被读取。

▶ 流程3 : 初始化 bean

判定bean 对应的类中的方法是否匹配到任意切入点

▶ 注意第1步在容器启动的时候，bean 对象还没有被创建成功。

▶ 要被实例化bean 对象的类中的方法和切入点进行匹配

● 匹配失败，创建原始对象,如`UserDao`
○ 匹配失败说明不需要增强，直接调用原始对象的方法即可。
● 匹配成功，创建原始对象（目标对象）的代理对象,如:`BookDao`
○ 匹配成功说明需要对其进行增强，对哪个类做增强，这个类对应的对象就叫做目标对象
○ 因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象
○ 最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强

▶ 流程4 : 获取bean执行方法

● 获取的bean是原始对象时，调用方法并执行，完成操作
● 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

▶ 容器是否为代理对象

结论:

● 如果目标对象中的方法会被增强，那么容器中将存入的是目标对象的代理对象
● 如果目标对象中的方法不被增强，那么容器中将存入的是目标对象本身。

▶ AOP核心概念

● 目标对象(Tar get)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
● 代理(Pro xy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

▷ 上面这两个概念比较抽象，简单来说：

目标对象就是要增强的类[如:BookServiceImpl类]对应的对象，也叫原始对象，不能说它不能运行，只能说它在运行的过程中对于要增强的内容是缺失的。

SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的，它的底层采用的是代理模式实现的，所以要对原始对象进行增强，就需要对原始对象创建代理对象，在代理对象中的方法把通知[如:MyAdvice中的method方法]内容加进去，就实现了增强,这就是我们所说的代理(Pro xy)。

二、AOP核心配置

1、AOP切入点表达式

● 示例：

▶ 语法格式

▷ 明确两个概念:

● 切入点 : 要进行增强的方法
● 切入点表达式 : 要进行增强的方法的描述方式

▷ 对于切入点的描述，有两中方式：

● 描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数 up date方法
execution(void com.itheima.dao.BookDao.update())
● 描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法
execution(void com.itheima.dao.impl.BookDaoImpl.update())
因为调用接口方法的时候最终运行的还是其实现类的方法，所以上面两种描述方式都是可以的。

▷ 对于切入点表达式的语法为:

切入点表达式标准格式：动作关键字(访问修饰符返回值包名.类/接口名.方法名(参数) 异常名）
execution(public User com.itheima.service.UserService.findById(int))
execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点

public : 访问修饰符,还可以是public，private等，可以省略

User：返回值，写返回值类型

com.itheima.service ：包名，多级包使用点连接

UserService : 类/接口名称

findById：方法名

int : 参数，直接写参数的类型，多个类型用逗号隔开

异常名：方法定义中抛出指定异常，可以省略

切入点表达式就是要找到需要增强的方法，所以它就是对一个具体方法的描述，但是方法的定义会有很多，所以如果每一个方法对应一个切入点表达式。

▶ 通配符

▷ `* `: 单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
execution（public * com.itheima.*.UserService.find*(*))
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

▷ `..` ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
execution（public User com..UserService.findById(..))
匹配com包下的任意包中的UserService类或接口中所有名称为 findById的方法

▷ `+`：专用于匹配子类类型
execution(* *..*Service+.*(..))
这个使用率较低，描述子类的，咱们做JavaEE开发，继承机会就一次，使用都很慎重，所以很少用它。*Service+，表示所有以Service结尾的接口的子类。

▷ 总结
execution(void com.itheima.dao.BookDao.update())
匹配接口，能匹配到

execution(void com.itheima.dao.impl.BookDaoImpl.update())
匹配实现类，能匹配到

execution(* com.itheima.dao.impl.BookDaoImpl.update())
返回值任意，能匹配到

execution(* com.itheima.dao.impl.BookDaoImpl.update(*))
返回值任意，但是update方法必须要有一个参数，无法匹配，要想匹配需要在update接口和实现类添加参数

execution(void com.*.*.*.*.update())
返回值为void,com包下的任意包三层包下的任意类的update方法，匹配到的是实现类，能匹配

execution(void com.*.*.*.update())
返回值为void,com包下的任意两层包下的任意类的update方法，匹配到的是接口，能匹配

execution(void *..update())
返回值为void，方法名是update的任意包下的任意类，能匹配

execution(* *..*(..))
匹配项目中任意类的任意方法，能匹配，但是不建议使用这种方式，影响范围广

execution(* *..u*(..))
匹配项目中任意包任意类下只要以u开头的方法，update方法能满足，能匹配

execution(* *..*e(..))
匹配项目中任意包任意类下只要以e结尾的方法，update和save方法能满足，能匹配

execution(void com..*())
返回值为void，com包下的任意包任意类任意方法，能匹配，*代表的是方法

execution(* com.itheima.*.*Service.find*(..))
将项目中所有业务层方法的以find开头的方法匹配

execution(* com.itheima.*.*Service.save*(..))
将项目中所有业务层方法的以save开头的方法匹配 
▶ 书写技巧

所有代码按照标准规范开发，否则以下技巧全部失效：

描述切入点通常描述接口，而不描述实现类,如果描述到实现类，就出现紧耦合了

访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）

返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述

包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配

接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名

方法名书写以动词进行精准匹配，名词采用*匹配，例如getById书写成getBy*,selectAll书写成selectAll

参数规则较为复杂，根据业务方法灵活调整

通常不使用异常作为匹配规则

2、AOP通知类型

▶ 类型介绍

▷ AOP通知 : AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。

▷ 共提供了5种通知类型:

前置通知

后置通知

环绕通知(重点)

返回后通知(了解)

抛出异常后通知(了解)

▷ 理解

(1) 前置通知，追加功能到方法执行前, 类似于在代码1或者代码2添加内容

(2) 后置通知, 追加功能到方法执行后, 不管方法执行的过程中有没有抛出异常都会执行，类似于在代码5添加内容

(3) 返回后通知, 追加功能到方法执行后，只有方法正常执行结束后才进行, 类似于在代码3添加内容，如果方法执行抛出异常，返回后通知将不会被添加

(4) 抛出异常后通知, 追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内容，只有方法抛出异常后才会被添加

(5) 环绕通知, 环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能。

▶ 使用时需要添加的依赖

pom.xml添加Spring依赖
  <dependencies>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.2.10.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
      </dependency>
  </dependencies>
▶ 通知类型的使用

▷ 前置通知

修改MyAdvice,在before方法上添加`@Before注解`
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    //此处也可以写成 @Before("MyAdvice.pt()"),不建议
    public void before() {
        System.out.println("before advice ...");
    }
}
▷ 后置通知
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Before("pt()")
    public void before() {
        System.out.println("before advice ...");
    }
    @After("pt()")
    public void after() {
        System.out.println("after advice ...");
    }
}
▷ 环绕通知

基本使用：
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Around("pt()")
    public void around(){
        System.out.println("around before advice ...");
        System.out.println("around after advice ...");
    }
}
因为环绕通知需要在原始方法的前后进行增强，所以环绕通知就必须要能对原始操作进行调用。如果我们使用环绕通知的话，要根据原始方法的返回值来设置环绕通知的返回值，具体解决方案为:
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2(){}
    
    @Around("pt2()")
    public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    }
}
▷ 返回后通知
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2(){}
    
    @AfterReturning("pt2()")
    public void afterReturning() {
        System.out.println("afterReturning advice ...");
    }
}
注意：返回后通知是需要在原始方法`select`正常执行后才会被执行，如果`select()`方法执行的过程中出现了异常，那么返回后通知是不会被执行。后置通知是不管原始方法有没有抛出异常都会被执行。

▷ 异常后通知
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    
    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2(){}
    
    @AfterReturning("pt2()")
    public void afterThrowing() {
        System.out.println("afterThrowing advice ...");
    }
}
注意：异常后通知是需要原始方法抛出异常，可以在`select()`方法中添加一行代码`int i = 1/0`即可。如果没有抛异常，异常后通知将不会被执行。

▶ 环绕通知注意事项

环绕通知是如何实现其他通知类型的功能的? 因为环绕通知是可以控制原始方法执行的，所以我们把增强的代码写在调用原始方法的不同位置就可以实现不同的通知类型的功能，如:

注意：

1. 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
2. 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
3. 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，最好设定为Object类型
4. 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void,也可以设置成Object
5. 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须要处理Throwable异常

▶ 通知类型总结

@After

@AfterReturning

@AfterThrowing

@Around

三、AOP通知获取数据

1、获取参数

▶ 非环绕通知获取方式

在方法上添加JoinPoint,通过JoinPoint来获取参数
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    @Before("pt()")
    public void before(JoinPoint jp) 
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("before advice ..." );
    }
    //...其他的略
}
参数可以是多个：
@Repository
public class BookDaoImpl implements BookDao {

    public String findName(int id,String password) {
        System.out.println("id:"+id);
        return "itcast";
    }
}
注意：使用JoinPoint的方式获取参数适用于`前置`、`后置`、`返回后`、`抛出异常后`通知。

▶ 环绕通知获取方式

环绕通知使用的是ProceedingJoinPoint，因为ProceedingJoinPoint是JoinPoint类的子类，所以对于ProceedingJoinPoint类中应该也会有对应的`getArgs()`方法，我们去验证下:
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp)throws Throwable {
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        Object ret = pjp.proceed();
        return ret;
    }
    //其他的略
}
注意:

● pjp.proceed()方法是有两个构造方法，分别是:

○ 调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数

○ 所以调用这两个方法的任意一个都可以完成功能

○ 但是当需要修改原始方法的参数时，就只能采用带有参数的方法,如下:
@Component
@Aspect
public class MyAdvice {
    Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}
    
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = pjp.proceed(args);
        return ret;
     }
     //其他的略
}
    
有了这个特性后，我们就可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的问题导致程序无法正确运行，保证代码的健壮性。

2、获取返回值

▶ 环绕通知获取返回值
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = pjp.proceed(args);
        return ret;
    }
    //其他的略
}
上述代码中，`ret`就是方法的返回值，我们是可以直接获取，不但可以获取，如果需要还可以进行修改。

▶ 返回后通知获取返回值
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    @AfterReturning(value = "pt()",returning = "ret")
    public void afterReturning(Object ret) {
        System.out.println("afterReturning advice ..."+ret);
    }
    //其他的略
}
注意:

(1)参数名的问题

(2)afterReturning方法参数类型的问题

参数类型可以写成String，但是为了能匹配更多的参数类型，建议写成Object类型

(3)afterReturning方法参数的顺序问题

3、获取异常

▶ 环绕通知获取异常

这块比较简单，以前我们是抛出异常，现在只需要将异常捕获，就可以获取到原始方法的异常信息了
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp){
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        args[0] = 666;
        Object ret = null;
        try{
            ret = pjp.proceed(args);
        }catch(Throwable throwable){
            t.printStackTrace();
        }
        return ret;
    }
    //其他的略
}
在catch方法中就可以获取到异常，至于获取到异常以后该如何处理，这个就和你的业务需求有关了。

▶ 抛出异常后通知获取异常
@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
    private void pt(){}

    @AfterThrowing(value = "pt()",throwing = "t")
    public void afterThrowing(Throwable t) {
        System.out.println("afterThrowing advice ..."+t);
    }
    //其他的略
}
如何让原始方法抛出异常，方式有很多，
@Repository
public class BookDaoImpl implements BookDao {

    public String findName(int id,String password) {
        System.out.println("id:"+id);
        if(true){
            throw new NullPointerException();
        }
        return "itcast";
    }
}
注意：

四、AOP事务管理

1、Spring事务简介

▶ 相关概念

● 事务作用：在数据层保障一系列的数据库操作同成功同失败
● Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败

▷ 数据层有事务我们可以理解，为什么业务层也需要处理事务呢?举个简单的例子：

● 转账业务会有两次数据层的调用，一次是加钱一次是减钱
● 把事务放在数据层，加钱和减钱就有两个事务
● 没办法保证加钱和减钱同时成功或者同时失败
● 这个时候就需要将事务放在业务层进行处理。

Spring为了管理事务，提供了一个平台事务管理器`PlatformTrans actionManager`

commit是用来提交事务，roll back是用来回滚事务。

PlatformTrans actionManager只是一个接口，Spring还为其提供了一个具体的实现:

从名称上可以看出，我们只需要给它一个DataSource对象，它就可以帮你去在业务层管理事务。其内部采用的是JDBC的事务。所以说如果你持久层采用的是JDBC相关的技术，就可以采用这个事务管理器来管理你的事务。而Mybatis内部采用的就是JDBC的事务，所以后期我们Spring整合Mybatis就采用的这个DataSourceTransactionManager事务管理器。

▶ 知识点

@EnableTransactionManagement

@Transactional

2、Spring事务角色

▶ 未开启Spring事务之前

● AccountDao的outMoney因为是修改操作，会开启一个事务T1
● AccountDao的inMoney因为是修改操作，会开启一个事务T2
● AccountService的transfer没有事务，
○ 运行过程中如果没有抛出异常，则T1和T2都正常提交，数据正确
○ 如果在两个方法中间抛出异常，T1因为执行成功提交事务，T2因为抛异常不会被执行
○ 就会导致数据出现错误

▶ 开启Spring的事务管理后

● transfer上添加了@Transactional注解，在该方法上就会有一个事务T
● AccountDao的outMoney方法的事务T1加入到transfer的事务T中
● AccountDao的inMoney方法的事务T2加入到transfer的事务T中
● 这样就保证他们在同一个事务中，当业务层中出现异常，整个事务就会回滚，保证数据的准确性。

▷ 概念:

● 事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
● 事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

注意 : 目前的事务管理是基于`DataSourceTransactionManager`和`SqlSes sionFactoryBean`使用的是同一个数据源。

3、事务属性

▶ 事务配置

上面这些属性都可以在`@Transactional`注解的参数上进行设置。

● readOnly：true 只读事务，false 读写事务，增删改要设为false,查询设为true。

● timeout:设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。

● roll backFor:当出现指定异常进行事务回滚

● noRollbackFor:当出现指定异常不进行事务回滚

○ noRollbackFor是设定对于指定的异常不回滚，这个好理解

○ rollbackFor是指定回滚异常，对于异常事务不应该都回滚么，为什么还要指定?

这块需要更正一个知识点，并不是所有的异常都会回滚事务，比如下面的代码就不会回滚
public interface AccountService {
    /**
    * 转账操作
    * @param out 传出方
    * @param in 转入方
    * @param money 金额
    */
    //配置当前接口方法具有事务
    public void transfer(String out,String in ,Double money) throws IOException;
}
      
@Service
public class AccountServiceImpl implements AccountService {
      
    @Autowired
    private AccountDao accountDao;
    @Transactional
    public void transfer(String out,String in ,Double money) throws IOException{
        accountDao.outMoney(out,money);
        //int i = 1/0; //这个异常事务会回滚
        if(true){
            throw new IOException(); //这个异常事务就不会回滚
        }
        accountDao.inMoney(in,money);
    }
      
}
○ 出现这个问题的原因是，Spring的事务只会对`Error异常`和`RuntimeExc eption异常`及其子类进行事务回顾，其他的异常类型是不会回滚的，对应IOExc eption不符合上述条件所以不回滚，此时就可以使用rollbackFor属性来设置出现IOException异常不回滚
@Service
public class AccountServiceImpl implements AccountService {
      
    @Autowired
    private AccountDao accountDao;
    @Transactional(rollbackFor = {IOException.class})
    public void transfer(String out,String in ,Double money) throws IOException{
          accountDao.outMoney(out,money);
          //int i = 1/0; //这个异常事务会回滚
          if(true){
               throw new IOException(); //这个异常事务就不会回滚
          }
          accountDao.inMoney(in,money);
    }
      
}
● rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串

● noRollbackForClassName等同于noRollbackFor，只不过属性为异常的类全名字符串

● isolation设置事务的隔离级别

○ DEFAULT :默认隔离级别, 会采用数据库的隔离级别
○ READ_UNCOMMITTED : 读未提交
○ READ_COMMITTED : 读已提交
○ REPEATABLE_READ : 重复读取
○ SERIALIZABLE: 串行化

▶ 事务传播行为

对于上述案例的分析:

● log方法、inMoney方法和outMoney方法都属于增删改，分别有事务T1,T2,T3
● transfer因为加了@Transactional注解，也开启了事务T
● 前面我们讲过Spring事务会把T1,T2,T3都加入到事务T中
● 所以当转账失败后，所有的事务都回滚，导致日志没有记录下来
● 这和我们的需求不符，这个时候我们就想能不能让log方法单独是一个事务呢?

要想解决这个问题，就需要用到事务传播行为，所谓的事务传播行为指的是:

● 事务传播行为：事务协调员对事务管理员所携带事务的处理态度。

具体如何解决，就需要用到之前我们没有说的`propagation属性`。

▷ 1.修改logService改变事务的传播行为
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}
运行后，就能实现我们想要的结果，不管转账是否成功，都会记录日志。

▶ 2.事务传播行为的可选值

对于我们开发实际中使用的话，因为默认值需要事务是常态的。根据开发过程选择其他的就可以了，例如案例中需要新事务就需要手工配置。其实入账和出账操作上也有事务，采用的就是默认值。