C++ 全栈知识体系

SSM - Spring AOP

AOP简介

概念

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。

核心思想**：是在不改原有代码的前提下对其进行增强。**

  • Spring的理念：无入侵式/无侵入式

核心概念

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

小结

AOP入门案例

思路分析

具体步骤:

1.导入坐标(pom.xml)

2.制作连接点(原始操作，Dao接口与实现类)

3.制作共性功能(通知类与通知)

4.定义切入点

5.绑定切入点与通知关系(切面)

知识点

名称 @EnableAspectJAutoProxy @Aspect @Pointcut @Before
类型 配置类注解（SpringConfig） 类注解 方法注解 方法注解
位置 配置类定义上方 切面类定义上方 切入点方法定义上方 通知方法定义上方
作用 开启注解格式AOP功能 设置当前类为AOP切面类 设置切入点方法 设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行
属性 value（默认）：切入点表达式

AOP工作流程

由于AOP是基于Spring容器管理的bean做的增强，所以整个工作过程需要从Spring加载bean说起:

流程1:Spring容器启动

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

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

流程3:初始化bean

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

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

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

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

流程4:获取bean执行方法

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

原始和代理对象执行的区别

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

AOP核心概念

在上面介绍AOP的工作流程中，提到了两个核心概念，分别是:

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

简单来说，

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

  2. SpringAOP是在不改变原有设计(代码)的前提下对其进行增强的，它的底层采用的是代理模式实现的。

    • 所以要对原始对象进行增强，就需要对原始对象创建代理对象。
    • 在代理对象中的方法把通知[如:MyAdvice中的method方法]内容加进去，就实现了增强,这就是所谓的代理(Proxy)。
    • SpringAOP的本质或者可以说底层实现是通过代理模式。

AOP配置管理

AOP切入点表达式

对于AOP中切入点表达式，需要学习三个内容，分别是语法格式、通配符和书写技巧。

语法格式

概念:

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

对于切入点的描述，有两种方式

描述方式一：执行com.itheima.dao包下的BookDao接口中的无参数update方法

execution(void com.itheima.dao.BookDao.update())
1

描述方式二：执行com.itheima.dao.impl包下的BookDaoImpl类中的无参数update方法

execution(void com.itheima.dao.impl.BookDaoImpl.update())
1

因为调用接口方法的时候最终运行的还是其实现类的方法，所以上面两种描述方式都是可以的。

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

  • 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）

对于这个格式，我们不需要硬记，通过一个例子，理解它:

execution(public User com.itheima.service.UserService.findById(int))
1
  • execution：动作关键字，描述切入点的行为动作，例如execution表示执行到指定切入点
  • public:访问修饰符,还可以是public，private等，可以省略
  • User：返回值，写返回值类型
  • com.itheima.service：包名，多级包使用点连接
  • UserService:类/接口名称
  • findById：方法名
  • int:参数，直接写参数的类型，多个类型用逗号隔开
  • 异常名：方法定义中抛出指定异常，可以省略

通配符

我们使用通配符描述切入点，主要的目的就是简化之前的配置，具体都有哪些通配符可以使用?

  • *:单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

    execution（public * com.itheima.*.UserService.find*(*))
    1

    匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

  • ..：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

    execution（public User com..UserService.findById(..))
    1

    匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

  • +：专用于匹配子类类型

    execution(* *..*Service+.*(..))
    1

    这个使用率较低，*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开头的方法匹配
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

后面两种更符合我们平常切入点表达式的编写规则

书写技巧

对于切入点表达式的编写其实是很灵活的，那么在编写的时候，有没有什么好的技巧让我们用用:

  • 所有代码按照标准规范开发，否则以下技巧全部失效
  • 描述切入点通常描述接口，而不描述实现类,如果描述到实现类，就出现紧耦合了
  • 访问控制修饰符针对接口开发均采用public描述（可省略访问控制修饰符描述）
  • 返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
  • 包名书写尽量不使用..匹配，效率过低，常用*做单个包描述匹配，或精准匹配
  • 接口名/类名书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口名
  • 方法名书写以动词进行精准匹配，名词采用匹配，例如getById书写成getBy,selectAll书写成selectAll
  • 参数规则较为复杂，根据业务方法灵活调整
  • 通常不使用异常作为匹配规则

