一、传统JDBC事务管理

　　首先我们先看一下，jdbc的事务配置是在Connection对消里面有对应的方法，比如setAutoCommit,commit,rollback这些方法就是对事务的操作。

conn.setAutoCommit(false);//设置事务非自动提交
conn.commit();//提交事务
conn.rollback();//事务回滚

　　这样必然存在一些问题，如：把业务逻辑代码和事务处理代码混合起来，同时存在代码重复性。如下是一段典型的控制事务代码：

　private DataSource dataSource = null;

  public void setDataSource(DataSource dataSource){
    this.dataSource = dataSource;
  }
  public void update() {
    Connection conn = null;
    PreparedStatement pstmt = null;
    try {
      conn = dataSource.getConnection();
      conn.setAutoCommit(false);//设置事务非自动提交
      String sql = "update testTable set name='测试数据' where id = '1'";
      pstmt = conn.prepareStatement(sql);
      pstmt.execute();
      conn.commit();//提交事务
    } catch (Exception e) {
      try {
        conn.rollback();//事务回滚
      } catch (Exception e1) {
        e1.printStackTrace();
      }
      e.printStackTrace();
    } finally {
      try {
        if(pstmt!=null)
          pstmt.close();
        if (conn != null)
          conn.close();
      } catch (SQLException e) {
        e.printStackTrace();
      }
    }
  }

二、Spring中的事务原理

　　Spring容器的事务机制的实质是对传统JDBC的封装，也即是Spring事务管理无论是对单数据库实例还是分布式数据库实例，要实现事务管理，那么必须保证在一个事务过程获得Connetion对象是同一个，那么即使在同一个函数中调用其他多个的函数，通过Spring框架的AOP动态代理机制，使得Spring容器底层能够按传统JDBC的方式进行事务处理，从而保证对这个函数做事务控制。
　　Spring框架具有支持多数据源的特性，在获得数据库Connection对象往往是通过DataSource中获得，DataSource这个接口往往由不同的厂商驱动实现，因此Spring框架往往是对DataSource进一步的封装保证每次获得的Connection为相同的，这就保证了一个业务方法里面进行多次dao操作，调用的都是一个connection对象，同时保证了多个dao都是在一个事务里面。

package javax.sql;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Wrapper;
/** 
 * <p>A factory for connections to the physical data source that this
 * <code>DataSource</code> object represents.  An alternative to the
 * <code>DriverManager</code> facility, a <code>DataSource</code> object
 * is the preferred means of getting a connection. An object that implements
 * the <code>DataSource</code> interface will typically be
 * registered with a naming service based on the 
 * Java<sup><font size=-2>TM</font></sup> Naming and Directory (JNDI) API.
 * <P>
 * The <code>DataSource</code> interface is implemented by a driver vendor.
 * There are three types of implementations:
 * <OL>
 *   <LI>Basic implementation -- produces a standard <code>Connection</code> 
 *       object
 *   <LI>Connection pooling implementation -- produces a <code>Connection</code>
 *       object that will automatically participate in connection pooling.  This
 *       implementation works with a middle-tier connection pooling manager.
 *   <LI>Distributed transaction implementation -- produces a
 *       <code>Connection</code> object that may be used for distributed
 *       transactions and almost always participates in connection pooling. 
 *       This implementation works with a middle-tier 
 *       transaction manager and almost always with a connection 
 *       pooling manager.
 * </OL>
 * <P>
 * A <code>DataSource</code> object has properties that can be modified
 * when necessary.  For example, if the data source is moved to a different
 * server, the property for the server can be changed.  The benefit is that
 * because the data source's properties can be changed, any code accessing
 * that data source does not need to be changed.
 * <P>
 * A driver that is accessed via a <code>DataSource</code> object does not 
 * register itself with the <code>DriverManager</code>.  Rather, a
 * <code>DataSource</code> object is retrieved though a lookup operation
 * and then used to create a <code>Connection</code> object.  With a basic
 * implementation, the connection obtained through a <code>DataSource</code>
 * object is identical to a connection obtained through the
 * <code>DriverManager</code> facility.
 *
 * @since 1.4
 */
public interface DataSource  extends CommonDataSource,Wrapper {
  /**
   * <p>Attempts to establish a connection with the data source that
   * this <code>DataSource</code> object represents.
   *
   * @return  a connection to the data source
   * @exception SQLException if a database access error occurs
   */
  Connection getConnection() throws SQLException;

  /**
   * <p>Attempts to establish a connection with the data source that
   * this <code>DataSource</code> object represents.
   *
   * @param username the database user on whose behalf the connection is 
   *  being made
   * @param password the user's password
   * @return  a connection to the data source
   * @exception SQLException if a database access error occurs
   * @since 1.4
   */
  Connection getConnection(String username, String password) 
    throws SQLException;
}

三、Spring中事务处理过程

　　首先我们先看JdbcTemplate类数据访问类

