由cglib或jdk动态代理生成代理类
//代理对象: //org.springframework.jdbc.datasource.DataSourceTransactionManager //开启事务 target.invoke1(){ insertMethod1() insertMethod2() updateMethod1() } //事务提交
事务操作必须使用同一个connection对象,如何保证
spring每次操作db的时候都需要获取一个connection连接,每次连接都放在ThreadLocal中。
DataSourceTransactionManager类doGetTransaction protected Object doGetTransaction() { DataSourceTransactionManager.DataSourceTransactionObject txObject = new DataSourceTransactionManager.DataSourceTransactionObject(); txObject.setSavepointAllowed(this.isNestedTransactionAllowed()); //这里是到TransactionSynchronizationManager里获取threadLocal线程绑定的连接 ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(this.obtainDataSource()); txObject.setConnectionHolder(conHolder, false); return txObject; }
1.引入数据源、数据库驱动、Spring-jdbc模块 2.事务操作加上@Transactional 3.打开事务功能 @EnableTransactionManagement 4.EnableTransactionManagement引入了一个ImportSelector 5.selector往spring容器中注册了两个组件:AutoProxyRegistrar和ProxyTransactionManagementConfiguration 5.1.AutoProxyRegistrar主要利用ImporyBeanDefinitionRegistrar注册了一个InfrastructureAdvisorAutoProxyCreator组件 InfrastructureAdvisorAutoProxyCreator实现了spring后置处理器接口,让需要进行事务处理的方法具备事务的能力(即向spring容器中添加了5.2里的BeanFactoryTransactionAttributeSourceAdvisor,进行了增强) 5.2 ProxyTransactionManagementConfiguration向容器中注册了两个bean:AnnotationTransactionAttributeSource和TransactionInterceptor放到BeanFactoryTransactionAttributeSourceAdvisor中 5.2.1 AnnotationTransactionAttributeSource 的作用是解析业务代码中@Transactional注解的元信息,传播属性,超时时间,隔离级别 5.2.2 TransactionInterceptor保存了事务属性信息以及事务管理器;它是一个MethodInterceptor; 6.当业务代码执行时,由注册的拦截器TransactionInterceptor进行执行invoke方法 7.TransactionAspectSupport类下的invokeWithinTransaction方法是具体的实现
//第一步:导入相关数据库依赖; //第二步:加事务注解; @Transactional(rollbackFor = {Exception.class}) public void updateAccount(int id) { int rows = accounMapper.deduction(id); if (rows > 0) { System.out.println("秒杀库存修改成功"); insertGoodOrder(); } else { System.out.println("秒杀修改失败"); } }
@Configuration @ComponentScan("top.yonyong.db") //第三步:开启事务管理功能,让@Transactional生效 @EnableTransactionManagement public class DataSourceConfig { //创建数据源 这个c3p0封装了JDBC, dataSource 接口的实现 @Bean public DataSource dataSource() throws PropertyVetoException { ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setUser("root"); dataSource.setPassword("root"); dataSource.setDriverClass("com.mysql.jdbc.Driver"); dataSource.setJdbcUrl("jdbc:mysql//localhost:3306/order"); return dataSource; } @Bean //第四步:注册事务管理器bean public PlatformTransactionManager platformTransactionManager() throws PropertyVetoException { return new DataSourceTransactionManager(dataSource()); } @Bean //第五步:jdbcTemplate能简化增查改删的操作 public JdbcTemplate jdbcTemplate() throws PropertyVetoException { return new JdbcTemplate(dataSource()); } }
package org.springframework.transaction.annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import org.springframework.context.annotation.AdviceMode; import org.springframework.context.annotation.Import; @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented //利用Import给容器添加一个Selector组件; @Import({TransactionManagementConfigurationSelector.class}) public @interface EnableTransactionManagement { //使用JDK或者是Cglib动态代理 //true:Ciglib动态代理 false JDK动态代理,默认false boolean proxyTargetClass() default false; //默认事务增强器是什么模式:代理 AdviceMode mode() default AdviceMode.PROXY; //最低的优先级 int order() default 2147483647; }
spring源码里常出现这两个注解:
ImportSelector是一个接口,只需要实现selectImport()方法,返回的是一个数组,即可给容器批量的注册Bean实例;
ImportBeanDefinitionRegistor也是一个接口,只需要实现registorBeanDefinition()方法就能实现给容器添加bean实例;
public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> { /** * TransactionManagementConfigurationSelector 实现了AdviceModeImportSelector * 而AdviceModeImportSelector实现了ImportSelector ,所以也就拥有了向spring容器注册bean的能力 */ @Override protected String[] selectImports(AdviceMode adviceMode) { switch (adviceMode) { case PROXY: //默认代理模式 //注册AutoProxyRegistrar和ProxyTransactionManagementConfiguration两个类 return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()}; case ASPECTJ: return new String[] {determineTransactionAspectClass()}; default: return null; } } private String determineTransactionAspectClass() { return (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader()) ? TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME : TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME); } }
通过ImportBeanDefinitionRegistrar给容器中添加组件:InfrastructureAdvisorAutoProxyCreator
public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar { private final Log logger = LogFactory.getLog(getClass()); @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { boolean candidateFound = false; Set<String> annoTypes = importingClassMetadata.getAnnotationTypes(); for (String annoType : annoTypes) { if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() && Boolean.class == proxyTargetClass.getClass()) { candidateFound = true; if (mode == AdviceMode.PROXY) {//看它给容器中注册了什么组件 AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry); if ((Boolean) proxyTargetClass) { AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry); return; } } } @Nullable //给容器中添加InfrastructureAdvisorAutoProxyCreator组件 public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,Object source) { //这里开始给容器注册:InfrastructureAdvisorAutoProxyCreator 事务动态代理创建器组件 return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source); }
一直点进去发现,InfrastructureAdvisorAutoProxyCreator其实实现了spring后置处理器,用来创建增强的bean
public class InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator { public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator { public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {} public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor { public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor { @Nullable //Bean实例前置增强 default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Nullable //Bean实例后置增强 default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; } }
@Configuration(proxyBeanMethods = false) public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration { //开始事务的元数据属性解析 @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME) @Role(BeanDefinition.ROLE_INFRASTRUCTURE) //对属性元信息的一些增强,比如在注解中设置的一些参数:传播属性propagation,回滚的条件rollbackFor等等 //@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor( TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) { //对我们的事务进行属性增强; BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor(); advisor.setTransactionAttributeSource(transactionAttributeSource); advisor.setAdvice(transactionInterceptor); if (this.enableTx != null) { advisor.setOrder(this.enableTx.<Integer>getNumber("order")); } return advisor; } //封装事务的属性值,注册为bean,作为形参供上面的方法使用 @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public TransactionAttributeSource transactionAttributeSource() { //新建了这个对象 return new AnnotationTransactionAttributeSource(); } //主要用于保存事务配置属性的信息,封装成一个TransactionInterceptor @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public TransactionInterceptor transactionInterceptor( TransactionAttributeSource transactionAttributeSource) { TransactionInterceptor interceptor = new TransactionInterceptor(); interceptor.setTransactionAttributeSource(transactionAttributeSource); if (this.txManager != null) { interceptor.setTransactionManager(this.txManager); } return interceptor; } }
public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource implements Serializable { public AnnotationTransactionAttributeSource() { this(true); } //花里胡哨不知道干啥的,但最终都会加上一个SpringTransactionAnnotationParser public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) { this.publicMethodsOnly = publicMethodsOnly; if (jta12Present || ejb3Present) { this.annotationParsers = new LinkedHashSet<>(4); this.annotationParsers.add(new SpringTransactionAnnotationParser()); if (jta12Present) { this.annotationParsers.add(new JtaTransactionAnnotationParser()); } if (ejb3Present) { this.annotationParsers.add(new Ejb3TransactionAnnotationParser()); } } else { this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser()); } } } public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable { @Override public boolean isCandidateClass(Class<?> targetClass) { return AnnotationUtils.isCandidateClass(targetClass, Transactional.class); } @Override @Nullable public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) { AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes( element, Transactional.class, false, false); if (attributes != null) { return parseTransactionAnnotation(attributes); } else { return null; } } public TransactionAttribute parseTransactionAnnotation(Transactional ann) { return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false)); } 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")); //事务的回滚条件设置 List<RollbackRuleAttribute> rollbackRules = new ArrayList<>(); for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) { rollbackRules.add(new RollbackRuleAttribute(rbRule)); } //设置需要进行回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,则进行事务回滚 for (String rbRule : attributes.getStringArray("rollbackForClassName")) { rollbackRules.add(new RollbackRuleAttribute(rbRule)); } for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) { rollbackRules.add(new NoRollbackRuleAttribute(rbRule)); } //设置不回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,事务不回滚 for (String rbRule : attributes.getStringArray("noRollbackForClassName")) { rollbackRules.add(new NoRollbackRuleAttribute(rbRule)); } rbta.setRollbackRules(rollbackRules); return rbta; } @Override public boolean equals(@Nullable Object other) { return (this == other || other instanceof SpringTransactionAnnotationParser); } @Override public int hashCode() { return SpringTransactionAnnotationParser.class.hashCode(); } }
到这里:第一就阶段的初始化任务就完成了,核心任务:
利用TransactionManagementConfigurationSelector给容器中导入两个组件:
(1)InfrastructureAdvisorAutoProxyCreator
AutoProxyRegistrar给容器中注册一个 InfrastructureAdvisorAutoProxyCreator组件,它其实就是一个后置处理器,一个动态代理创建器,利用后置处理器和动态代理对目标方法进行增强,>返回一个增强的实例对象,代理对象执行方法利用拦截器链进行调用;
(2)ProxyTransactionManagementConfiguration
对事务管理器的获取,对事务的元信息进行处理,对目标方法本身的执行,主要是事务能力细节的代理实现,然后给容器中注册配置生成的事务增强器Bean;
目标方法的调用,开始调用TransactionInterceptor.invoke() 方法,这个是事务执行的核心
//这里拦截后封装成 MethodInterceptor,保存了事务的信息,和aop的逻辑一样 public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable { public TransactionInterceptor() { } public TransactionInterceptor(PlatformTransactionManager ptm, Properties attributes) { setTransactionManager(ptm); setTransactionAttributes(attributes); } public TransactionInterceptor(PlatformTransactionManager ptm, TransactionAttributeSource tas) { setTransactionManager(ptm); setTransactionAttributeSource(tas); } //动态代理的调用 @Override @Nullable public Object invoke(MethodInvocation invocation) throws Throwable { Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); // Adapt to TransactionAspectSupport's invokeWithinTransaction... //这里调用的是TransactionAspectSupport类的方法 return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed); } //--------------------------------------------------------------------- // Serialization support //--------------------------------------------------------------------- private void writeObject(ObjectOutputStream oos) throws IOException { // Rely on default serialization, although this class itself doesn't carry state anyway... oos.defaultWriteObject(); // Deserialize superclass fields. oos.writeObject(getTransactionManagerBeanName()); oos.writeObject(getTransactionManager()); oos.writeObject(getTransactionAttributeSource()); oos.writeObject(getBeanFactory()); } private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { ois.defaultReadObject(); setTransactionManagerBeanName((String) ois.readObject()); setTransactionManager((PlatformTransactionManager) ois.readObject()); setTransactionAttributeSource((TransactionAttributeSource) ois.readObject()); setBeanFactory((BeanFactory) ois.readObject()); } }
//TransactionAspectSupport类 invokeWithinTransaction方法 @Nullable protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable { // If the transaction attribute is null, the method is non-transactional. //(1):获取(实践第二步中)设置的事务属性信息(propagation = Propagation.REQUIRED, rollbackFor = Exception.class),直接从内存中加载; TransactionAttributeSource tas = getTransactionAttributeSource(); final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null); //(2):获取注册的事务管理器-PlatformTransactionManager,加载到容器中; final TransactionManager tm = determineTransactionManager(txAttr); if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) { ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> { if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) { throw new TransactionUsageException( "Unsupported annotated transaction on suspending function detected: " + method + ". Use TransactionalOperator.transactional extensions instead."); } ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType()); if (adapter == null) { throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " + method.getReturnType()); } return new ReactiveTransactionSupport(adapter); }); return txSupport.invokeWithinTransaction( method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm); } PlatformTransactionManager ptm = asPlatformTransactionManager(tm); final String joinpointIdentification = methodIdentification(method, targetClass, txAttr); if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) { // Standard transaction demarcation with getTransaction and commit/rollback calls. //得到事务管理器,关闭事务自动提交; TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification); Object retVal; try { // This is an around advice: Invoke the next interceptor in the chain. // This will normally result in a target object being invoked. //(4): 开始执行目标方法本身doBusiness(); retVal = invocation.proceedWithInvocation(); } catch (Throwable ex) { // target invocation exception //(4.1): 如果执行过程中抛出异常则回滚 completeTransactionAfterThrowing(txInfo, ex); throw ex; } finally { cleanupTransactionInfo(txInfo); } if (vavrPresent && VavrDelegate.isVavrTry(retVal)) { // Set rollback-only in case of Vavr failure matching our rollback rules... TransactionStatus status = txInfo.getTransactionStatus(); if (status != null && txAttr != null) { retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status); } } //(4.2) 如果执行成功,则提交事务; commitTransactionAfterReturning(txInfo); return retVal; } else { final ThrowableHolder throwableHolder = new ThrowableHolder(); // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in. try { Object result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> { TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status); try { Object retVal = invocation.proceedWithInvocation(); if (vavrPresent && VavrDelegate.isVavrTry(retVal)) { // Set rollback-only in case of Vavr failure matching our rollback rules... retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status); } return retVal; } catch (Throwable ex) { if (txAttr.rollbackOn(ex)) { // A RuntimeException: will lead to a rollback. if (ex instanceof RuntimeException) { throw (RuntimeException) ex; } else { throw new ThrowableHolderException(ex); } } else { // A normal return value: will lead to a commit. throwableHolder.throwable = ex; return null; } } finally { cleanupTransactionInfo(txInfo); } }); // Check result state: It might indicate a Throwable to rethrow. if (throwableHolder.throwable != null) { throw throwableHolder.throwable; } return result; } catch (ThrowableHolderException ex) { throw ex.getCause(); } catch (TransactionSystemException ex2) { if (throwableHolder.throwable != null) { logger.error("Application exception overridden by commit exception", throwableHolder.throwable); ex2.initApplicationException(throwableHolder.throwable); } throw ex2; } catch (Throwable ex2) { if (throwableHolder.throwable != null) { logger.error("Application exception overridden by commit exception", throwableHolder.throwable); } throw ex2; } } }
public class DataSourceTransactionManager extends AbstractPlatformTransactionManager implements ResourceTransactionManager, InitializingBean { //注入数据源 private DataSource dataSource; //数据源事务处理器默认构造方法,创建一个数据源事务处理器实例,并设置允许嵌套事务 public DataSourceTransactionManager() { setNestedTransactionAllowed(true); } //根据给定数据源,创建一个数据源事务处理器实例 public DataSourceTransactionManager(DataSource dataSource) { this(); setDataSource(dataSource); afterPropertiesSet(); } //设置数据源 public void setDataSource(DataSource dataSource) { if (dataSource instanceof TransactionAwareDataSourceProxy) { //如果数据源是一个事务包装数据源代理,则获取事务包装代理的目标数据源 this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource(); } else { this.dataSource = dataSource; } } //获取数据源 public DataSource getDataSource() { return this.dataSource; } //数据源事务处理器对象构造方法的回调函数 public void afterPropertiesSet() { if (getDataSource() == null) { throw new IllegalArgumentException("Property 'dataSource' is required"); } } public Object getResourceFactory() { return getDataSource(); } //创建事务,对数据库而言,是由Connection来完成事务工作的。该方法把数据库的//Connection对象放到一个ConnectionHolder对象中,然后封装到一个 //DataSourceTransactionObject对象中 protected Object doGetTransaction() { //创建数据源事务对象 DataSourceTransactionObject txObject = new DataSourceTransactionObject(); //设置数据源事务对象对嵌套事务使用保存点 txObject.setSavepointAllowed(isNestedTransactionAllowed()); //从事务管理容器中获取存放数据库Connection的对象 ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(this.dataSource); txObject.setConnectionHolder(conHolder, false); return txObject; } //判断是否已经存在事务 protected boolean isExistingTransaction(Object transaction) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; //根据存放数据库连接的ConnectionHolder的isTransactionActive属性来判断 return (txObject.getConnectionHolder() != null && txObject.getConnectionHolder().isTransactionActive()); } //处理事务开始的方法 protected void doBegin(Object transaction, TransactionDefinition definition) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; Connection con = null; try { //如果数据源事务对象的ConnectionHolder为null或者是事务同步的 if (txObject.getConnectionHolder() == null || txObject.getConnectionHolder().isSynchronizedWithTransaction()) { //获取当前数据源的数据库连接 Connection newCon = this.dataSource.getConnection(); if (logger.isDebugEnabled()) { logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction"); } //为数据源事务对象设置ConnectionHolder txObject.setConnectionHolder(new ConnectionHolder(newCon), true); } //设置数据源事务对象的事务同步 txObject.getConnectionHolder().setSynchronizedWithTransaction(true); //获取数据源事务对象的数据库连接 con = txObject.getConnectionHolder().getConnection(); //根据数据连接和事务属性,获取数据库连接的事务隔离级别 Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition); //为数据源事务对象设置事务隔离级别 txObject.setPreviousIsolationLevel(previousIsolationLevel); //如果数据库连接设置了自动事务提交属性,则关闭自动提交 if (con.getAutoCommit()) { //保存数据库连接设置的自动连接到数据源事务对象中 txObject.setMustRestoreAutoCommit(true); if (logger.isDebugEnabled()) { logger.debug("Switching JDBC Connection [" + con + "] to manual commit"); } //设置数据库连接自动事务提交属性为false,即禁止自动事务提交 con.setAutoCommit(false); } //激活当前数据源事务对象的事务配置 txObject.getConnectionHolder().setTransactionActive(true); //获取事务配置的超时时长 int timeout = determineTimeout(definition); //如果事务配置的超时时长不等于事务的默认超时时长 if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) { //数据源事务对象设置超时时长 txObject.getConnectionHolder().setTimeoutInSeconds(timeout); } //把当前数据库Connection和线程绑定 if (txObject.isNewConnectionHolder()) { TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder()); } } catch (Exception ex) { DataSourceUtils.releaseConnection(con, this.dataSource); throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex); } } //事务挂起 protected Object doSuspend(Object transaction) { //获取事务对象 DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; //将事务对象中的ConnectionHolders设置为null txObject.setConnectionHolder(null); ConnectionHolder conHolder = (ConnectionHolder) //解除事务对象和当前线程的绑定 TransactionSynchronizationManager.unbindResource(this.dataSource); return conHolder; } //事务恢复 protected void doResume(Object transaction, Object suspendedResources) { //获取已暂停事务的ConnectionHolder ConnectionHolder conHolder = (ConnectionHolder) suspendedResources; //重新将事务对象和当前线程绑定 TransactionSynchronizationManager.bindResource(this.dataSource, conHolder); } //事务提交 protected void doCommit(DefaultTransactionStatus status) { //获取事务对象 DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction(); //通过事务对象获取数据库连接 Connection con = txObject.getConnectionHolder().getConnection(); if (status.isDebug()) { logger.debug("Committing JDBC transaction on Connection [" + con + "]"); } try { //使用数据库连接手动进行事务提交 con.commit(); } catch (SQLException ex) { throw new TransactionSystemException("Could not commit JDBC transaction", ex); } } //事务回滚 protected void doRollback(DefaultTransactionStatus status) { //获取事务对象 DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction(); //通过事务对象获取数据库连接 Connection con = txObject.getConnectionHolder().getConnection(); if (status.isDebug()) { logger.debug("Rolling back JDBC transaction on Connection [" + con + "]"); } try { //通过调用数据库连接的回滚方法完成事务回滚操作 con.rollback(); } catch (SQLException ex) { throw new TransactionSystemException("Could not roll back JDBC transaction", ex); } } //设置回滚 protected void doSetRollbackOnly(DefaultTransactionStatus status) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction(); if (status.isDebug()) { logger.debug("Setting JDBC transaction [" + txObject.getConnectionHolder().getConnection() + "] rollback-only"); } txObject.setRollbackOnly(); } //操作完成之后清除操作 protected void doCleanupAfterCompletion(Object transaction) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; //移除当前线程绑定的ConnectionHolder if (txObject.isNewConnectionHolder()) { TransactionSynchronizationManager.unbindResource(this.dataSource); } Connection con = txObject.getConnectionHolder().getConnection(); try { //如果事务对象保存了自动事务提交属性,则设置数据库连接的自动事务提交属性 if (txObject.isMustRestoreAutoCommit()) { con.setAutoCommit(true); } //事务结束后重置数据库连接 DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel()); } catch (Throwable ex) { logger.debug("Could not reset JDBC Connection after transaction", ex); } //如果事务对象中有新的ConnectionHolder if (txObject.isNewConnectionHolder()) { if (logger.isDebugEnabled()) { logger.debug("Releasing JDBC Connection [" + con + "] after transaction"); } //释放数据库连接 DataSourceUtils.releaseConnection(con, this.dataSource); } //清除事务对象的ConnectionHolder txObject.getConnectionHolder().clear(); } //数据源事务对象,内部类 private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport { //是否有新的ConnectionHolder private boolean newConnectionHolder; //是否保存自动提交 private boolean mustRestoreAutoCommit; //设置ConnectionHolder public void setConnectionHolder(ConnectionHolder connectionHolder, boolean newConnectionHolder) { //为父类JdbcTransactionObjectSupport设置ConnectionHolder super.setConnectionHolder(connectionHolder); this.newConnectionHolder = newConnectionHolder; } public boolean isNewConnectionHolder() { return this.newConnectionHolder; } //调用父类JdbcTransactionObjectSupport的相关方法,查询收费存在事务 public boolean hasTransaction() { return (getConnectionHolder() != null && getConnectionHolder().isTransactionActive()); } //设置是否保存自动提交 public void setMustRestoreAutoCommit(boolean mustRestoreAutoCommit) { this.mustRestoreAutoCommit = mustRestoreAutoCommit; } public boolean isMustRestoreAutoCommit() { return this.mustRestoreAutoCommit; } //设置数据库连接在操作失败是,是否只回滚处理 public void setRollbackOnly() { getConnectionHolder().setRollbackOnly(); } public boolean isRollbackOnly() { return getConnectionHolder().isRollbackOnly(); } } }