Spring 自动事务代理

记⼀次实际开发过程中遇到事务报错问题Transactionsynchronizationi。

⼀：问题场景 在⼀次http请求的后台接⼝中返回结果中出现了这个错误信息“Transaction synchronization is not active”，意思是“事务同步器没有激活”，但是被调⽤的接⼝已经添加了@Transactional注解，所以百思不得不得其解为什么还会报这个错误，那么是什么原因引起了这个异常呢？⾃⼰通过百度⼤神博客终于找到⼀篇相似的⽂章解决了⾃⼰的问题，今天就是把解决⽅案记录下来为以后再出现类似情况提供解决⽅案。

⼆：出现原因 Google搜索⼀番之后，发现了这篇⽂章Spring的TransactionEventListener，⽂中提到了可能出现这个错误信息的⼀种情况： @EventListener public void afterRegisterSendMail(MessageEvent event) { // Spring 4.2 之前 TransactionSynchronizationManager.registerSynchronization( new TransactionSynchronizationAdapter() { @Override public void afterCommit() { internalSendMailNotification(event); } }); } 上⾯的代码将在事务提交后执⾏.如果在⾮事务context中（就是⽅法未开启spring事务）将抛出ng.IllegalStateException: Transaction synchronization is not active 于是找到⾃⼰代码中的TransactionSynchronizationManager部分，果然在当前http请求链路中的⼀个接⼝⾥发现了类似的代码： TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() { @Override public void afterCommit() { try { byte[] bytes = JSON.toJSONBytes(task, new SerializeConfig()); MessageProperties messageProperties = new MessageProperties(); messageProperties.setMessageId(idWorker.nextStringId()); Message message = new Message(bytes, messageProperties); salaryFileMsgProducer.sendSalaryFileMsg(message); } catch (Exception e) { log.error(e.getMessage()); e.printStackTrace(); } } }); 想必是执⾏这段代码的时候报的异常，但是上⾯那篇⽂章说了引起这个异常的原因是“在⾮事务context中注册同步器”，难道当前事务没有开启？我们的业务代码⼀般都是使⽤spring的注解@Transactional来开启事务，那么去看⼀下开启事务的代码⽚段。

Spring事务原理统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatusspring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。

PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：TransactionDefinition td = new TransactionDefinition();TransactionStatus ts = transactionManager.getTransaction(td);try{ //do sthmit(ts);}catch(Exception e){transactionManager.rollback(ts);}spring提供的事务管理可以分为两类：编程式的和声明式的。

编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。

省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.void add(){transactionTemplate.execute( new TransactionCallback(){pulic Object doInTransaction(TransactionStatus ts){ //do sth}}}声明式：使用TransactionProxyFactoryBean:<bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name="transactionManager"><ref bean="transactionManager"/></property><property name="target"><ref local="userManagerTarget"/></property><property name="transactionAttributes"><props><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean>围绕Poxy的动态代理能够自动的提交和回滚事务org.springframework.transaction.interceptor.TransactionProxyFactoryBeanPROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。

spring 事务实现原理Spring事务的实现原理主要依赖于数据库或者其他存储系统的事务功能。

1. 数据库事务支持：Spring事务的实现依赖于数据库的事务功能。

通常情况下，数据库支持ACID（原子性、一致性、隔离性和持久性）事务特性，可以通过SQL的BEGIN、COMMIT 和ROLLBACK等命令来控制事务的开始、提交和回滚操作。

2. 事务管理器：Spring框架提供了事务管理器（TransactionManager）接口，用于管理事务的开始、提交和回滚等操作。

事务管理器可以根据配置信息选择不同的实现，如使用JDBC事务管理器（DataSourceTransactionManager）或者JTA事务管理器（JtaTransactionManager）等。

3. 编程式事务：Spring框架提供了编程式事务管理的支持，通过编写代码显式地控制事务的边界。

开发者可以在代码中使用事务管理器的API来手动管理事务，包括事务的开始、提交和回滚等操作。

这种方式灵活性较高，但也需要开发者手动处理事务的细节。

4. 声明式事务：Spring框架还提供了声明式事务管理的支持，通过使用注解或者XML配置来定义事务的属性和边界。

开发者可以使用@Transactional注解或者事务配置元素来标记方法或者类，指示该方法或者类在执行时需要开启事务。

Spring会在方法调用前后自动地管理事务的开始、提交和回滚等操作。

5. 事务传播行为：Spring事务还支持事务传播行为的定义，即一个方法调用另一个带有事务的方法时事务该如何传播。

例如，当前方法可能会暂停事务、加入到现有的事务中或者创建一个新的事务。

Spring提供了多种事务传播行为的选项，如REQUIRED、REQUIRES_NEW、NESTED等，可以根据需要进行配置。

总的来说，Spring事务的实现原理是通过与数据库或其他存储系统的事务功能结合，通过事务管理器来管理事务的开始、提交和回滚等操作。

SpringAOP的原理和应用场景SpringAOP（Aspect-Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种通过预定义的方式，将横切关注点（Cross-cutting Concerns）与业务逻辑进行解耦的机制。

本文将介绍SpringAOP的原理及其在实际应用场景中的应用。

一、SpringAOP的原理SpringAOP基于代理模式（Proxy Pattern）实现。

在SpringAOP中，通过生成与原始类（被代理类）具有相同接口的代理类，将横切逻辑编织到业务逻辑中。

在运行时，当调用代理类的方法时，会在方法执行前、后或异常抛出时插入相应的横切逻辑代码。

具体而言，SpringAOP使用了以下几个核心概念：1. 切面（Aspect）：切面是横切逻辑的模块化单元，它包含了一组通知（Advice）和切点（Pointcut）。

2. 通知（Advice）：通知定义了实际的横切逻辑代码，并规定了何时执行该代码。

SpringAOP提供了五种类型的通知：前置通知（Before）、后置通知（After）、返回通知（After-returning）、异常通知（After-throwing）和环绕通知（Around）。

3. 切点（Pointcut）：切点指定了在哪些连接点（Join Point）上执行通知。

连接点可以是方法调用、属性访问等程序执行的点。

4. 连接点（Join Point）：连接点是程序执行过程中的一个特定点，如方法调用前、方法调用后等。

通知通过切点来选择连接点。

5. 织入（Weaving）：织入是将切面应用到目标对象，并创建代理对象的过程。

织入可以在编译时、类加载时或运行时进行。

二、SpringAOP的应用场景SpringAOP可应用于各种场景，用于解决跨越多个模块或类的横切关注点问题。

以下是一些常见的SpringAOP应用场景：1. 日志记录：通过在关键方法的前后插入日志代码，实现对系统运行状态的监控和记录。

SpringBoot事务注解详解SpringBoot事务注解详解@Transactionalspring 事务注解1.简单开启事务管理@EnableTransactionManagement // 启注解事务管理，等同于xml配置⽅式的 <tx:annotation-driven />2.事务注解详解默认遇到throw new RuntimeException(“…”);会回滚需要捕获的throw new Exception(“…”);不会回滚指定回滚@Transactional(rollbackFor=Exception.class)public void methodName() {// 不会回滚throw new Exception("...");}指定不回滚@Transactional(noRollbackFor=Exception.class)public ItimDaoImpl getItemDaoImpl() {// 会回滚throw new RuntimeException("注释");}如果有事务,那么加⼊事务,没有的话新建⼀个(不写的情况下)@Transactional(propagation=Propagation.REQUIRED)容器不为这个⽅法开启事务@Transactional(propagation=Propagation.NOT_SUPPORTED)readOnly=true只读,不能更新,删除@Transactional (propagation = Propagation.REQUIRED,readOnly=true)设置超时时间@Transactional (propagation = Propagation.REQUIRED,timeout=30)设置数据库隔离级别@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)3.指定事务管理器spring Boot 使⽤事务⾮常简单，⾸先使⽤注解 @EnableTransactionManagement 开启事务⽀持后，然后在访问数据库的Service⽅法上添加注解 @Transactional 便可。

Spring声明式事务注解之@EnableTransactionManagement解析Spring声明式事务注解之@EnableTransactionManagement1. 说明@EnableTransactionManagement声明在主配置类上，表⽰开启声明式事务，其原理是通过@Import导⼊TransactionManagementConfigurationSelector组件，然后⼜通过TransactionManagementConfigurationSelector导⼊组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration；2. 原理分析@EnableTransactionManagement代码实现如下：@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented// 通过@Import导⼊TransactionManagementConfigurationSelector组件@Import(TransactionManagementConfigurationSelector.class)public @interface EnableTransactionManagement {boolean proxyTargetClass() default false;AdviceMode mode() default AdviceMode.PROXY;int order() default Ordered.LOWEST_PRECEDENCE;}@EnableTransactionManagement通过@Import导⼊TransactionManagementConfigurationSelector；TransactionManagementConfigurationSelector的实现如下：public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {/*** {@inheritDoc}* @return {@link ProxyTransactionManagementConfiguration} or* {@code AspectJTransactionManagementConfiguration} for {@code PROXY} and* {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()}, respectively*/@Overrideprotected String[] selectImports(AdviceMode adviceMode) {switch (adviceMode) {case PROXY:// 根据@EnableTransactionManagement的固定值PROXY，这⾥会导⼊AutoProxyRegistrar组件和ProxyTransactionManagementConfiguration组件 return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};case ASPECTJ:return new String[] {TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};default:return null;}}}所以TransactionManagementConfigurationSelector⼜导⼊了组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration；3. AutoProxyRegistrar分析3.1 AutoProxyRegistrar继承关系InfrastructureAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--ProxyProcessorSupport--SmartInstantiationAwareBeanPostProcessor // 跟AOP是原理是⼀样的--InstantiationAwareBeanPostProcessor--BeanPostProcessor--BeanFactoryAware3.2 AutoProxyRegistrar的所⽤AutoProxyRegistrar的作⽤跟AOP中的AnnotationAwareAspectJAutoProxyCreator是⼀样的，利⽤后置处理器机制在对象创建以后，包装对象，返回⼀个代理对象（增强器），代理对象执⾏⽅法利⽤拦截器链进⾏调⽤；InfrastructureAdvisorAutoProxyCreator继承SmartInstantiationAwareBeanPostProcessor，跟AOP的原理是⼀样的，也是通过@Transactional作为⽅法拦截的标记，把有事务管理的类作为⽬标类，⽣成代理对象，然后增强@Transactional标记的⽅法，在使⽤⽬标⽅法的时候，从IOC容器中获取的其实是被增强的代理类，且事务⽅法会被代理，跟AOP原理⼀样的；4. ProxyTransactionManagementConfiguration分析ProxyTransactionManagementConfiguration是⼀个配置类，想IOC容器中导⼊事务增强器(BeanFactoryTransactionAttributeSourceAdvisor)，事务注解@Transactional的解析器(AnnotationTransactionAttributeSource)和事务⽅法拦截器(TransactionInterceptor)；package org.springframework.transaction.annotation;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Role;import org.springframework.transaction.config.TransactionManagementConfigUtils;import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;import org.springframework.transaction.interceptor.TransactionAttributeSource;import org.springframework.transaction.interceptor.TransactionInterceptor;@Configurationpublic class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {/**事务增强器(Advisor)，在事务类创建的时候，被AutoProxyRegistrar导⼊的组件InfrastructureAdvisorAutoProxyCreator拦截，InfrastructureAdvisorAutoProxyCreator拦截的逻就是增强事务类的事务⽅法，⽽BeanFactoryTransactionAttributeSourceAdvisor作为增强器，与需要增强的⽅法(这⾥是指被@Transactional标记的⽅法)进⾏匹配，匹配成功的增强器，最后转成拦截器(MethodInterceptor,就是下⾯的TransactionInterceptor)，然后与⽬标⽅法⼀起在拦截器链中被执⾏，达到⽅法增强的效果；BeanFactoryTransactionAttributeSourceAdvisor的继承关系如下：BeanFactoryTransactionAttributeSourceAdvisor--AbstractBeanFactoryPointcutAdvisor--AbstractPointcutAdvisor--PointcutAdvisor--AdvisorAOP中AspectJPointcutAdvisor的继承关系如下，与AbstractPointcutAdvisor⼀样，都实现PointcutAdvisor--AspectJPointcutAdvisor--PointcutAdvisor--Advisor*/@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();advisor.setTransactionAttributeSource(transactionAttributeSource());advisor.setAdvice(transactionInterceptor());advisor.setOrder(this.enableTx.<Integer>getNumber("order"));return advisor;}/**@Transactional注解的解析类；负责解析事务⽅法上@Transactional中的各个参数配置，解析的时机是在创建事务类之后被增强的时候，匹配事务⽅法的时候⼀起被解析了AnnotationTransactionAttributeSource的继承关系如下：AnnotationTransactionAttributeSource--AbstractFallbackTransactionAttributeSource--TransactionAttributeSource通过⽅法org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource.getTransactionAttribute(Method, Class<?>)解析出事务信息TransactionAttribute；AnnotationTransactionAttributeSource在⽅法findTransactionAttribute(Class<?>)中依赖于SpringTransactionAnnotationParser在解析事务类时，绑定事务⽅法与增强器的时候进⾏@Transactional注解解析；*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionAttributeSource transactionAttributeSource() {return new AnnotationTransactionAttributeSource();}/**被@Transactional标记的事务⽅法的拦截器，实际是⼀个MethodInterceptor保存了事务属性信息，事务管理器；在⽬标⽅法执⾏的时候；执⾏拦截器链；*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionInterceptor transactionInterceptor() {TransactionInterceptor interceptor = new TransactionInterceptor();interceptor.setTransactionAttributeSource(transactionAttributeSource());if (this.txManager != null) {interceptor.setTransactionManager(this.txManager);}return interceptor;}}在SpringTransactionAnnotationParser中parseTransactionAnnotation⽅法来解析@Transactional中的各个参数，其具体代码如下：protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();Propagation propagation = attributes.getEnum("propagation");rbta.setPropagationBehavior(propagation.value());Isolation isolation = attributes.getEnum("isolation");rbta.setIsolationLevel(isolation.value());rbta.setTimeout(attributes.getNumber("timeout").intValue());rbta.setReadOnly(attributes.getBoolean("readOnly"));rbta.setQualifier(attributes.getString("value"));ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<RollbackRuleAttribute>();Class<?>[] rbf = attributes.getClassArray("rollbackFor");for (Class<?> rbRule : rbf) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] rbfc = attributes.getStringArray("rollbackForClassName");for (String rbRule : rbfc) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");for (Class<?> rbRule : nrbf) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] nrbfc = attributes.getStringArray("noRollbackForClassName");for (String rbRule : nrbfc) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}rbta.getRollbackRules().addAll(rollBackRules);return rbta;}spring 事务 @EnableTransactionManagement原理@EnableXXX原理：注解上有个XXXRegistrar，或通过XXXSelector引⼊XXXRegistrar，XXXRegistrar实现了ImportBeanDefinitionRegistrar的registerBeanDefinitions⽅法，给容器注册XXXCreator。

PlatformTransactionManager 是Spring 框架中的一个接口，用于管理事务，它提供了一种声明式方式来处理事务。

以下是使用PlatformTransactionManager 的基本步骤：1. 首先，需要在Spring 配置文件中定义一个TransactionManager bean。

例如：<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/></bean>2. 然后，在需要处理事务的方法上，使用Transactional 注解。

例如：Transactionalpublic void doSomething() {// 这里是需要处理事务的代码}3. 最后，在启动Spring 容器时，需要将事务管理器bean 注入到需要处理事务的类中。

例如：Autowiredprivate PlatformTransactionManager transactionManager;这样，当调用doSomething() 方法时，Spring 会自动将transactionManager 注入到该方法中，并使用transactionManager 来管理事务。

需要注意的是，PlatformTransactionManager 接口的实现类有多种，例如DataSourceTransactionManager、JdbcTransactionManager 等，具体使用哪种实现类需要根据具体的需求来选择。

同时，还需要注意事务的传播行为、隔离级别等配置。

Spring声明式事务@Transactional详解，事务隔离级别和传播⾏为@Transactional注解⽀持9个属性的设置，这⾥只讲解其中使⽤较多的三个属性：readOnly、propagation、isolation。

其中propagation属性⽤来枚举事务的传播⾏为，isolation⽤来设置事务隔离级别，readOnly进⾏读写事务控制。

@Service@Transactional(readOnly = true)public class AppTradeRec2Service extends BaseService {@Autowiredprivate AppTradeRecDao appTradeRecDao;@Autowiredprivate ConsInfoDao consInfoDao;@Transactional(readOnly = false)public void payCharge(TradeRec tradeRec) {User usr = UserUtils.getUser();ConsInfo cons = consInfoDao.getByUser(usr.getId());//修改交易记录tradeRec.setPayBefore(cons.getAccountAmt());tradeRec.setPayAfter(cons.getAccountAmt() - tradeRec.getRcvAmt());tradeRec.setIsPay("99");appTradeRecDao.save(tradeRec);//修改账户余额cons.setAccountAmt(cons.getAccountAmt() - tradeRec.getRcvAmt());consInfoDao.save(cons);}}⼀、readOnly读写事务控制readOnly=true表明所注解的⽅法或类只是读取数据。

Spring事务之七（事务自动提交）一、MySQL数据库事务自动提交对于mysql数据库，默认情况下，数据库处于自动提交模式。

每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则隐式的提交事务，如果执行失败则隐式的回滚事务。

对于正常的事务管理，是一组相关的操作处于一个事务之中，因此必须关闭数据库的自动提交模式，下面是查看方式：查看是否自动提交命令（ON表示开启自动提交，值为1，OFF表示关闭自动提交，值为0）：关闭自动提交后，则用户将一直处于某个事务中，直到执行一条commit提交或rollback语句才会结束当前事务重新开始一个新的事务。

二、Spring连接如果结合Spring来获取数据库连接，就不用担心，spring会将底层连接的自动提交特性设置为false，先看下Spring事务配置：1.<!-- 配置事务 -->2.<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransac tionManager">3.<property name="dataSource" ref="dataSource" />4.</bean>5.<tx:annotation-driven transaction-manager="transactionManager"/>上面配置中，重要的是类：org.springframework.jdbc.datasource.DataSourceTransactionMa nager，看其对自动提交的处理：1.protected void doBegin(Object transaction, TransactionDefinition definition) {2.3.//......4.5.if(con.getAutoCommit()) {6.txObject.setMustRestoreAutoCommit(true);7.if(this.logger.isDebugEnabled()) {8.this.logger.debug("Switching JDBC Connection [" + con + "] to manual commit");9.}10.con.setAutoCommit(false);11.}12.13.//......14.15.}三、建议：当一个连接关闭时，如果有未提交的事务则回滚任何未提交的事务（C3P0默认的策略，C3P0的autoCommitOnClose属性默认是false）。