AOP通知类型

类型介绍

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

共有5种通知类型:

  • 前置通知
  • 后置通知
  • 环绕通知(重点)
  • 返回后通知(了解)
  • 抛出异常后通知(了解)

为了更好的理解这几种通知类型，我们来看一张图

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

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

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

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

(5)环绕通知：环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能，具体是如何实现的，需要我们往下学习。

通知类型总结

@Before/@After/@AfterReturning/@AfterThrowing/@Around 设置当前通知方法与切入点之间的绑定关系

名称 @Before @After @AfterReturning @AfterThrowing @Around
类型 方法注解 方法注解 方法注解 方法注解 方法注解
位置 通知方法定义上方 通知方法定义上方 通知方法定义上方 通知方法定义上方 通知方法定义上方
作用 当前通知方法在原始切入点方法之前运行 当前通知方法在原始切入点方法后运行 当前通知方法在原始切入点方法正常执行完毕后执行 当前通知方法在原始切入点方法运行抛出异常后执行 当前通知方法在原始切入点方法前后运行

环绕通知注意事项

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

业务层接口执行效率

需求分析

  • 需求：任意业务层接口执行均可显示其执行效率（执行时长）

  • 目的：查看每个业务层执行的时间，这样就可以监控出哪个业务比较耗时，将其查找出来方便优化。

具体实现的思路:

(1) 开始执行方法之前记录一个时间

(2) 执行方法

(3) 执行完方法之后记录一个时间

(4) 用后一个时间减去前一个时间的差值，就是我们需要的结果。

功能开发

步骤1:开启SpringAOP的注解功能

在Spring的主配置文件SpringConfig类中添加注解

@EnableAspectJAutoProxy
1
步骤2:创建AOP的通知类

  • 该类要被Spring管理，需要添加@Component

  • 要标识该类是一个AOP的切面类，需要添加@Aspect

  • 配置切入点表达式，需要添加一个方法，并添加@Pointcut

@Component
@Aspect
public class ProjectAdvice {
    //配置业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    
    public void runSpeed(){
        
    } 
}
1
2
3
4
5
6
7
8
9
10
11
步骤3:添加环绕通知

在runSpeed()方法上添加@Around

步骤4:完成核心业务，记录万次执行的时间
@Component
@Aspect
public class ProjectAdvice {
    //配置业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    //@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
    @Around("servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp){
        
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("业务层接口万次执行时间: "+(end-start)+"ms");
    } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
步骤5:运行单元测试类

**注意:**因为程序每次执行的时长是不一样的，所以运行多次最终的结果是不一样的。

步骤6:程序优化

目前程序所面临的问题是，多个方法一起执行测试的时候，控制台都打印的是:

业务层接口万次执行时间:xxxms

需要区分到底是哪个接口的哪个方法执行的具体时间

@Component
@Aspect
public class ProjectAdvice {
    //配置业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}
    //@Around("ProjectAdvice.servicePt()") 可以简写为下面的方式
    @Around("servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp){
        //获取执行签名信息
        Signature signature = pjp.getSignature();
        //通过签名获取执行操作名称(接口名)
        String className = signature.getDeclaringTypeName();
        //通过签名获取执行操作名称(方法名)
        String methodName = signature.getName();
        
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
步骤7:运行单元测试类

AOP通知获取数据

从获取参数、获取返回值和获取异常三个方面来研究切入点的相关信息。

理解:

  • 获取切入点方法的参数，所有的通知类型都可以获取参数
    • JoinPoint：适用于前置、后置、返回后、抛出异常后通知
    • ProceedingJoinPoint：适用于环绕通知
  • 获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无
    • 返回后通知
    • 环绕通知
  • 获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无
    • 抛出异常后通知
    • 环绕通知

获取参数

非环绕通知获取方式

在方法上添加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 ..." );
    }
	//...其他的略
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

说明:

使用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;
    }
	//其他的略
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意:

