spring声明式事务 同一类内方法调用事务失效(转)

原文 https://blog.csdn.net/jiesa/article/details/53438342

[问题]

Spring的声明式事务，我想就不用多介绍了吧，一句话“自从用了Spring AOP啊，事务管理真轻松啊，真轻松；事务管理代码没有了，脑不酸了，手不痛了，一口气全配上了事务；轻量级，测试起来也简单，嘿！”。不管从哪个角度看，轻量级声明式事务都是一件解放生产力的大好事。所以，我们“一直用它”。

不过，最近的一个项目里，却碰到了一个事务管理上的问题：有一个服务类，其一个声明了事务的方法，里面做了三次插入SQL操作，但是在后面出错回滚时，却发现前面插入成功了，也是说，这个声明了事务的方法，实际上并没有真正启动事务！怎么回事呢？难道Spring的声明式事务失效了？

[探幽]

其实以前也会碰到有人说，Spring的事务配置不起作用，但是根据第一反应和以往经验，我总会告诉他，肯定是你的配置有问题啦；所以这一次，我想也不会例外，大概是把事务注解配在了接口上而不是实现方法上，或者，如果是用XML声明方式的话，很可能是切入点的表达式没有配对。

不过，在检查了他们的配置后，却发现没有配置问题，该起事务的实现方法上，用了@Transactional事务注解声明，XML里也配了注解驱动<tx:annotation-driven .../>，配置很正确啊，怎么会不起作用？

我很纳闷，于是往下问：

问1：其他方法有这种情况么？

答1：没有。

问2：这个方法有什么特别的么（以下简称方法B）？

答2：就是调后台插了三条记录啊，没啥特别的。

问3：这个方法是从Web层直接调用的吧？

答3：不是，是这个Service类（以下简称ServiceA）的另外一个方法调过来的（以下简称方法A）。

问4：哦，那个调用它的方法配了事务么（问题可能在这了）？

答4：没有。

问5：那WEB层的Action（用的是Struts2），调用的是没有声明事务的方法A，方法A再调用声明了事务的方法B？

答5：对的。

问6：你直接在方法A上加上事务声明看看

答6：好。。。

看来可能找到问题所在了，于是把@Transactional也加在方法A上，启动项目测试，结果是：事务正常生效，方法A和方法B都在一个事务里了。

好了，现在总结一下现象：

1、ServiceA类为Web层的Action服务

2、Action调用了ServiceA的方法A，而方法A没有声明事务（原因是方法A本身比较耗时而又不需要事务）

3、ServiceA的方法A调用了自己的方法B，而方法B声明了事务，但是方法B的事务声明在这种情况失效了。

4、如果在方法A上也声明事务，则在Action调用方法A时，事务生效，而方法B则自动参与了这个事务。

我让他先把A也加上事务声明，决定回来自己再测一下。

这个问题，表面上是事务声明失效的问题，实质上很可能是Spring的AOP机制实现角度的问题。我想到很久以前研究Spring的AOP实现时发现的一个现象：对于以Cglib方式增强的AOP目标类，会创建两个对象，一个事Bean实例本身，一个是Cglib增强代理对象，而不仅仅是只有后者。我曾经疑惑过这一点，但当时没有再仔细探究下去。

我们知道，Spring的AOP实现方式有两种：1、Java代理方式；2、Cglib动态增强方式，这两种方式在Spring中是可以无缝*切换的。Java代理方式的优点是不依赖第三方jar包，缺点是不能代理类，只能代理接口。

Spring通过AopProxy接口，抽象了这两种实现，实现了一致的AOP方式：

现在看来，这种抽象同样带了一个缺陷，那就是抹杀了Cglib能够直接创建普通类的增强子类的能力，Spring相当于把Cglib动态生成的子类，当普通的代理类了，这也是为什么会创建两个对象的原因。下图显示了Spring的AOP代理类的实际调用过程：

