MyBatis事务管理机制

Mybatis管理事务是分为两种方式:

(1)使用JDBC的事务管理机制,就是利用java.sql.Connection对象完成对事务的提交 
(2)使用MANAGED的事务管理机制，这种机制mybatis自身不会去实现事务管理，而是让程序的容器（JBOSS,WebLogic）来实现对事务的管理 
在Mybatis的配置文件中可以配置事务管理方式如下： 
[html] view plain copy

 
<?xml version="1.0" encoding="UTF-8"?>  
 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">  
 <configuration>  
     <environments default="development">  
          <environment id="development">  
              <!--配置事务的管理方式-->  
              <transactionManager type="JDBC" />  
              <!-- 配置数据库连接信息 -->  
              <dataSource type="POOLED">  
                  <property name="driver" value="com.mysql.jdbc.Driver" />  
                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />  
                 <property name="username" value="root" />  
                 <property name="password" value="XDP" />  
             </dataSource>  
         </environment>  
     </environments>      
 </configuration>  
Mybatis提供了一个事务接口Transaction，以及两个实现类jdbcTransaction和ManagedTransaction，当spring与Mybatis一起使用时，spring提供了一个实现类SpringManagedTransaction 
Transaction接口：提供的抽象方法有获取数据库连接getConnection，提交事务commit，回滚事务rollback和关闭连接close，源码如下： 
[java] view plain copy

 
//事务接口  
ublic interface Transaction {  
 /** 
  * Retrieve inner database connection 
  * @return DataBase connection 
  * @throws SQLException 
  */  
  //获得数据库连接  
 Connection getConnection() throws SQLException;  
 /** 
  * 提交 
  * Commit inner database connection. 
  * @throws SQLException 
  */  
 void commit() throws SQLException;  
 /** 
  * 回滚 
  * Rollback inner database connection. 
  * @throws SQLException 
  */  
 void rollback() throws SQLException;  
 /** 
  * 关闭连接 
  * Close inner database connection. 
  * @throws SQLException 
  */  
 void close() throws SQLException;  

JdbcTransaction实现类：Transaction的实现类，通过使用jdbc提供的方式来管理事务，通过Connection提供的事务管理方法来进行事务管理，源码如下： 
[java] view plain copy

 
public class JdbcTransaction implements Transaction {  
  
  private static final Log log = LogFactory.getLog(JdbcTransaction.class);  
  
  /* 连接**/  
  protected Connection connection;  
    
  /* 数据源**/  
  protected DataSource dataSource;  
    
  /* 事务等级**/  
  protected TransactionIsolationLevel level;  
    
  /* 事务提交**/  
  protected boolean autoCommmit;  
  
  public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {  
    dataSource = ds;  
    level = desiredLevel;  
    autoCommmit = desiredAutoCommit;  
  }  
  
  public JdbcTransaction(Connection connection) {  
    this.connection = connection;  
  }  
  
  @Override  
  public Connection getConnection() throws SQLException {  
    if (connection == null) {  
      openConnection();  
    }  
    //返回连接  
    return connection;  
  }  
  
  @Override  
  public void commit() throws SQLException {  
    if (connection != null && !connection.getAutoCommit()) {  
      if (log.isDebugEnabled()) {  
        log.debug("Committing JDBC Connection [" + connection + "]");  
      }  
      //连接提交  
      connection.commit();  
    }  
  }  
  
  @Override  
  public void rollback() throws SQLException {  
    if (connection != null && !connection.getAutoCommit()) {  
      if (log.isDebugEnabled()) {  
        log.debug("Rolling back JDBC Connection [" + connection + "]");  
      }  
      //连接回滚  
      connection.rollback();  
    }  
  }  
  
  @Override  
  public void close() throws SQLException {  
    if (connection != null) {  
      resetAutoCommit();  
      if (log.isDebugEnabled()) {  
        log.debug("Closing JDBC Connection [" + connection + "]");  
      }  
      //关闭连接  
      connection.close();  
    }  
  }  
  
  protected void setDesiredAutoCommit(boolean desiredAutoCommit) {  
    try {  
      //事务提交状态不一致时修改  
      if (connection.getAutoCommit() != desiredAutoCommit) {  
        if (log.isDebugEnabled()) {  
          log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");  
        }  
        connection.setAutoCommit(desiredAutoCommit);  
      }  
    } catch (SQLException e) {  
      // Only a very poorly implemented driver would fail here,  
      // and there's not much we can do about that.  
      throw new TransactionException("Error configuring AutoCommit.  "  
          + "Your driver may not support getAutoCommit() or setAutoCommit(). "  
          + "Requested setting: " + desiredAutoCommit + ".  Cause: " + e, e);  
    }  
  }  
  
  protected void resetAutoCommit() {  
    try {  
      if (!connection.getAutoCommit()) {  
        // MyBatis does not call commit/rollback on a connection if just selects were performed. select操作没有commit和rollback事务  
        // Some databases start transactions with select statements 一些数据库在select操作是会开启事务  
        // and they mandate a commit/rollback before closing the connection.  
        // A workaround is setting the autocommit to true before closing the connection.  
        // Sybase throws an exception here.  
        if (log.isDebugEnabled()) {  
          log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");  
        }  
        connection.setAutoCommit(true);  
      }  
    } catch (SQLException e) {  
      if (log.isDebugEnabled()) {  
        log.debug("Error resetting autocommit to true "  
          + "before closing the connection.  Cause: " + e);  
      }  
    }  
  }  
  //打开连接  
  protected void openConnection() throws SQLException {  
    if (log.isDebugEnabled()) {  
      log.debug("Opening JDBC Connection");  
    }  
    //从数据源中获得连接  
    connection = dataSource.getConnection();  
    if (level != null) {  
      connection.setTransactionIsolation(level.getLevel());  
    }  
    setDesiredAutoCommit(autoCommmit);  
  }  
  
}  

ManagedTransaction实现类：通过容器来进行事务管理，所有它对事务提交和回滚并不会做任何操作，源码如下： 
[java] view plain copy

 
public class ManagedTransaction implements Transaction {  
  
  private static final Log log = LogFactory.getLog(ManagedTransaction.class);  
  
  private DataSource dataSource;  
  private TransactionIsolationLevel level;  
  private Connection connection;  
  private boolean closeConnection;  
  
  public ManagedTransaction(Connection connection, boolean closeConnection) {  
    this.connection = connection;  
    this.closeConnection = closeConnection;  
  }  
  //数据源，事务等级及是否关闭事务  
  public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {  
    this.dataSource = ds;  
    this.level = level;  
    this.closeConnection = closeConnection;  
  }  
  
  @Override  
  public Connection getConnection() throws SQLException {  
    if (this.connection == null) {  
      openConnection();  
    }  
    return this.connection;  
  }  
  //提交操作无效  
  @Override  
  public void commit() throws SQLException {  
    // Does nothing  
  }  
  //回滚操作无效  
  @Override  
  public void rollback() throws SQLException {  
    // Does nothing  
  }  
  
  @Override  
  public void close() throws SQLException {  
    if (this.closeConnection && this.connection != null) {  
      if (log.isDebugEnabled()) {  
        log.debug("Closing JDBC Connection [" + this.connection + "]");  
      }  
      //关闭连接  
      this.connection.close();  
    }  
  }  
  
  protected void openConnection() throws SQLException {  
    if (log.isDebugEnabled()) {  
      log.debug("Opening JDBC Connection");  
    }  
    this.connection = this.dataSource.getConnection();  
    if (this.level != null) {  
      this.connection.setTransactionIsolation(this.level.getLevel());  
    }  
  }  
  
}  

SpringManagedTransaction实现类：它其实也是通过使用JDBC来进行事务管理的，当spring的事务管理有效时，不需要操作commit/rollback/close，spring事务管理会自动帮我们完成，源码如下： 
[java] view plain copy

 
public class SpringManagedTransaction implements Transaction {  
  
  private static final Log LOGGER = LogFactory.getLog(SpringManagedTransaction.class);  
  
  private final DataSource dataSource;  
  
  private Connection connection;  
  
  private boolean isConnectionTransactional;  
  
  private boolean autoCommit;  
    
  //获得数据源  
  public SpringManagedTransaction(DataSource dataSource) {  
    notNull(dataSource, "No DataSource specified");  
    this.dataSource = dataSource;  
  }  
  
  /** 
   * {@inheritDoc} 
   * 返回数据库连接 
   */  
  @Override  
  public Connection getConnection() throws SQLException {  
    if (this.connection == null) {  
      openConnection();  
    }  
    return this.connection;  
  }  
  
  /** 
   * Gets a connection from Spring transaction manager and discovers if this 
   * {@code Transaction} should manage connection or let it to Spring. 
   * <p> 
   * It also reads autocommit setting because when using Spring Transaction MyBatis 
   * thinks that autocommit is always false and will always call commit/rollback 
   * so we need to no-op that calls. 
   *从spring的事务管理中获得一个连接  
   */  
  private void openConnection() throws SQLException {  
    this.connection = DataSourceUtils.getConnection(this.dataSource);  
    this.autoCommit = this.connection.getAutoCommit();  
    this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);  
  
    if (LOGGER.isDebugEnabled()) {  
      LOGGER.debug(  
          "JDBC Connection ["  
              + this.connection  
              + "] will"  
              + (this.isConnectionTransactional ? " " : " not ")  
              + "be managed by Spring");  
    }  
  }  
  
  /** 
   * {@inheritDoc} 
   */  
  @Override  
  public void commit() throws SQLException {  
    if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {  
      if (LOGGER.isDebugEnabled()) {  
        LOGGER.debug("Committing JDBC Connection [" + this.connection + "]");  
      }  
      this.connection.commit();  
    }  
  }  
  
  /** 
   * {@inheritDoc} 
   */  
  @Override  
  public void rollback() throws SQLException {  
    if (this.connection != null && !this.isConnectionTransactional && !this.autoCommit) {  
      if (LOGGER.isDebugEnabled()) {  
        LOGGER.debug("Rolling back JDBC Connection [" + this.connection + "]");  
      }  
      this.connection.rollback();  
    }  
  }  
  
  /** 
   * {@inheritDoc} 
   */  
  @Override  
  public void close() throws SQLException {  
    DataSourceUtils.releaseConnection(this.connection, this.dataSource);  
  }  
  
}