  • 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;
    }
	//其他的略
}
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16

      有了这个特性后，可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的问题导致程序无法正确运行，保证代码的健壮性。

获取返回值

对于返回值，只有返回后AfterReturing和环绕Around这两个通知类型可以获取：

环绕通知获取返回值

@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;
    }
	//其他的略
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

上述代码中，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
3
4
5
6
7
8
9
10
11
12

注意:

(1)参数名的问题

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

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

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

获取异常

对于获取抛出的异常，只有抛出异常后AfterThrowing和环绕Around这两个通知类型可以获取：

环绕通知获取异常

@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;
    }
	//其他的略
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在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);
    }
	//其他的略
}
1
2
3
4
5
6
7
8
9
10
11
12

如何让原始方法抛出异常，方式有很多，

@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";
    }
}
1
2
3
4
5
6
7
8
9
10
11

总结

AOP的核心概念

  • 概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
  • 作用：在不惊动原始设计的基础上为方法进行功能增强
  • 核心概念
    • 代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
    • 连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行
    • 切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
    • 通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
    • 切面（Aspect）：描述通知与切入点的对应关系
    • 目标对象（Target）：被代理的原始对象成为目标对象

切入点表达式

  • 切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名（参数）异常名)

    execution(* com.itheima.service.*Service.*(..))
    1

  • 切入点表达式描述通配符：

    • 作用：用于快速描述，范围描述
    • *：匹配任意符号（常用）
    • .. ：匹配多个连续的任意符号（常用）
    • +：匹配子类类型

  • 切入点表达式书写技巧

  1. 按标准规范开发
  2. 查询操作的返回值建议使用*匹配
  3. 减少使用..的形式描述包
  4. 对接口进行描述，使用*表示模块名，例如UserService的匹配描述为*Service
  5. 方法名书写保留动词，例如get，使用*表示名词，例如getById匹配描述为getBy*
  6. 参数根据实际情况灵活调整

五种通知类型

  • 前置通知
  • 后置通知
  • 环绕通知（重点）
    • 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
    • 环绕通知可以隔离原始方法的调用执行
    • 环绕通知返回值设置为Object类型
    • 环绕通知中可以对原始方法调用过程中出现的异常进行处理
  • 返回后通知
  • 抛出异常后通知

通知中获取参数

  • 获取切入点方法的参数，所有的通知类型都可以获取参数
    • JoinPoint：适用于前置、后置、返回后、抛出异常后通知
    • ProceedingJoinPoint：适用于环绕通知
  • 获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
    • 返回后通知
    • 环绕通知
  • 获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
    • 抛出异常后通知
    • 环绕通知

AOP事务管理

Spring事务简介

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

Spring为了管理事务，提供了一个平台事务管理器PlatformTransactionManager

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

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

Mybatis内部采用的就是JDBC的事务，后期Spring整合Mybatis就采用的这个DataSourceTransactionManager事务管理器。

转账案例-需求分析

需求: 实现任意两个账户间转账操作

需求微缩: A账户减钱，B账户加钱

为了实现上述的业务需求，我们可以按照下面步骤来实现下: ①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）

②：业务层提供转账操作（transfer），调用减钱与加钱的操作

③：提供2个账号和操作金额执行转账操作

④：基于Spring整合MyBatis环境搭建上述操作

事务管理

如果在转账的过程中出现了异常，例如转出和转入操作之间存在异常：

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }

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

当程序出问题后，我们需要让事务进行回滚，而且这个事务应该是加在业务层上，而Spring的事务管理就是用来解决这类问题的。

Spring事务管理具体的实现步骤为:

步骤1:在需要被事务管理的方法上添加注解

    @Transactional
    public void transfer(String out,String in ,Double money) {
        accountDao.outMoney(out,money);
        int i = 1/0;
        accountDao.inMoney(in,money);
    }

}
1
2
3
4
5
6
7
8

注意:

@Transactional可以写在接口类上、接口方法上、实现类上和实现类方法上

  • 写在接口类上，该接口的所有实现类的所有方法都会有事务
  • 写在接口方法上，该接口的所有实现类的该方法都会有事务
  • 写在实现类上，该类中的所有方法都会有事务
  • 写在实现类方法上，该方法上有事务
  • 建议写在实现类或实现类的方法上