因此，从上面的分析可以看出，methodB没有被AopProxy通知到，导致最终结果是：被Spring的AOP增强的类，在同一个类的内部方法调用时，其被调用方法上的增强通知将不起作用。

而这种结果，会造成什么影响呢：

1：内部调用时，被调用方法的事务声明将不起作用

2：换句话说，你在某个方法上声明它需要事务的时候，如果这个类还有其他开发者，你将不能保证这个方法真的会在事务环境中

3：再换句话说，Spring的事务传播策略在内部方法调用时将不起作用。不管你希望某个方法需要单独事务，是RequiresNew，还是要嵌套事务，要Nested，等等，统统不起作用。

4：不仅仅是事务通知，所有你自己利用Spring实现的AOP通知，都会受到同样限制。。。。

[解难]

问题的原因已经找到，其实，我理想中的AOP实现，应该是下面这样：

只要一个Cglib增强对象就好，对于Java代理方式，我的选择是毫不犹豫的抛弃。

至于前面的事务问题，只要避开Spring目前的AOP实现上的限制，要么都声明要事务，要么分开成两个类，要么直接在方法里使用编程式事务，那么一切OK。

 

 

二 具体解释

前些日子一朋友在需要在目标对象中进行自我调用，且需要实施相应的事务定义，且网上的一种通过BeanPostProcessor的解决方案是存在问题的。因此专门写此篇帖子分析why。

1、预备知识

aop概念请参考【http://www.iteye.com/topic/1122401】和【http://jinnianshilongnian.iteye.com/blog/1418596】

spring的事务管理，请参考【http://jinnianshilongnian.iteye.com/blog/1441271】

使用AOP 代理后的方法调用执行流程，如图所示

也就是说我们首先调用的是AOP代理对象而不是目标对象，首先执行事务切面，事务切面内部通过TransactionInterceptor环绕增强进行事务的增强，即进入目标方法之前开启事务，退出目标方法时提交/回滚事务。

2、测试代码准备

Java代码  

1. public interface AService {
2. public void a();
3. public void b();
4. }
5. @Service()
6. public class AServiceImpl1 implements AService{
7. @Transactional(propagation = Propagation.REQUIRED)
8. public void a() {
9. this.b();
10. }
11. @Transactional(propagation = Propagation.REQUIRES_NEW)
12. public void b() {
13. }
14. }

3、问题

目标对象内部的自我调用将无法实施切面中的增强，如图所示

此处的this指向目标对象，因此调用this.b()将不会执行b事务切面，即不会执行事务增强，因此b方法的事务定义“@Transactional(propagation = Propagation.REQUIRES_NEW)”将不会实施，即结果是b和a方法的事务定义是一样的，可以从以下日志看出：

org.springframework.transaction.annotation.AnnotationTransactionAttributeSource Adding transactional method 'a' with attribute: PROPAGATION_REQUIRED,ISOLATION_DEFAULT; ''

org.springframework.beans.factory.support.DefaultListableBeanFactory Returning cached instance of singleton bean 'txManager'

org.springframework.orm.hibernate4.HibernateTransactionManager Creating new transaction with name [com.sishuok.service.impl.AServiceImpl1.a]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT; ''  -----创建a方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Opened new Session …… for Hibernate transaction  ---打开Session

……

org.springframework.transaction.support.TransactionSynchronizationManager Initializing transaction synchronization

org.springframework.transaction.interceptor.TransactionInterceptor Getting transaction for [com.sishuok.service.impl.AServiceImpl1.a]

org.springframework.transaction.interceptor.TransactionInterceptor Completing transaction for [com.sishuok.service.impl.AServiceImpl1.a] ----完成a方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering beforeCommit synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering beforeCompletion synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Initiating transaction commit

org.springframework.orm.hibernate4.HibernateTransactionManager Committing Hibernate transaction on Session ……---提交a方法事务

或

