//***************************************** 代码2： DataSourceTransactionManager.java *****************************************
@Override
protected Object doGetTransaction() {
   DataSourceTransactionObject txObject = new DataSourceTransactionObject();
   txObject.setSavepointAllowed(isNestedTransactionAllowed());
   ConnectionHolder conHolder =
      (ConnectionHolder) TransactionSynchronizationManager.getResource(this.dataSource);  //通过事务同步管理器获取连接，从当前线程的ThreadLocal中获取
   txObject.setConnectionHolder(conHolder, false);
   return txObject;
}

//***************************************** 代码3： DataSourceTransactionManager.java *****************************************
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
   DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
   Connection con = null;
 
   try {
      if (txObject.getConnectionHolder() == null ||                                  //如果事务对象里没有连接，则从数据源（连接池）中获取新的连接
            txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
         Connection newCon = this.dataSource.getConnection();
         if (logger.isDebugEnabled()) {
            logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
         }
         txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
      }
 
      txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
      con = txObject.getConnectionHolder().getConnection();
 
      Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
      txObject.setPreviousIsolationLevel(previousIsolationLevel);
 
      // Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
      // so we don‘t want to do it unnecessarily (for example if we‘ve explicitly
      // configured the connection pool to set it already).
      if (con.getAutoCommit()) {
         txObject.setMustRestoreAutoCommit(true);
         if (logger.isDebugEnabled()) {
            logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
         }
         con.setAutoCommit(false);
      }
      txObject.getConnectionHolder().setTransactionActive(true);
 
      int timeout = determineTimeout(definition);
      if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
         txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
      }
 
      // Bind the session holder to the thread.
      if (txObject.isNewConnectionHolder()) {
         TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder()); //将连接绑定到ThreadLocal中
      }
   }
 
   catch (Throwable ex) {
      DataSourceUtils.releaseConnection(con, this.dataSource);
      throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
   }
}

//***************************************** 代码4： JdbcTemplate.java *****************************************
public <T> T execute(StatementCallback<T> action) throws DataAccessException {
   Assert.notNull(action, "Callback object must not be null");
 
   Connection con = DataSourceUtils.getConnection(getDataSource());
   ......
}
  
//***************************************** DataSourceUtils.java *********************************************
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
   Assert.notNull(dataSource, "No DataSource specified");
 
   ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource); //先从ThreadLocal中获取连接
   if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
      conHolder.requested();
      if (!conHolder.hasConnection()) {
         logger.debug("Fetching resumed JDBC Connection from DataSource");
         conHolder.setConnection(dataSource.getConnection());
      }
      return conHolder.getConnection();
   }
   // Else we either got no holder or an empty thread-bound holder here.
 
   logger.debug("Fetching JDBC Connection from DataSource");
   Connection con = dataSource.getConnection();                                                       //如果ThreadLocal中没有连接，则从数据源（连接池）中获取新的连接
   ......
}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class TransactionThreadTest {
 
    private static final ExecutorService executor = Executors.newFixedThreadPool(1);
 
    @Autowired
    private PlatformTransactionManager transactionManager;
 
    @Autowired
    private IUserDAO userDAO;
 
    @Test
    public void testTransactionThread() {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        //def.setReadOnly(true);
        Boolean flag = def.isReadOnly();
        TransactionStatus status = transactionManager.getTransaction(def);
 
        try {
 
            // 更新库存
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        syncDisneyPluStock();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            executor.execute(runnable);
 
            Thread.sleep(1000);
 
            UserDO userDO = new UserDO();
            userDO.setName("lanlan");
            userDAO.insert(userDO);
 
        } catch (Exception e) {
            transactionManager.rollback(status);
        }
        transactionManager.commit(status);
    }
 
    public void syncDisneyPluStock() throws Exception {
        UserDO userDO = new UserDO();
        userDO.setName("dd");
        userDAO.insert(userDO);
        //throw new Exception();
    }
}

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="meilvDataSource"/>
</bean>
 
<!-- 使用tx/aop来配置 -->
<aop:config>
    <!-- 通过aop定义事务增强切面 -->
    <aop:pointcut id="serviceMethod" expression="execution(* com.test.aop.*.*(..))" />
    <!-- 引用事务增强 -->
    <aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
</aop:config>
 
<!--事务增强 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!-- 事务属性定义 -->
    <tx:attributes>
        <tx:method name="action" read-only="false" />
        <tx:method name="work" rollback-for="RuntimeException" />
    </tx:attributes>
</tx:advice>