spring事务管理流程（浅入浅出的代理模式与Spring事务管理）

前言

最近在开发业务代码的时候，犯了一个事务注解的错误：在同一个类的非事务方法中调用了另一个事务方法，导致事务没有生效，如下所示：

public ConfirmOrderResultVO batchConfirmPurchaseOrders(Long taobaoUserId, List<String> bizOrderIds) throws TCException { ……………………………………………………………… for (String bizOrderId : bizOrderIds) { // 推单成功进入successList，否则进入failedList if (confirmPurchaseOrder(taobaoUserId, bizOrderId)){ successList.add(Long.valueOf(bizOrderId)); }else { failedList.add(Long.valueOf(bizOrderId)); } } ……………………………………………………………… }

其中confirmPurchaseOrder()是一个事务方法：

@Transactional public Boolean confirmPurchaseOrder(Long taobaoUserId, String bizOrderId) throws TCException { logger.warn("|ConfirmPurchaseOrder|UserId:" taobaoUserId ",orderId:" bizOrderId); ………………………… return ture; }

这样在直接调用batchConfirmPurchaseOrders()方法时，如果confirmPurchaseOrder()方法发生了异常，是不会回滚的。原理在于Spring的事务管理依靠的动态代理模式，当在同一个类中调用一个非事务方法，是不会生成代理对象的，自然也不会触发事务。借此机会回顾一下代理模式和Spring事务管理的原理。

代理模式

网上讲解代理模式的文章千奇百怪，很多时候看完了也不明白讲的重点是什么。

事实上在生活中我们常常会遇到各种各样的代理模式，例如火车票代售点代理出售火车票，他在“帮忙”出售火车票的同时，收取了额外的手续费，记录了自己店里的流水等。

又比如班长代理老师来上交班费，他在“上交班费”的动作之前，还进行了检查班级同学是否到齐、向每一位同学收班费、核对班费金额，最后再上交班费。





总而言之，代理模式就是 代理其他对象，在完成原动作的基础上（前后）做一些额外的自定义的工作 。

聪明的朋友看到这里一定想到了：那我在一个方法中调用另一个方法不就是代理模式了吗？啊对对对，从功能上来讲是一样的，但是“模式”之所以为“模式”，以我拙见，其本质目的在于形成规范，以减少重复代码的编写。因此如果不能达到减少代码重复的本质目的，便不能称之为“模式”。

按照代理模式的实现方式，分为两种：静态代理和动态代理。那我们就拿刚刚说过的“写作业”这件事来做例子，讲解一下两种实现方式的区别。

▐静态代理

首先定义一个“作业”接口，里面有一个方法“做作业”

public interface Homework { void doHomework(); }

小红实现了这个接口。但是小红是一个不爱学习的小学生，又因为师从马掌门成为了学校的扛把子，所以为了不让老师发现，他决定自己随便做做，把剩下的部分交给小弟们来做。

public class XiaoHong implements Homework{ @Override public void doHomework() { System.out.println("XiaoHong did homework casually"); } }

其中小王、小张两个小弟成绩优异，一个负责数学作业，一个负责英语作业，于是他们两个自告奋勇实现了Homework接口，在代理完成作业的基础上，还不断学习提高自己的能力，并且对作业答案进行了校验。

小王：

public class XiaoWang implements Homework{ // 持有Homework属性 private Homework homework; // 通过构造函数初始化Homework public XiaoWang(Homework homework){ this.homework=homework; } //代理实现 @Override public void doHomework() { doStudy(); homework.doHomework(); System.out.println("XiaoWang helps with MathHomework"); doCheck(); } // 额外方法 private void doCheck() { System.out.println("XiaoWang is checking-----------------"); } // 额外方法 private void doStudy() { System.out.println("XiaoWang is studying---------------"); } }

小张：

public class XiaoZhang implements Homework{ // 持有Homework属性 private Homework homework; // 通过构造函数初始化Homework public XiaoZhang(Homework homework){ this.homework=homework; } //代理实现 @Override public void doHomework() { doStudy(); homework.doHomework(); System.out.println("XiaoZhang helps with EngHomework"); doCheck(); } // 额外方法 private void doCheck() { System.out.println("XiaoZhang is checking-----------------"); } // 额外方法 private void doStudy() { System.out.println("XiaoZhang is studying---------------"); } }

于是，小红可以放心地把作业交给小王和小张了：

public static void main(String[] args) { // 实例化一个目标对象 XiaoHong xiaoHong = new XiaoHong(); // 把目标对象通过构造函数传递给代理对象 XiaoZhang xiaoZhang =new XiaoZhang(xiaoHong); XiaoWang xiaoWang =new XiaoWang(xiaoHong); // 调用代理对象的方法 xiaoZhang.doHomework(); xiaoWang.doHomework(); }

输出：

XiaoZhang is studying--------------- XiaoHong did homework casually XiaoZhang helps with EngHomework XiaoZhang is checking----------------- XiaoWang is studying--------------- XiaoHong did homework casually XiaoWang helps with MathHomework XiaoWang is checking-----------------

问题来了，如果老师又布置了一个Book接口和readBook方法，但是readBook前后的动作是一样的（都需要study和check），如何通过代理来实现呢？

一个方案是让小王和小张都实现Book接口和readBook方法，并持有新的Book对象；另一个方案是再找一个小赵实现Book接口和readBook方法。

这样两种方案实际上都能达到效果，但是如果接口和方法增多起来呢？如果让一个代理类实现一堆方法，并持有一堆不同的对象，这个类势必会变得臃肿不堪；如果每一个新的方法都创建一个新的代码类，引用不同的对象，又会造成代码的大量重复。因此，动态代理就出现了。

▐动态代理

前文所讲的静态代理之所以为“静态”，是因为每个接口的每个方法，我们都要显式地去实现、创建、调用，所有的操作都是写死的、是静态的。而动态代理的巧妙之处在于，可以在程序的运行期间，动态的生成不同的代理类，来完成相同的工作。也就是说，如果你想实现一个方法，在所有其他方法执行前后做一些额外的相同的动作，例如打印日志、记录方法执行时间等，你就需要动态代理了（是不是想到了什么？）。

事实上所有的动态代理思想都是一致的，而目前最常用的动态代理实现有两种：JDK原生实现和Cglib开源实现。

Spring在5.X之前默认的动态代理实现一直是JDK动态代理。但是从5.X开始，Spring就开始默认使用Cglib来作为动态代理实现。并且SpringBoot从2.X开始也转向了Cglib动态代理实现。

• JDK实现动态代理

现在有一个牛X的机器人代理，可以帮所有人在完成老师布置的任何任务前后，进行学习和答案的核对，在JDK的动态代理实现中，他是这样编写的：

// 实现InvocationHandler public class RobotProxy implements InvocationHandler { // 持有一个Object类型的目标对象target private Object target; // 通过构造函数实例化目标对象target public RobotProxy(Object target) { this.target = target; } // 重写invoke方法 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { doStudy(); // 执行目标对象的方法 Object invoke = method.invoke(target, args); doCheck(); return invoke; } // 额外动作 private void doStudy() { System.out.println("Robot is studying------------"); } // 额外动作 private void doCheck() { System.out.println("Robot is checking------------"); } }

然后这样调用机器人代理：

public static void main(String[] args) { // 实例化一个目标对象 XiaoHong xiaoHong = new XiaoHong(); // 传入实现的接口 new Class[]{Homework.class} // 以及代理类 new RobotProxy(xiaoHong) Homework homework = (Homework)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Homework.class}, new RobotProxy(xiaoHong)); homework.doHomework(); }

输出：

Robot is studying------------ XiaoHong did homework casually Robot is checking------------

可以看到，JDK实现动态代理必须要依赖接口，只有实现了接口的目标类才可以被代理，而Cglib动态代理就可以消除接口的限制。

• Cglib实现动态代理

创建一个升级版的机器人RovotV2代理类：

// 实现MethodInterceptor方法（要引入cglib包） public class RobotV2Proxy implements MethodInterceptor { // 重写intercept方法 @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { doStudy(); Object invoke = methodProxy.invokeSuper(o, objects); doCheck(); return invoke; } // 额外动作 private void doStudy() { System.out.println("RobotV2 is studying------------"); } // 额外动作 private void doCheck() { System.out.println("RobotV2 is checking------------"); } }

调用方式：

public static void main(String[] args) { // 创建增强类 Enhancer enhancer = new Enhancer(); // 设置父类 enhancer.setSuperclass(XiaoHong.class); // 设置回调 enhancer.setCallback(new RobotV2Proxy()); // 创建目标对象 XiaoHong xiaoHong = (XiaoHong)enhancer.create(); // 调用目标方法 xiaoHong.doHomework(); }

输出：

RobotV2 is studying------------ XiaoHong did homework casually RobotV2 is checking------------

Cglib动态代理相比于JDK代理实现有几个优势：

1. 基于字节码，生成真实对象的子类。
2. 运行效率高于JDK代理
3. 不需要实现接口

可以看到，动态代理只需要一个代理类，就可以代理所有需要同一种处理（如上文所述的study()、check()）的类和方法，这就是动态代理与静态代理最大的区别。

Spring事务管理

OK，了解到了代理模式的好处之后，就可以自然而然的想到Spring事务管理的基本原理了。无非是借助动态代理，做一些额外的操作：在真正的方法执行之前开启事务，在方法顺利执行完成之后提交事务，如果方法执行过程中发生异常，要执行回滚操作。

一般有两种方法使用Spring的事务管理，一种是利用注解，一种是手动编程。本文因为使用的是注解型的事务管理，因此只对注解型事务的使用和原理进行探究，以找到事务没有生效的原因。

▐注解型事务

• 注解型事务使用

注解型事务的使用非常简单，只需要在需要事务管理的类或方法上加上@Transactional(rollbackFor = Exception.class)，其中rollbackFor指定的是遇到什么情况下执行回滚。

当然这个注解还有传播级别、隔离级别等我们背过的八股文属性，就不一一展开了。

,