org.springframework.orm.hibernate4.HibernateTransactionManager Rolling back Hibernate transaction on Session ……---如果有异常将回滚a方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering afterCommit synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering afterCompletion synchronization

org.springframework.transaction.support.TransactionSynchronizationManager Clearing transaction synchronization

……

org.springframework.orm.hibernate4.HibernateTransactionManager Closing Hibernate Session …… after transaction     --关闭Session

我们可以看到事务切面只对a方法进行了事务增强，没有对b方法进行增强。

3、解决方案

此处a方法中调用b方法时，只要通过AOP代理调用b方法即可走事务切面，即可以进行事务增强，如下所示：

Java代码  

1. public void a() {
2. aopProxy.b();//即调用AOP代理对象的b方法即可执行事务切面进行事务增强
3. }

判断一个Bean是否是AOP代理对象可以使用如下三种方法：

AopUtils.isAopProxy(bean)        ： 是否是代理对象；

AopUtils.isCglibProxy(bean)       ： 是否是CGLIB方式的代理对象；

AopUtils.isJdkDynamicProxy(bean) ： 是否是JDK动态代理方式的代理对象；

3.1、通过ThreadLocal暴露Aop代理对象

1、开启暴露Aop代理到ThreadLocal支持（如下配置方式从spring3开始支持）

Java代码  

1. <aop:aspectj-autoproxy expose-proxy="true"/><!—注解风格支持-->

Java代码  

1. <aop:config expose-proxy="true"><!—xml风格支持-->

2、修改我们的业务实现类

this.b();-----------修改为--------->((AService) AopContext.currentProxy()).b();

3、执行测试用例，日志如下

org.springframework.beans.factory.support.DefaultListableBeanFactory Returning cached instance of singleton bean 'txManager'

org.springframework.orm.hibernate4.HibernateTransactionManager Creating new transaction with name [com.sishuok.service.impl.AServiceImpl2.a]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT; ''   -----创建a方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Opened new Session ……for Hibernate transaction  --打开a Session

org.springframework.orm.hibernate4.HibernateTransactionManager Preparing JDBC Connection of Hibernate Session ……

org.springframework.orm.hibernate4.HibernateTransactionManager Exposing Hibernate transaction as JDBC transaction ……

……

org.springframework.transaction.support.TransactionSynchronizationManager Initializing transaction synchronization

org.springframework.transaction.interceptor.TransactionInterceptor Getting transaction for [com.sishuok.service.impl.AServiceImpl2.a]

org.springframework.transaction.annotation.AnnotationTransactionAttributeSource Adding transactional method 'b' with attribute: PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT; ''

……

org.springframework.orm.hibernate4.HibernateTransactionManager Suspending current transaction, creating new transaction with name [com.sishuok.service.impl.AServiceImpl2.b]  -----创建b方法事务（并暂停a方法事务）

……

org.springframework.orm.hibernate4.HibernateTransactionManager Opened new Session  for Hibernate transaction  ---打开b Session

……

org.springframework.transaction.support.TransactionSynchronizationManager Initializing transaction synchronization

org.springframework.transaction.interceptor.TransactionInterceptor Getting transaction for [com.sishuok.service.impl.AServiceImpl2.b]

org.springframework.transaction.interceptor.TransactionInterceptor Completing transaction for [com.sishuok.service.impl.AServiceImpl2.b] ----完成b方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering beforeCommit synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering beforeCompletion synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Initiating transaction commit

org.springframework.orm.hibernate4.HibernateTransactionManager Committing Hibernate transaction on Session …… ---提交b方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering afterCommit synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering afterCompletion synchronization

org.springframework.transaction.support.TransactionSynchronizationManager Clearing transaction synchronization

……

org.springframework.orm.hibernate4.HibernateTransactionManager Closing Hibernate Session …… after transaction  --关闭 b Session

-----到此b方法事务完毕

