本文回顾了代理模式和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代理实现有几个优势：
- 基于字节码，生成真实对象的子类。
- 运行效率高于JDK代理
- 不需要实现接口
可以看到，动态代理只需要一个代理类，就可以代理所有需要同一种处理（如上文所述的study()、check()）的类和方法，这就是动态代理与静态代理最大的区别。
