前言
最近在开发业务代码的时候,犯了一个事务注解的错误:在同一个类的非事务方法中调用了另一个事务方法,导致事务没有生效,如下所示:
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()是一个事务方法:
@Transactionalpublic 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 casuallyXiaoZhang helps with EngHomeworkXiaoZhang is checking----------------- XiaoWang is studying---------------XiaoHong did homework casuallyXiaoWang helps with MathHomeworkXiaoWang 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的动态代理实现中,他是这样编写的:
// 实现InvocationHandlerpublic 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 casuallyRobot 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 casuallyRobotV2 is checking------------
Cglib动态代理相比于JDK代理实现有几个优势:
- 基于字节码,生成真实对象的子类。
- 运行效率高于JDK代理
- 不需要实现接口
可以看到,动态代理只需要一个代理类,就可以代理所有需要同一种处理(如上文所述的study()、check())的类和方法,这就是动态代理与静态代理最大的区别。
Spring事务管理
OK,了解到了代理模式的好处之后,就可以自然而然的想到Spring事务管理的基本原理了。无非是借助动态代理,做一些额外的操作:在真正的方法执行之前开启事务,在方法顺利执行完成之后提交事务,如果方法执行过程中发生异常,要执行回滚操作。
一般有两种方法使用Spring的事务管理,一种是利用注解,一种是手动编程。本文因为使用的是注解型的事务管理,因此只对注解型事务的使用和原理进行探究,以找到事务没有生效的原因。
▐注解型事务
- 注解型事务使用
注解型事务的使用非常简单,只需要在需要事务管理的类或方法上加上@Transactional(rollbackFor = Exception.class),其中rollbackFor指定的是遇到什么情况下执行回滚。
当然这个注解还有传播级别、隔离级别等我们背过的八股文属性,就不一一展开了。