org.springframework.orm.hibernate4.HibernateTransactionManager Resuming suspended transaction after completion of inner transaction ---恢复a方法事务

……

org.springframework.transaction.support.TransactionSynchronizationManager Initializing transaction synchronization

org.springframework.transaction.interceptor.TransactionInterceptor Completing transaction for [com.sishuok.service.impl.AServiceImpl2.a] ----完成a方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering beforeCommit synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering beforeCompletion synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Initiating transaction commit

org.springframework.orm.hibernate4.HibernateTransactionManager Committing Hibernate transaction on Session ……---提交a方法事务

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering afterCommit synchronization

org.springframework.orm.hibernate4.HibernateTransactionManager Triggering afterCompletion synchronization

org.springframework.transaction.support.TransactionSynchronizationManager Clearing transaction synchronization

……

org.springframework.orm.hibernate4.HibernateTransactionManager Closing Hibernate Session …… after transaction  --关闭 a Session

此处我们可以看到b方法的事务起作用了。

以上方式是解决目标对象内部方法自我调用并实施事务的最简单的解决方案。

4、实现原理分析

4.1、在进入代理对象之后通过AopContext.serCurrentProxy(proxy)暴露当前代理对象到ThreadLocal，并保存上次ThreadLocal绑定的代理对象为oldProxy；

4.2、接下来我们可以通过 AopContext.currentProxy() 获取当前代理对象；

4.3、在退出代理对象之前要重新将ThreadLocal绑定的代理对象设置为上一次的代理对象，即AopContext.serCurrentProxy(oldProxy)。

有些人不喜欢这种方式，说通过ThreadLocal暴露有性能问题，其实这个不需要考虑，因为事务相关的（Session和Connection）内部也是通过SessionHolder和ConnectionHolder暴露到ThreadLocal实现的。

不过自我调用这种场景确实只有很少情况遇到，因此不用这种方式我们也可以通过如下方式实现。

3.2、通过初始化方法在目标对象中注入代理对象

Java代码  

1. @Service
2. public class AServiceImpl3 implements AService{
3. @Autowired  //①  注入上下文
4. private ApplicationContext context;
5. private AService proxySelf; //②  表示代理对象，不是目标对象
6. @PostConstruct  //③ 初始化方法
7. private void setSelf() {
8. //从上下文获取代理对象（如果通过proxtSelf=this是不对的，this是目标对象）
9. //此种方法不适合于prototype Bean，因为每次getBean返回一个新的Bean
10. proxySelf = context.getBean(AService.class);
11. }
12. @Transactional(propagation = Propagation.REQUIRED)
13. public void a() {
14. proxySelf.b(); //④ 调用代理对象的方法 这样可以执行事务切面
15. }
16. @Transactional(propagation = Propagation.REQUIRES_NEW)
17. public void b() {
18. }
19. }

此处日志就不分析，和3.1类似。此种方式不是很灵活，所有需要自我调用的实现类必须重复实现代码。

3.3、通过BeanPostProcessor 在目标对象中注入代理对象

此种解决方案可以参考http://fyting.iteye.com/blog/109236。

BeanPostProcessor 的介绍和使用敬请等待我的下一篇分析帖。

一、定义BeanPostProcessor 需要使用的标识接口

Java代码  

1. public interface BeanSelfAware {
2. void setSelf(Object proxyBean);
3. }

即我们自定义的BeanPostProcessor （InjectBeanSelfProcessor）如果发现我们的Bean是实现了该标识接口就调用setSelf注入代理对象。

二、Bean实现

Java代码  

1. @Service
2. public class AServiceImpl4 implements AService, BeanSelfAware {//此处省略接口定义
3. private AService proxySelf;
4. public void setSelf(Object proxyBean) { //通过InjectBeanSelfProcessor注入自己（目标对象）的AOP代理对象
5. this.proxySelf = (AService) proxyBean;
6. }
7. @Transactional(propagation = Propagation.REQUIRED)
8. public void a() {
9. proxySelf.b();//调用代理对象的方法 这样可以执行事务切面
10. }
11. @Transactional(propagation = Propagation.REQUIRES_NEW)
12. public void b() {
13. }
14. }