步骤2:在JdbcConfig类中配置事务管理器

    //配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}
1
2
3
4
5
6
7
8

步骤3：开启事务注解

在SpringConfig的配置类中开启

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
1
2
3
4
5
6
7
8
9

步骤4:运行测试类

会发现在转换的业务出现错误后，事务就可以控制回顾，保证数据的正确性。

知识点：@EnableTransactionManagement/@Transactional

名称 @EnableTransactionManagement
类型 配置类注解 接口注解 类注解 方法注解
位置 配置类定义上方 业务层接口上方 业务层实现类上方 业务方法上方
作用 设置当前Spring环境中开启注解式事务支持 为当前业务层方法添加事务（如果设置在类或接口上方则类或接口中所有方法均添加事务）

Spring事务角色

两个重要概念，分别是事务管理员和事务协调员。

  1. 未开启Spring事务之前:

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

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

通过上面的分析，可以得到如下概念:

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

注意:

目前的事务管理是基于DataSourceTransactionManager和SqlSessionFactoryBean使用的是同一个数据源。

Spring事务属性

学习事务配置、转账业务追加日志、事务传播行为。

事务配置

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

  • readOnly：true只读事务，false读写事务，增删改要设为false,查询设为true。
  • timeout:设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。
  • rollbackFor:当出现指定异常进行事务回滚
  • noRollbackFor:当出现指定异常不进行事务回滚
    • Spring的事务只会对Error异常和RuntimeException异常及其子类进行事务回滚，其他的异常类型是不会回滚的。
  • rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串
  • noRollbackForClassName等同于noRollbackFor，只不过属性为异常的类全名字符串
  • isolation设置事务的隔离级别
    • DEFAULT :默认隔离级别, 会采用数据库的隔离级别
    • READ_UNCOMMITTED : 读未提交
    • READ_COMMITTED : 读已提交
    • REPEATABLE_READ : 重复读取
    • SERIALIZABLE: 串行化

转账业务追加日志案例

需求分析

在前面的转案例的基础上添加新的需求，完成转账后记录日志。

  • 需求：实现任意两个账户间转账操作，并对每次转账操作在数据库进行留痕
  • 需求微缩：A账户减钱，B账户加钱，数据库记录日志

基于上述的业务需求，我们来分析下该如何实现:

①：基于转账操作案例添加日志模块，实现数据库中记录日志

②：业务层转账操作（transfer），调用减钱、加钱与记录日志功能

需要注意一点就是，我们这个案例的预期效果为:

无论转账操作是否成功，均进行转账操作的日志留痕

环境准备

该环境是基于转账环境来完成的，所以环境的准备可以参考6.1.3的环境搭建步骤，在其基础上，我们继续往下写

步骤1:创建日志表
create table tbl_log(
   id int primary key auto_increment,
   info varchar(255),
   createDate datetime
)
1
2
3
4
5
步骤2:添加LogDao接口
public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}
1
2
3
4
5
步骤3:添加LogService接口与实现类
public interface LogService {
    void log(String out, String in, Double money);
}
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
	@Transactional
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
步骤4:在转账的业务中添加记录日志
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;
    @Autowired
    private LogService logService;
	@Transactional
    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }

}
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
步骤5:运行程序

  • 当程序正常运行，tbl_account表中转账成功，tbl_log表中日志记录成功

  • 当转账业务之间出现异常(int i =1/0),转账失败，tbl_account成功回滚，但是tbl_log表未添加数据

  • 这个结果和我们想要的不一样，什么原因?该如何解决?

  • 失败原因:日志的记录与转账操作隶属同一个事务，同成功同失败

  • 最终效果:无论转账操作是否成功，日志必须保留

事务传播行为

对于上述案例的分析:

  • 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);
    }
}
1
2
3
4
5
6
7
8
9
10
11

运行后，就能实现我们想要的结果，不管转账是否成功，都会记录日志。

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

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

← SSM - SpringMVC 基础 →