`

Spring事务处理时自我调用的解决方案及一些实现方式的风险

 
阅读更多
前些日子一朋友在需要在目标对象中进行自我调用，且需要实施相应的事务定义，且网上的一种通过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、测试代码准备 
public interface AService {  
    public void a();  
    public void b();  
}  
   
@Service()  
public class AServiceImpl1 implements AService{  
    @Transactional(propagation = Propagation.REQUIRED)  
    public void a() {  
        this.b();  
    }  
    @Transactional(propagation = Propagation.REQUIRES_NEW)  
    public void b() {  
    }  
}

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方法即可走事务切面，即可以进行事务增强，如下所示： 

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


判断一个Bean是否是AOP代理对象可以使用如下三种方法：
AopUtils.isAopProxy(bean)        ： 是否是代理对象；
AopUtils.isCglibProxy(bean)       ： 是否是CGLIB方式的代理对象；
AopUtils.isJdkDynamicProxy(bean) ： 是否是JDK动态代理方式的代理对象；
3.1、通过ThreadLocal暴露Aop代理对象
1、开启暴露Aop代理到ThreadLocal支持（如下配置方式从spring3开始支持） 

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

<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、通过初始化方法在目标对象中注入代理对象 

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


此处日志就不分析，和3.1类似。此种方式不是很灵活，所有需要自我调用的实现类必须重复实现代码。
3.3、通过BeanPostProcessor 在目标对象中注入代理对象
此种解决方案可以参考http://fyting.iteye.com/blog/109236。

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

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


public interface BeanSelfAware {  
    void setSelf(Object proxyBean);  
}
 
即我们自定义的BeanPostProcessor （InjectBeanSelfProcessor）如果发现我们的Bean是实现了该标识接口就调用setSelf注入代理对象。

二、Bean实现 

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

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

三、InjectBeanSelfProcessor实现 


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


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

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

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

（2、用例
（2.1、定义BeanPostProcessor 需要使用的标识接口
和3.1中一样此处不再重复。

（2.2、Bean实现 


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

  


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

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

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

（2.3、InjectBeanSelfProcessor实现
和之前3.3中一样 此处不再重复。

（2.4、测试用例 


@RunWith(value = SpringJUnit4ClassRunner.class)  
@ContextConfiguration(value = {"classpath:spring-config.xml"})  
public class SelfInjectTest {  
    @Autowired  
    AService aService;  
    @Autowired  
    BService bService;  
    @Test  
    public void test() {  
    }  
}

 
执行如上测试用例会输出：
BService=true
AService==false
即BService通过InjectBeanSelfProcessor注入代理对象成功，而AService却失败了（实际是注入了目标对象），如下是debug得到的信息：






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

敬请期待我的下一篇分析帖。
3.4、改进版的InjectBeanSelfProcessor的解决方案 

@Component  
public class InjectBeanSelfProcessor2 implements BeanPostProcessor, ApplicationContextAware {  
    private ApplicationContext context;  
    //① 注入ApplicationContext  
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {  
        this.context = applicationContext;  
    }  
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {  
        if(!(bean instanceof BeanSelfAware)) { //② 如果Bean没有实现BeanSelfAware标识接口 跳过  
            return bean;  
        }  
        if(AopUtils.isAopProxy(bean)) { //③ 如果当前对象是AOP代理对象，直接注入  
            ((BeanSelfAware) bean).setSelf(bean);  
        } else {  
            //④ 如果当前对象不是AOP代理，则通过context.getBean(beanName)获取代理对象并注入  
            //此种方式不适合解决prototype Bean的代理对象注入  
            ((BeanSelfAware)bean).setSelf(context.getBean(beanName));  
        }  
        return bean;  
    }  
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {  
        return bean;  
    }  
}

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: Is there an unresolvable circular reference?

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

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


没有完美的解决方案，只有最适用的解决方案。

测试代码请参考附件，jar包与http://www.iteye.com/topic/1120924使用的是一样的
分享到：
| SpringMVC + spring3.1.1 + hibernate4.1.0 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring延迟加载和声明式事务处理最终解决方案(修正版)

    为了解决这个问题，Spring提供了两种主要解决方案： 1. **Open Session in View Interceptor (OSIV)**：这是Spring MVC中的一个拦截器，它的作用是在整个视图渲染过程中保持Hibernate Session的开放，确保在需要的...

    spring基于AOP实现事务

    对于Spring事务管理，我们通常有两种方式：编程式和声明式。编程式事务管理需要在代码中显式地调用begin、commit、rollback等事务控制方法，而声明式事务管理则是在配置文件或注解中声明事务规则，更加简洁且易于...

    springboot多数据源即分布式事务解决方案

    如果不想使用JTA，Spring还提供了一种基于编程式事务管理的解决方案，称为PROPAGATION_REQUIRED。在这种模式下，开发者需要手动调用`TransactionTemplate`或在Service方法上使用`@Transactional`注解来开启和管理...

    Spring自定义切面事务问题

    在开发基于Spring框架的应用程序时，我们经常需要利用AOP（面向切面编程）来实现横切关注点（如日志记录、安全控制、事务管理等）的模块化处理。其中，事务管理是保证数据一致性的重要手段之一。然而，在实际开发...

    spring事务详解

    总之，Spring事务框架提供了一套功能强大、易于使用的事务管理解决方案，它不仅可以减少代码量，提高开发效率，还可以通过声明式配置来提升代码的可读性和可维护性。对于希望深入学习Spring事务管理的开发者而言，...

    Spring事务管理的jar包

    Spring提供了全面的事务管理解决方案，使得开发者可以方便地控制事务的边界，保证数据的一致性和完整性。本篇将深入探讨Spring事务管理的核心概念、工作原理以及如何使用`spring-tx-3.2.0.RELEASE.jar`这个jar包。 ...

    spring编程式事务实现

    总的来说，`TransactionTemplate`为Spring编程式事务提供了一种简洁、可复用的解决方案。通过它，开发者可以在不牺牲事务控制灵活性的同时，避免过多的事务管理代码侵入业务逻辑。然而，在实际应用中，应当根据项目...

    详细整理Spring事务失效的具体场景及解决方案.docx

    "Spring事务失效的具体场景及解决方案详细整理" 在实际项目开发中，为了保证业务数据的一致性，大家一般都会采用事务机制。但是，很多小伙伴可能只是简单了解一下，遇到事务失效的情况，便会无从下手。下面我们将...

    spring事务管理

    ### Spring事务管理详解 #### 一、事务管理基础概念 在深入探讨Spring事务管理之前，我们需要先理解什么是事务。事务可以被定义为一系列的操作集合，这些操作作为一个整体被提交或回滚。简单来说，事务就是一个不...

    关于SpringMyBatis纯注解事务不能提交的问题分析与解决

    本文主要针对在Spring + MyBatis环境下，或使用Spring JDBC时，Oracle事务不能正常提交的问题进行了深入分析，并提出了相应的解决方案。根据提供的部分内容，我们发现该问题与不同的数据源配置有关。具体来说，当...

    Spring事务管理和SpringJDBC思维导图

    在思维导图"Spring Transaction.twd"中，可能包含了Spring事务管理的各个概念和它们之间的关系，如事务的ACID属性（原子性、一致性、隔离性和持久性），事务管理器，以及声明式和编程式事务管理的实现方式。...

    spring事务几种传播方式

    ### Spring事务传播方式详解 #### 一、引言 在基于Spring框架开发的应用程序中，事务管理是一项重要的功能。为了确保数据的一致性和完整性，合理地配置事务的传播行为至关重要。Spring提供了多种事务传播行为选项...

    解决osgi spring 事务配置问题

    Spring Dynamic Modules（Spring-DM，现在已经被Spring OSGi取代）提供了一种方式来处理这种情况，它可以帮助我们在OSGi环境中创建透明的Spring事务代理。 此外，我们需要确保所有涉及事务的服务都在同一个...

    spring事务总结.docx

    然而，在实际开发过程中，经常会遇到一些关于Spring事务的问题，如事务失效、事务回滚、大事务问题以及编程式事务等。本文将深入探讨这些问题，并给出相应的解决方案。 #### 一、事务不生效的原因及解决办法 1. **...

    spring 的3种事务配置方式

    本文将详细介绍Spring中的三种事务配置方式：编程式事务管理、声明式事务管理以及基于注解的事务管理。 **1. 编程式事务管理** 编程式事务管理是通过编程的方式手动控制事务的开始、提交、回滚等操作。主要使用`...

    AOP实现自我调用的事物嵌套问题

    当我们遇到"AOP实现自我调用的事物嵌套问题"时，这通常涉及到Spring框架中的事务管理，特别是自调用方法在事务处理时可能会引发的问题。 首先，让我们理解Spring AOP的事务管理是如何工作的。Spring使用代理模式来...

    Spring+MyBatis+Atomikos实现JTA分布式事务

    Atomikos则是开源的JTA（Java Transaction API）实现，能够提供分布式事务解决方案。本文将深入探讨如何使用Spring、MyBatis和Atomikos实现JTA分布式事务。 首先，让我们理解JTA的概念。Java Transaction API（JTA...

    spring事务管理.rar

    常见问题及解决方案 - **事务边界问题**：确保事务的正确边界，避免事务过大或过小，影响性能和数据一致性。 - **事务回滚规则**：理解`rollbackFor`和`noRollbackFor`如何工作，以正确处理异常。 - **事务隔离...

    spring + JTA + JOTM实现分布式事务

    Spring是一个强大的企业级应用开发框架，它提供了一整套事务管理解决方案，包括编程式和声明式事务管理。对于分布式事务，Spring支持JTA事务管理，并且可以无缝集成JOTM。 1. **配置JOTM**：首先，你需要在项目的类...

Magicbox
Global site tag (gtag.js) - Google Analytics