实现BeanSelfAware标识接口的setSelf将代理对象注入，并且通过“proxySelf.b()”这样可以实施b方法的事务定义。

三、InjectBeanSelfProcessor实现

Java代码  

1. @Component
2. public class InjectBeanSelfProcessor implements BeanPostProcessor {
3. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
4. return bean;
5. }
6. public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
7. if(bean instanceof BeanSelfAware) {//如果Bean实现了BeanSelfAware标识接口，就将代理对象注入
8. ((BeanSelfAware) bean).setSelf(bean); //即使是prototype Bean也可以使用此种方式
9. }
10. return bean;
11. }
12. }

postProcessAfterInitialization根据目标对象是否实现BeanSelfAware标识接口，通过setSelf(bean)将代理对象（bean）注入到目标对象中，从而可以完成目标对象内部的自我调用。

关于BeanPostProcessor的执行流程等请一定参考我的这篇帖子，否则无法继续往下执行。

四、InjectBeanSelfProcessor的问题

（1、场景：通过InjectBeanSelfProcessor进行注入代理对象且循环依赖场景下会产生前者无法通过setSelf设置代理对象的问题。 循环依赖是应该避免的，但是实际工作中不可避免会有人使用这种注入，毕竟没有强制性。

（2、用例

（2.1、定义BeanPostProcessor 需要使用的标识接口

和3.1中一样此处不再重复。

（2.2、Bean实现

Java代码  

1. @Service
2. public class AServiceImpl implements AService, BeanSelfAware {//此处省略Aservice接口定义
3. @Autowired
4. private BService bService;   //①  通过@Autowired方式注入BService
5. private AService self;       //②  注入自己的AOP代理对象
6. public void setSelf(Object proxyBean) {
7. this.self = (AService) proxyBean;  //③ 通过InjectBeanSelfProcessor注入自己（目标对象）的AOP代理对象
8. System.out.println("AService=="+ AopUtils.isAopProxy(this.self)); //如果输出true标识AOP代理对象注入成功
9. }
10. @Transactional(propagation = Propagation.REQUIRED)
11. public void a() {
12. self.b();
13. }
14. @Transactional(propagation = Propagation.REQUIRES_NEW)
15. public void b() {
16. }
17. }

Java代码  

1. @Service
2. public class BServiceImpl implements BService, BeanSelfAware {//此处省略Aservice接口定义
3. @Autowired
4. private AService aService;  //①  通过@Autowired方式注入AService
5. private BService self;      //②  注入自己的AOP代理对象
6. public void setSelf(Object proxyBean) {  //③ 通过InjectBeanSelfProcessor注入自己（目标对象）的AOP代理对象
7. this.self = (BService) proxyBean;
8. System.out.println("BService=" + AopUtils.isAopProxy(this.self)); //如果输出true标识AOP代理对象注入成功
9. }
10. @Transactional(propagation = Propagation.REQUIRED)
11. public void a() {
12. self.b();
13. }
14. @Transactional(propagation = Propagation.REQUIRES_NEW)
15. public void b() {
16. }
17. }

此处A依赖B，B依赖A，即构成循环依赖，此处不探讨循环依赖的设计问题（实际工作应该避免循环依赖），只探讨为什么循环依赖会出现注入代理对象失败的问题。

循环依赖请参考我的博文【http://jinnianshilongnian.iteye.com/blog/1415278】。

依赖的初始化和销毁顺序请参考我的博文【http://jinnianshilongnian.iteye.com/blog/1415461】。

（2.3、InjectBeanSelfProcessor实现

和之前3.3中一样 此处不再重复。

