面试必备技能：JDK动态代理给Spring事务埋下的坑！

心已赠人 2022-06-02 10:20 96阅读 0赞

## 一、场景分析 ##

最近做项目遇到了一个很奇怪的问题，大致的业务场景是这样的：我们首先设定两个事务，事务parent和事务child，在Controller里边同时调用这两个方法，示例代码如下：

**1、场景A：**

@RestController
    @RequestMapping(value = "/test")
    public class OrderController { 
    
        @Autowired
        private TestService userService;
    
        @GetMapping
        public void test() {
            //同时调用parent和child
            userService.parent();
            userService.child();
        }
    }

@Service
    public class TestServiceImpl implements TestService { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        @Transactional
        public void parent() {
            User parent = new User("张大壮 Parent", "123456", 45);
            userMapper.insert(parent);
        }
    
        @Override
        @Transactional
        public void child() {
            User child = new User("张大壮 Child", "654321", 25);
            userMapper.insert(child);
        }
    }

这里其实是分别执行了两个事务，执行的结果是两个方法都可以插入数据！如下：

![这里写图片描述][SouthEast]

**2、场景B：**

修改上述代码如下：

@RestController
    @RequestMapping(value = "/test")
    public class OrderController { 
    
        @Autowired
        private TestService userService;
    
        @GetMapping
        public void test() {
            userService.parent();
        }
    }