public Object execute(ConnectionCallback action)
    throws DataAccessException
  {
    Assert.notNull(action, "Callback object must not be null");
    Connection con = DataSourceUtils.getConnection(getDataSource());
    try {
      Connection conToUse = con;
      if (this.nativeJdbcExtractor != null)
      {
        conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
      }
      else
      {
        conToUse = createConnectionProxy(con);
      }
      localObject1 = action.doInConnection(conToUse);
    }
    catch (SQLException ex)
    {
      Object localObject1;
      DataSourceUtils.releaseConnection(con, getDataSource());
      con = null;
      throw getExceptionTranslator().translate("ConnectionCallback", getSql(action), ex);
    }
    finally {
      DataSourceUtils.releaseConnection(con, getDataSource());
    }
  }

　　由上述源码中Connection con = DataSourceUtils.getConnection(getDataSource());这个可以看出，DataSourceUtils类保证当前线程获得的是同一个Connection对象。下面我们主要分析DataSourceUtils类：

public static Connection getConnection(DataSource dataSource)
    throws CannotGetJdbcConnectionException
  {
    try
    {
      return doGetConnection(dataSource);
    } catch (SQLException ex) {
    }
    throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
  }
  public static Connection doGetConnection(DataSource dataSource)
    throws SQLException
  {
    Assert.notNull(dataSource, "No DataSource specified");
    ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);
    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();
    }
    logger.debug("Fetching JDBC Connection from DataSource");
    Connection con = dataSource.getConnection();
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
      logger.debug("Registering transaction synchronization for JDBC Connection");
      ConnectionHolder holderToUse = conHolder;
      if (holderToUse == null) {
        holderToUse = new ConnectionHolder(con);
      }
      else {
        holderToUse.setConnection(con);
      }
      holderToUse.requested();
      TransactionSynchronizationManager.registerSynchronization(new ConnectionSynchronization(holderToUse, dataSource));
      holderToUse.setSynchronizedWithTransaction(true);
      if (holderToUse != conHolder) {
        TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
      }
    }
    return con;
  }

　　由以上源码可以知道，数据库连接从TransactionSynchronizationManager中获得，如果已经存在则获得，否则重新从DataSource创建一个连接，并把这个连接封装为ConnectionHolder，然后注册绑定到TransactionSynchronizationManager中，并返回Connection对象。同时，可以看出DataSource和ConnectionHolder的存储管理在TransactionSynchronizationManager中，继续分析TransactionSynchronizationManager中的关键代码：

private static final ThreadLocal resources = new NamedThreadLocal("Transactional resources");
  public static Object getResource(Object key)
  {
    Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
    Object value = doGetResource(actualKey);
    if ((value != null) && (logger.isTraceEnabled())) {
      logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
    }
    return value;
  }
  private static Object doGetResource(Object actualKey)
  {
    Map map = (Map)resources.get();
    if (map == null) {
      return null;
    }
    Object value = map.get(actualKey);
    if (((value instanceof ResourceHolder)) && (((ResourceHolder)value).isVoid())) {
      map.remove(actualKey);
      value = null;
    }
    return value;
  }
  public static void bindResource(Object key, Object value)
    throws IllegalStateException
  {
    Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
    Assert.notNull(value, "Value must not be null");
    Map map = (Map)resources.get();
    if (map == null) {
      map = new HashMap();
      resources.set(map);
    }
    if (map.put(actualKey, value) != null) {
      throw new IllegalStateException("Already value [" + map.get(actualKey) + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
    }
    if (logger.isTraceEnabled())
      logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" + Thread.currentThread().getName() + "]");
  }

分析源码可以得出，
(1)TransactionSynchronizationManager内部用ThreadLocal对象存储资源，ThreadLocal存储的为DataSource生成的actualKey为key值和ConnectionHolder作为value值封装成的Map。
(2)结合DataSourceUtils的doGetConnection函数和TransactionSynchronizationManager的bindResource函数可知：在某个线程第一次调用时候，封装Map资源为：key值为DataSource生成actualKey【Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);】value值为DataSource获得的Connection对象封装后的ConnectionHolder。等这个线程下一次再次访问中就能保证使用的是第一次创建的ConnectionHolder中的Connection对象。

　　当事务结束后，调用【DataSourceUtils.releaseConnection(con, getDataSource());】将ConnectionHolder从TransactionSynchronizationManager中解除。当谁都不用，这个连接被close。　

public static void releaseConnection(Connection con, DataSource dataSource)
  {
    try
    {
      doReleaseConnection(con, dataSource);
    }
    catch (SQLException ex) {
      logger.debug("Could not close JDBC Connection", ex);
    }
    catch (Throwable ex) {
      logger.debug("Unexpected exception on closing JDBC Connection", ex);
    }
  }
  public static void doReleaseConnection(Connection con, DataSource dataSource)
    throws SQLException
  {
    if (con == null) {
      return;
    }
    if (dataSource != null) {
      ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.getResource(dataSource);
      if ((conHolder != null) && (connectionEquals(conHolder, con)))
      {
        conHolder.released();
        return;
      }
    }
    if ((!(dataSource instanceof SmartDataSource)) || (((SmartDataSource)dataSource).shouldClose(con))) {
      logger.debug("Returning JDBC Connection to DataSource");
      con.close();
    }
  }