（2.4、测试用例

Java代码  

1. @RunWith(value = SpringJUnit4ClassRunner.class)
2. @ContextConfiguration(value = {"classpath:spring-config.xml"})
3. public class SelfInjectTest {
4. @Autowired
5. AService aService;
6. @Autowired
7. BService bService;
8. @Test
9. public void test() {
10. }
11. }

执行如上测试用例会输出：

BService=true

AService==false

即BService通过InjectBeanSelfProcessor注入代理对象成功，而AService却失败了（实际是注入了目标对象），如下是debug得到的信息：

（2. 5、这是为什么呢，怎么在循环依赖会出现这种情况？

敬请期待我的下一篇分析帖。

3.4、改进版的InjectBeanSelfProcessor的解决方案

Java代码  

1. @Component
2. public class InjectBeanSelfProcessor2 implements BeanPostProcessor, ApplicationContextAware {
3. private ApplicationContext context;
4. //① 注入ApplicationContext
5. public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
6. this.context = applicationContext;
7. }
8. public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
9. if(!(bean instanceof BeanSelfAware)) { //② 如果Bean没有实现BeanSelfAware标识接口 跳过
10. return bean;
11. }
12. if(AopUtils.isAopProxy(bean)) { //③ 如果当前对象是AOP代理对象，直接注入
13. ((BeanSelfAware) bean).setSelf(bean);
14. } else {
15. //④ 如果当前对象不是AOP代理，则通过context.getBean(beanName)获取代理对象并注入
16. //此种方式不适合解决prototype Bean的代理对象注入
17. ((BeanSelfAware)bean).setSelf(context.getBean(beanName));
18. }
19. return bean;
20. }
21. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
22. return bean;
23. }
24. }

5、总结

纵观其上：

【3.1 通过ThreadLocal暴露Aop代理对象】适合解决所有场景（不管是singleton Bean还是prototype Bean）的AOP代理获取问题（即能解决目标对象的自我调用问题）；

【3.2 通过初始化方法在目标对象中注入代理对象】 和【3.4 改进版的InjectBeanSelfProcessor的解决方案】能解决普通（无循环依赖）的AOP代理对象注入问题，而且也能解决【3.3】中提到的循环依赖（应该是singleton之间的循环依赖）造成的目标对象无法注入AOP代理对象问题，但该解决方案不适合解决循环依赖中包含prototype Bean的自我调用问题；

【3.3 通过BeanPostProcessor 在目标对象中注入代理对象】：只能解决 普通（无循环依赖）的 的Bean注入AOP代理，无法解决循环依赖的AOP代理对象注入问题，即无法解决目标对象的自我调用问题。

jingnianshilongnian 写道

spring允许的循环依赖（只考虑单例和原型Bean）：
A----B
B----A
只有在A和B都不为原型是允许的，即如果A和B都是prototype则会报错（无法进行原型Bean的循环依赖）。
A（单例）---B（单例） 或 A（原型）---B（单例） 这是可以的，但 A（原型）---B（原型）或 A（原型）---B（单例Lazy）【且context.getBean("A")】时 这是不允许的。

一、A（原型）---B（原型） A（原型）---B（单例Lazy）【且context.getBean("A")】 会报：
Error creating bean with name 'BServiceImpl': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.sishuok.issue.AService com.sishuok.issue.impl.BServiceImpl.aService; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'AServiceImpl': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.sishuok.issue.BService com.sishuok.issue.impl.AServiceImpl.bService; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'BServiceImpl': Requested bean is currently in creation: [color=red]Is there an unresolvable circular reference[/color]?

二、A（原型）---B（单例） 和 A（单例）---B（单例）
这种方式 使用我的 【3.3 通过BeanPostProcessor 在目标对象中注入代理对象】 是没有问题的。

因此【 3.4 改进版的InjectBeanSelfProcessor的解决方案 】 可以作为最后的解决方案。