@Service
    public class TestServiceImpl implements TestService { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        @Transactional
        public void parent() {
            User parent = new User("张大壮 Parent", "123456", 45);
            userMapper.insert(parent);
            //在parent里边调用child
            child();
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void child() {
            User child = new User("张大壮 Child", "654321", 25);
            userMapper.insert(child);
        }
    }

> Propagation.REQUIRES\_NEW的含义表示：如果当前存在事务，则挂起当前事务并且开启一个新事务继续执行，新事务执行完毕之后，然后在缓刑之前挂起的事务，如果当前不存在事务的话，则开启一个新事务。

执行的结果是两个方法都可以插入数据！执行结果如下：

![这里写图片描述][SouthEast 1]

场景A和场景B都是正常的执行，期间没有发生任何的回滚，假如child（）方法中出现了异常！

**3、场景C**

修改child（）的代码如下所示，其他代码和场景B一样：

@Override
        @Transactional
        public void parent() {
            User parent = new User("张大壮 Parent", "123456", 45);
            userMapper.insert(parent);
            child();
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void child() {
            User child= new User("张大壮 Child", "654321", 25);
            userMapper.insert(child);
            throw new RuntimeException("child Exception....................");
        }

执行结果如下，会出现异常，并且数据都没有插入进去：

![这里写图片描述][SouthEast 2]

![这里写图片描述][SouthEast 3]

**疑问1：场景C中child（）抛出了异常，但是parent（）没有抛出异常，按道理是不是应该parent（）提交成功而child（）回滚？**

可能有的小伙伴要说了，child（）抛出了异常在parent（）没有进行捕获，造成了parent（）也是抛出了异常了的！所以他们两个都会回滚！

**4、场景D**

按照上述小伙伴的疑问这个时候，如果对parent（）方法修改，捕获child（）中抛出的异常，其他代码和场景C一样：

@Override
        @Transactional
        public void parent() {
            User parent = new User("张大壮 Parent", "123456", 45);
            userMapper.insert(parent);
            try {
                child();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void child() {
            User child = new User("张大壮 Child", "654321", 25);
            userMapper.insert(child);
            throw new RuntimeException("child Exception....................");
        }

然后再次执行，结果是两个都插入了数据库：

![这里写图片描述][SouthEast 4]

![这里写图片描述][SouthEast 5]

看到这里很多小伙伴都可能会问，按照我们的逻辑来想的话child（）中抛出了异常，parent（）没有抛出并且捕获了child（）抛出了异常！执行的结果应该是child（）回滚，parent（）提交成功的啊！

**疑问2：场景D为什么不是child（）回滚和parent（）提交成功哪？**

上述的场景C和场景D似乎融为了一题，要么都成功要么都失败！和我们预期的效果一点都不一样！看到这里这就是我们今天要探讨的主题《JDK动态代理给Spring事务埋下的坑！》接下来我们就分析一下Spring事务在该特定场景下不能回滚的深层次原因！

## 二、问题本质所在 ##

我们知道Spring事务管理是通过JDK动态代理的方式进行实现的（另一种是使用CGLib动态代理实现的），也正是因为动态代理的特性造成了上述parent（）方法调用child（）方法的时候造成了child（）方法中的事务失效！简单的来说，在场景D中parent（）方法调用child（）方法的时候，child（）方法的事务是不起作用的，此时的child（）方法像一个没有加事务的普通方法，其本质上就相当于下边的代码：

场景C本质：

![这里写图片描述][SouthEast 6]

场景D本质：

![这里写图片描述][SouthEast 7]

正如上述的代码，我们可以很轻松的解释**疑问1和疑问2**，因为动态代理的特性造成了场景C和场景D的本质如上述代码。在场景C中，child（）抛出异常没有捕获，相当于parent事务中抛出了异常，造成parent（）一起回滚，因为他们本质是同一个方法；在场景D中，child（）抛出异常并进行了捕获，parent事务中没有抛出异常，parent（）和child（）同时在一个事务里边，所以他们都成功了；

看到这里，那么动态代理的这个特性到底是什么才会造成Spring事务失效那？

## 三、动态代理的这个特性到底是什么？ ##

首先我们看一下一个简单的动态代理实现方式：

![这里写图片描述][SouthEast 8]

//接口
    public interface OrderService { 
    
        void test1();
    
        void test2();
    }
    
    //接口实现类
    public class OrderServiceImpl implements OrderService { 
    
        @Override
        public void test1() {
            System.out.println("--执行test1--");
        }
    
        @Override
        public void test2() {
            System.out.println("--执行test2--");
        }
    }

//代理类
    public class OrderProxy implements InvocationHandler { 
    
        private static final String METHOD_PREFIX = "test";
    
        private Object target;
    
        public OrderProxy(Object target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //我们使用这个标志来识别是否使用代理还是使用方法本体
            if (method.getName().startsWith(METHOD_PREFIX)) {
                System.out.println("========分隔符========");
            }
            return method.invoke(target, args);
        }
    
        public Object getProxy() {
            return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                    target.getClass().getInterfaces(), this);
        }
    }

//测试方法
    public class ProxyDemo {
    
        public static void main(String[] args) {
            OrderService orderService = new OrderServiceImpl();
            OrderProxy proxy = new OrderProxy(orderService);
            orderService = (OrderService) proxy.getProxy();
            orderService.test1();
            orderService.test2();
        }
    }

此时我们执行以下测试方法，注意了此时是同时调用了test1()和test2(）的，执行结果如下：

![这里写图片描述][SouthEast 9]

可以看出，在OrderServiceImpl 类中由于test1(）没有调用test2（），他们方法的执行都是使用了代理的，也就是说test1和test2都是通过代理对象调用的invoke（）方法，这和我们场景A和B类似。

假如我们模拟一下场景C和场景D在test1(）中调用test2（），那么代码修改为如下：

![这里写图片描述][SouthEast 10]

![这里写图片描述][SouthEast 11]

执行结果如下：

![这里写图片描述][SouthEast 12]

这里可以很清楚的看出来test1(）走的是代理，而test2（）走的是普通的方法，没有经过代理！看到这里你是否已经恍然大明白了呢？

这个应该可以很好的理解为什么是这样子！这是因为在Java中test1（）中调用test2（）中的方法，本质上就相当于把test2（）的方法体放入到test1（）中，也就是内部方法，同样的不管你嵌套了多少层，只有代理对象`proxy` 直接调用的那一个方法才是真正的走代理的，如下：

![这里写图片描述][SouthEast 13]

测试方法和上边的测试方法一样，执行结果如下：

![这里写图片描述][SouthEast 14]

**记住：只有代理对象proxy直接调用的那个方法才是真正的走代理的！**

## 四、如何解决这个坑？ ##

上文的分析中我们已经了解了为什么在该特定场景下使用Spring事务的时候造成事务无法回滚的问题，下边我们谈一下几种解决的方法：

1、我们可以选择逃避这个问题！我们可以不使用以上这种事务嵌套的方式来解决问题，最简单的方法就是把问题提到Service或者是更靠前的逻辑中去解决，使用service.xxxtransaction是不会出现这种问题的。

**2、通过AopProxy上下文获取代理对象：**

（1）SpringBoot配置方式：注解开启 `exposeProxy = true`，暴露代理对象 (否则AopContext.currentProxy()) 会抛出异常。

添加依赖：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

添加注解：

![这里写图片描述][SouthEast 15]

修改原有代码的执行方式为：

![这里写图片描述][SouthEast 16]

此时的执行结果为：

![这里写图片描述][SouthEast 17]

可见，child方法由于异常已经回滚了，而parent可以正确的提交，这才是我们想要的结果！注意的是在parent调用child的时候是通过try/catch捕获了异常的！

（2）传统Spring XML配置文件只需要添加依赖个设置如下配置即可，使用方式一样：

<aop:aspectj-autoproxy expose-proxy="true"/>

**3、通过ApplicationContext上下文进行解决：**

@Service
    public class TestServiceImpl implements TestService { 
    
        @Autowired
        private UserMapper userMapper;
    
        /** * Spring应用上下文 */
        @Autowired
        private ApplicationContext context;
    
        private TestService proxy;
    
        @PostConstruct
        public void init() {
            //从Spring上下文中获取AOP代理对象
            proxy = context.getBean(TestService.class);
        }
    
        @Override
        @Transactional
        public void parent() {
            User parent = new User("张大壮 Parent", "123456", 45);
            userMapper.insert(parent);
            try {
                proxy.child();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void child() {
            User child = new User("张大壮 Child", "654321", 25);
            userMapper.insert(child);
            throw new RuntimeException("child Exception....................");
        }
    }

执行结果符合我们的预期：

![这里写图片描述][SouthEast 18]

## 五、总结 ##

到此为止，我们简单的介绍了一下Spring事务管理中如果业务中有像场景C或者场景D的情况时，如果不清楚JDK动态代理造成Spring事务无法回滚的问题的话就可能是一个开发事故了，说不定是要扣工资的！

上文中简述了几种场景的事务使用和造成事务无法回滚的根本问题，当然讲述的还是表面的现象，并没有深入原理去分析，尽管如此，如果你在面试的时候能够对这个问题说一下自己的了解，也是一个加分项！

[SouthEast]: /images/20220602/cd36cfb401514934ab4b838be87d65c1.png
[SouthEast 1]: /images/20220602/351b953c5a094c26878371cc747240c6.png
[SouthEast 2]: /images/20220602/6e6243170ff54ef9a7f9dcfdf42e1f47.png
[SouthEast 3]: /images/20220602/e1bd8c3933774d80aa48bf21d46a4aba.png
[SouthEast 4]: /images/20220602/34fb61635dbb4ead8c57895cb70f758f.png
[SouthEast 5]: /images/20220602/c6b39cb08d854b3e8e13a6e17a7f6994.png
[SouthEast 6]: /images/20220602/2425752bff844016ab9186259b5d88c6.png
[SouthEast 7]: /images/20220602/a154911c63a04151b0f8d90ab7fd3c20.png
[SouthEast 8]: /images/20220602/619c57dc79ea4b4fb7a265d8fc0321f1.png
[SouthEast 9]: /images/20220602/10cba99729fb43b6b7aba21314642c07.png
[SouthEast 10]: /images/20220602/ba8929e7bf944b35933e1690f409fc12.png
[SouthEast 11]: /images/20220602/e86703a415fb49f7b71a7818d9dcbb53.png
[SouthEast 12]: /images/20220602/38b44afad13e4a1182919d8eb862446f.png
[SouthEast 13]: /images/20220602/2a22416fc63a4a20bc1205d347fb0fda.png
[SouthEast 14]: /images/20220602/15f5fde63da94c178fe527ccd1d19c14.png
[SouthEast 15]: /images/20220602/79575d3599904473aee8d459002f5295.png
[SouthEast 16]: /images/20220602/09a925ad25a84b578e8d15616dffcbca.png
[SouthEast 17]: /images/20220602/a0e4cfa2faac4a659abaf78faeb03102.png
[SouthEast 18]: /images/20220602/1794279c3c91435087f72234b9655baf.png