Spring Data Access

<tx:annotation-driven transaction-manager="datasourceTransactionManager"/>

<tx:advice id="txAdvice" transaction-manager="datasourceTransactionManager">
    <tx:attributes>
        <tx:method name="save*" propagation="REQUIRED" rollback-for="java.lang.Throwable" timeout="20"/>
        <tx:method name="*" read-only="true" rollback-for="java.lang.Throwable" timeout="20"/>
    </tx:attributes>
</tx:advice>
<aop:config>
    <aop:pointcut id="servicePointcut"
                  expression="execution(public * com.service.*.*(..)) "/>
    <aop:advisor pointcut-ref="servicePointcut" advice-ref="txAdvice" order="1"/>
</aop:config>

public class TransactionInterceptor implements MethodInterceptor, Serializable {
​
protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
   throws Throwable {
​
  // 获取方法的事务属性(propagationBehavior、timeout、readonly等)
  final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
 // 通过事务属性获取对应的PlatformTransactionManager（支持多个事务管理器、多个数据源）
  final PlatformTransactionManager tm = determineTransactionManager(txAttr);
 // 获取方法名(类名+.+方法名), 仅用于打debug/trace级别的日志
  final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
 // 方法无事务属性，或者不是回调型事务管理器(WebSphere, IBM的软件平台，主要用于银行、电信行业)
  if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
   // 如果需要事务，则从数据源getConnection，connection.setAutoCommit(false)
   TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
   Object retVal = null;
   try {
    // 执行实际的方法(sql)
    retVal = invocation.proceedWithInvocation();
   }
   catch (Throwable ex) {
    // 判断是否回滚，需要回滚则调用rollback
    completeTransactionAfterThrowing(txInfo, ex);
    throw ex;
   }
   finally {
 // 恢复上一个ThreadLocal的事务信息
    cleanupTransactionInfo(txInfo);
   }
 // 正常提交事务
   commitTransactionAfterReturning(txInfo);
   return retVal;
  }
 else {
      ...
    }
}

public interface PlatformTransactionManager {
	TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
	void commit(TransactionStatus status) throws TransactionException;
	void rollback(TransactionStatus status) throws TransactionException;
}

public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
 // 从TheadLocal获取DataSourceTransactionObject(主要封装的是Connection对象)
  Object transaction = doGetTransaction();
​
  if (definition == null) {
   definition = new DefaultTransactionDefinition();
  }
 //transaction对象里有Connection，表示存在事务
  if (isExistingTransaction(transaction)) {
   return handleExistingTransaction(definition, transaction, debugEnabled);
  }
 
  if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
   throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
  }
​
  // 傲娇的PROPAGATION_MANDATORY，没有事务就抛异常
  if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
   throw new IllegalTransactionStateException(
     "No existing transaction found for transaction marked with propagation 'mandatory'");
  }
 // 需要开启事务
  else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
    definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
    definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
   SuspendedResourcesHolder suspendedResources = suspend(null);
   try {
    boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
    DefaultTransactionStatus status = newTransactionStatus(
      definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
 //实际开始事务    
    doBegin(transaction, definition);
 //设置readOnly、isolation等ThreadLocal信息
    prepareSynchronization(status, definition);
    return status;
   }
   catch (RuntimeException ex) {
    resume(null, suspendedResources);
    throw ex;
   }
   catch (Error err) {
    resume(null, suspendedResources);
    throw err;
   }
  }
  else {
   // 不需要事务，包装一个null对象返回
   boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
   return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
  }
}

public @interface Transactional {
	Propagation propagation() default Propagation.REQUIRED;
	Isolation isolation() default Isolation.DEFAULT;
	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
	boolean readOnly() default false;
	Class<? extends Throwable>[] rollbackFor() default {};
}

TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
 @Override
 public void afterCommit() {
       someFunction(event);
    }
});

@Async
@TransactionalEventListener(fallbackExecution = true, phase = TransactionPhase.AFTER_COMPLETION)
public void handleCustomerEsUpdate(Event event) {
    ...
}

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
​
 Object object = new Object();
 object.setKey(Integer.MAX_VALUE);
 objectMapper.insert(object);
​
 otherService.methodB();
​
 try {
 Thread.sleep(5000);
    } catch (InterruptedException e) {
 e.printStackTrace();
    }
​
}
​
@Async
@Transactional(propagation = Propagation.REQUIRED)
public void methodB() {
 Object object = objectMapper.getByKey(Integer.MAX_VALUE);
 System.out.println(object);
}

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
 <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
 <property name="basePackage" value="com.**.mapper"/>
</bean>

public class SpringManagedTransaction implements Transaction {
​
 @Override
 public Connection getConnection() throws SQLException {
   if (this.connection == null) {
      openConnection();//获取新的connection对象
   }
   return this.connection;//在同一个事务里，始终是一个connection对象
 }
​
 private void openConnection() throws SQLException {
    this.connection = DataSourceUtils.getConnection(this.dataSource);
    ..
 }

<tx:advice id="myBatisTxAdvice" transaction-manager="myBatisTransactionManager">
 <tx:attributes>
 <tx:method name="save*" propagation="REQUIRED" timeout="25"/>

public void timeOut() {
    try {
      Thread.sleep(26000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    Object object = objectMapper.getByKey(Integer.MAX_VALUE);
}
public void notTimeOut() {
    Object object = objectMapper.getByKey(Integer.MAX_VALUE);
    try {
      Thread.sleep(26000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
}