探囊取物，取出MyBatis内部事务

Posted 2021-10-29 毛奇志

文章目录

• 一、前言
• 二、事务概要
• • 2.1 从数据库事务到Mybatis事务
  • 2.2 Mybatis事务的两种形式
• 三、事务的创建
• • 3.1 mybatis-config.xml配置
  • 3.2 创建事务工厂
  • • 3.2.1 parse()
    • 3.2.2 parseConfiguration()
    • 3.2.3 environmentsElement()
    • 3.2.4 transactionManagerElement()
  • 3.3 创建事务Transaction
• 四、JdbcTransaction源码解析
• • 4.1 commit()+rollback()+close()的调用,都交给connection来完成
  • 4.2 getConnection()和openConnection()逻辑
  • 4.3 如果autocommit设置为on，忽略commit和rollback
  • 4.4 close()
  • 4.5 JdbcTransaction类的变量：connection dataSource level autoCommmit
• 五、ManagedTransaction源码解析
• • 5.1 commit()+rollback()+close()的调用
  • 5.2 getConnection()和openConnection()逻辑
  • 5.3 忽略commit和rollback操作
  • 5.4 close()逻辑:直接关闭连接
  • 5.5 ManagedTransaction的属性:dataSource level connection closeConnection
• 六、尾声

一、前言

MyBatis作为Java语言的数据库框架，对数据库的事务管理是其非常重要的一个方面。本文将讲述MyBatis的事务管理的实现机制。首先介绍MyBatis的事务Transaction的接口设计以及其不同实现JdbcTransaction 和 ManagedTransaction；接着，从MyBatis的XML配置文件入手，讲解MyBatis事务工厂的创建和维护，进而阐述了MyBatis事务的创建和使用；最后分析JdbcTransaction和ManagedTransaction的实现和二者的不同特点。

二、事务概要

2.1 从数据库事务到Mybatis事务

对数据库的事务而言，应该具有以下几点：创建（create）、提交（commit）、回滚（rollback）、关闭（close）。MyBatis中将对事务的处理封装到Transaction接口中，该接口可以完成对事务的创建（create）、提交（commit）、回滚（rollback）、关闭（close）。接口定义如下：

2.2 Mybatis事务的两种形式

MyBatis的事务管理分为两种形式，即Transaction接口两个实现类（JdbcTransaction和ManagedTransaction）：

1、使用JDBC的事务管理机制：即利用java.sql.Connection对象完成对事务的提交（commit()）、回滚（rollback()）、关闭（close()）等

2、使用Managed的事务管理机制：这种机制MyBatis自身不会去实现事务管理，而是让程序的容器如（JBOSS，Weblogic、Tomcat）来实现对事务的管理.

这两者的类图如下所示：

三、事务的创建

事务的创建分为三步：

第一步，mybatis-config.xml中配置
第二步，创建事务工厂
第三步，创建事务Transaction

3.1 mybatis-config.xml配置

我们在使用MyBatis时，一般会在MyBatisXML配置文件中定义类似如下的信息：

mybatis-config.xml配置文件中，<environment>节点定义了连接某个数据库的信息，其子节点<transactionManager> 的 type 会决定我们用什么类型的事务管理机制，<transactionManager>节点中，type="jdbc"表示使用JdbcTransaction，type="managed"表示使用ManagedTransaction。

3.2 创建事务工厂

MyBatis事务的创建是交给TransactionFactory 事务工厂来创建的，要想创建事务，先要创建一个事务工厂。对于读取到的 mybatis-config.xml 文件，如果我们将<transactionManager>的type 配置为"JDBC",那么，在MyBatis初始化解析<environment>节点时，会根据 type=“JDBC” 创建一个JdbcTransactionFactory 工厂。

创建事务工厂三步骤：

第一步，parse()方法中调用parseConfiguration()方法
parseConfiguration()方法内部逻辑：解析configuration下的子节点，其中包括environments节点

第二步，parseConfiguration()方法中调用environmentsElement()方法
environmentsElement()方法内部逻辑：解析environments节点下面的子节点

第三步，environmentsElement()方法中调用transactionManagerElement()方法和dataSourceElement()方法
transactionManagerElement()方法内部逻辑：解析transactionManager节点
dataSourceElement()方法内部逻辑：解析dataSource节点，然后通过反射方法构建TransactionFactory

3.2.1 parse()

parse()方法概述：XMLConfigBuilder类中，parse()在mybatis初始化的时候，会从XPathParser中取出 节点对应的Node对象，然后解析此Node节点的子Node，都设置到configuration类对象中，最后返回一个configuration对象。

3.2.2 parseConfiguration()

3.2.3 environmentsElement()

MyBatis 对 transactionManager 节点的解析会生成 TransactionFactory实例，对dataSource 解析会生成datasouce实例，作为 environment 节点，会根据TransactionFactory和DataSource实例创建一个Environment对象，代码如下所示：

  private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
      if (environment == null) {
        environment = context.getStringAttribute("default");
      }
      for (XNode child : context.getChildren()) {
        String id = child.getStringAttribute("id");
        //是和默认的环境相同时，解析之
        if (isSpecifiedEnvironment(id)) {
          //1.解析<transactionManager>节点，决定创建什么类型的TransactionFactory
          TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
          //2. 创建dataSource
          DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
          DataSource dataSource = dsFactory.getDataSource();
          //3. 使用了Environment内置的构造器Builder，传递id 事务工厂TransactionFactory和数据源DataSource，得到builder
          Environment.Builder environmentBuilder = new Environment.Builder(id)
              .transactionFactory(txFactory)
              .dataSource(dataSource);
          //4.  最后设置到configuration对象上去，然后最后parse()方法返回的解释组装好的configuration对象
          configuration.setEnvironment(environmentBuilder.build());   
        }
      }
    }
  }

1、解析<transactionManager>节点，决定创建什么类型的TransactionFactory，使用反射的方式创建具体的TransactionFactory（刚才的transactionManagerElement()方法解释过了）
2、创建dataSource
3、使用了Environment内置的构造器Builder，传递id 事务工厂TransactionFactory和数据源DataSource，得到builder
4、最后设置到configuration对象上去，然后最后parse()方法返回的解释组装好的configuration对象

Environment: Environment表示着一个数据库的连接，生成后的Environment对象会被设置到Configuration实例中，以供后续的使用。

事务工厂TransactionFactory源码解析

事务工厂Transaction定义了创建Transaction的两个方法：一个是通过指定的Connection对象创建Transaction，另外是通过数据源DataSource来创建Transaction。与JDBC和MANAGED两种Transaction相对应，TransactionFactory有两个对应的实现的子类，如下所示：

举一反三：

Tranaction是事务接口，目的是对数据库事务进行抽象，提供创建（构建函数创建事务）、提交（commit）、回滚（rollback）、关闭（close）方法，两个实现类，JdbcTransaction类和ManagedTransaction类。

TranactionFactory是事务工厂接口，目的是创建事务，提供newInstance()方法，两个实现类，JdbcTransactionFactory类和ManagedTransactionFactory类。

3.2.4 transactionManagerElement()

    /**
     * 解析<transactionManager>节点，创建对应的TransactionFactory
     * @param context
     * @return
     * @throws Exception
     */
  private TransactionFactory transactionManagerElement(XNode context) throws Exception {
    if (context != null) {
      String type = context.getStringAttribute("type");
      Properties props = context.getChildrenAsProperties();
      /*
            在Configuration初始化的时候，会通过以下语句，给JDBC和MANAGED对应的工厂类
            typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
            typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
            下述的resolveClass(type).newInstance()会创建对应的工厂实例
       */
      TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
      factory.setProperties(props);
      return factory;
    }
    throw new BuilderException("Environment declaration requires a TransactionFactory.");
  }

如上述代码所示，如果type = “JDBC”,则MyBatis会创建一个JdbcTransactionFactory.class 实例；如果type=“MANAGED”，则MyBatis会创建一个MangedTransactionFactory.class实例。

注意，这里是使用反射的方式创建JdbcTransactionFactory实例的
TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
貌似源码解析xml配置文件都是通过反射的方式，Spring解析applicationContext.xml是通过反射新建实例，Mybatis解析mybatis-config.xml也是通过反射新建实例。

3.3 创建事务Transaction

通过事务工厂TransactionFactory很容易获取到Transaction对象实例，即通过事务工厂JdbcTransactionFactory很容易获取到JdbcTransaction对象实例，通过事务工厂ManagedTransactionFactory很容易获取到ManagedTransaction对象实例。

我们以JdbcTransaction为例，看一下JdbcTransactionFactory是怎样生成JdbcTransaction的，找到JdbcTransactionFactory类中的newTransaction()方法，代码如下：

public class JdbcTransactionFactory implements TransactionFactory {
 
  public void setProperties(Properties props) {
  }
 
    /**
     * 根据给定的数据库连接Connection创建Transaction
     * @param conn Existing database connection
     * @return
     */
  public Transaction newTransaction(Connection conn) {
    return new JdbcTransaction(conn);
  }
 
    /**
     * 根据DataSource、隔离级别和是否自动提交创建Transacion
     *
     * @param ds
     * @param level Desired isolation level
     * @param autoCommit Desired autocommit
     * @return
     */
  public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
    return new JdbcTransaction(ds, level, autoCommit);
  }
}

如上所示，JdbcTransactionFactory会创建JDBC类型的Transaction，即JdbcTransaction。类似地，ManagedTransactionFactory也会创建ManagedTransaction。下面我们会分别深入JdbcTranaction 和ManagedTransaction，看它们到底是怎样实现事务管理的。

问题：创建TransactionFactory对象和创建Transaction对象的方式是否一样？
回答：不一样。Mybatis中创建TransactionFactory是使用反射的方式，TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance(); 但是在TransactionFactory中创建Transaction是使用new：

 public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level,  boolean autoCommit) {
    return new JdbcTransaction(ds, level, autoCommit);
  }

问题：整个事务创建过程中，mybatis是如何根据配置文件中的事务类型“jdbc”或“managed”来创建相应的事务的？
回答：对于配置文件mybatis-config.xml配置文件中传递过来的“jdbc”或“managed”，mybatis底层使用parse()解析mybatis-config.xml配置文件的时候，先创建对相应的JdbcTransactionFactory或者ManagedTransactionFactory，然后在这两个TransactionFactory中的newInstance中创建JdbcTransaction或者ManagedTransaction。

问题：整个事务创建过程涉及的类与接口？
回答：
XMLConfigBuilder类
JdbcTransactionFactory（TransactionFactory）
ManagedTransactionFactory（TransactionFactory）
JdbcTransaction（Transaction）
ManagedTransaction（Transaction）

四、JdbcTransaction源码解析

1. JdbcTransaction依赖与从dataSource中取得的连接 connection 来管理 transaction 的作用域，直接使用JDBC的commit和rollback和close事务管理机制。
2. connection对象的获取被延迟到调用getConnection()方法。
3. 如果autocommit设置为on，开启状态的话，它会执行后自动提交，忽略commit和rollback。

4.1 commit()+rollback()+close()的调用,都交给connection来完成

JdbcTransaction的事务提交、事务回滚、事务关闭都是通过调用connection中的方法来完成的。

4.2 getConnection()和openConnection()逻辑

connection对象的获取被延迟到调用getConnection()方法（就是上面getConnection()中当connection为null,调动openConnection()方法）。注意，openConnection()中之所以可以设置connection，它是通过datasource.getConnection()获取的。

  protected void openConnection() throws SQLException {
    if (log.isDebugEnabled()) {
      log.debug("Opening JDBC Connection");
    }
    connection = dataSource.getConnection();
    // 在openConnection()方法中，如果level不为null,会设置事务隔离级别
    if (level != null) {
      connection.setTransactionIsolation(level.getLevel());
    }
    // 这里调用一个setDesiredAutoCommit()方法，在JdbcTransaction事务中设置是否
    setDesiredAutoCommit(autoCommmit); 
  }  
  
  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);
    }  
 }  

openConnection()方法完成三件事：

(1) 设置类的connection变量

(2) 设置隔离级别(如果类的level变量不为null，通过类的level变量设置隔离级别，这里是通过JdbcTransaction类设置，因为这个隔离级别就是在JdbcTransaction类中使用的，作为commit和rollback的判断依据)

(3) 设置自动提交(底层还是使用connection去设置)

4.3 如果autocommit设置为on，忽略commit和rollback

如果autocommit设置为on，开启状态的话，它会忽略commit和rollback。代码解释：

/**
 * 三大功能之一 commit()功能 使用connection的commit() ，
 * 注意，要connection不为null,而且自动提交为false才行，自动提交为true,忽略commit()方法
 * @throws SQLException
 */   public void commit() throws SQLException {
if (connection != null && !connection.getAutoCommit()) {
  if (log.isDebugEnabled()) {
    log.debug("Committing JDBC Connection [" + connection + "]");
  }
  connection.commit();
}   }

/**
 * 三大功能之一 rollback()功能 使用connection的rollback()
 * 注意，要connection不为null,而且自动提交为false才行，自动提交为true,忽略commit()方法
 * @throws SQLException
 */   public void rollback() throws SQLException {
if (connection != null && !connection.getAutoCommit()) {
  if (log.isDebugEnabled()) {
    log.debug("Rolling back JDBC Connection [" + connection + "]");
  }
  connection.rollback();
}   } 

4.4 close()

close()逻辑:重置自动提交为true+关闭连接

 /**
 * 三大功能之一 close()功能 使用connection的close()
 * @throws SQLException
 */   
public void close() throws SQLException {
if (connection != null) {
  resetAutoCommit();
  connection.close();
}   
}   
protected void resetAutoCommit() {
try {
  if (!connection.getAutoCommit()) {
    connection.setAutoCommit(true);
  }
} catch (SQLException e) {
  log.debug("Error resetting autocommit to true "
      + "before closing the connection.  Cause: " + e);
}   }

4.5 JdbcTransaction类的变量：connection dataSource level autoCommmit

JdbcTransaction中的方法解释完成了，JdbcTransaction的变量如下：

public class JdbcTransaction implements Transaction {
  //日志打印
  private static final Log log = LogFactory.getLog(JdbcTransaction.class);

  //数据库连接
  protected Connection connection;    // 构造函数或者openConnection()方法中设置，三个方法commit() rollback() close() setAutoCommit()的时候使用，都是调用connection来实现的
  //数据源
  protected DataSource dataSource;   //构造函数中设置，在openConnection()方法中，通过dataSource.getConnection()设置connection对象
  //隔离级别
  protected TransactionIsolationLevel level;   //构造函数中设置，在openConnection()方法中，通过connection.setTransactionIsolation()设置隔离级别	
  //是否为自动提交
  protected boolean autoCommmit;  //构造函数中设置，在openConnection()方法中，通过调用setDesiredAutoCommit(autoCommmit)设置是否自动提交
}

五、ManagedTransaction源码解析

ManagedTransaction让容器来管理事务Transaction的整个生命周期，意思就是说，使用ManagedTransaction的commit和rollback功能不会对事务有任何的影响，它什么都不会做，它将事务管理的权利移交给了容器来实现。

5.1 commit()+rollback()+close()的调用

容器管理，rollback()和commit(),mybatis还是可以管理close()的

commit()+rollback()

使用ManagedTransaction的commit和rollback功能不会对事务有任何的影响，它什么都不会做，它将事务管理的权利移交给了容器来实现。

close()

默认情况下，可以配置它可以关闭一个连接connection（closeConnection变量为true,这样就无法调用close()），也可以配置它不可以关闭一个连接，让容器来管理transaction的整个生命周期

5.2 getConnection()和openConnection()逻辑

connection的获取延迟到getConnection()方法的调用

(1) getConnection()中调用openConnection()设置类中的connnection属性;
(2) openConnection()完成两件事情，设置类中的connection属性和设置类中connection属性的隔离级别，与JdbcTransaction不同的是，不用设置自动提交。

JdbcTransaction通过在openConnection()方法中设置自动提交，然后再rollback()和commit()方法中根据判断自动提交来决定是否执行；但是在ManagedTransaction中，rollback()和commit()为空方法，所有不用设置和获取自动提交，完全交给容器来执行.

// getConnection()中调用openConnection()设置类中的connnection属性
  public Connection getConnection() throws SQLException {
    if (this.connection == null) {
      openConnection();
    }
    return this.connection;
  }
 // openConnection()完成两件事情，设置类中的connection属性和设置类中connection属性的隔离级别，与JdbcTransaction不同的是，不用设置自动提交，JdbcTransaction通过在openConnection()方法中设置自动提交，然后再rollback()和commit()方法中根据判断自动提交来决定是否执行；但是在ManagedTransaction中，rollback()和commit()为空方法，所有不用设置和获取自动提交，完全交给容器来执行
  protected void openConnection() throws SQLException {
 
    this.connection = this.dataSource.getConnection();
    if (this.level != null) {
      this.connection.setTransactionIsolation(this.level.getLevel());
    }
  }

5.3 忽略commit和rollback操作

忽略所有的commit和rollback操作

public void commit() throws SQLException {
    // Does nothing
  }
 
public void rollback() throws SQLException {
    // Does nothing
  }

5.4 close()逻辑:直接关闭连接

close()方法还是使用connection的close()方法

  public void close() throws SQLException {
    if (this.closeConnection && this.connection != null) {
      this.connection.close();
    }
  }

ManagedTransaction类的方法，接下来是ManagedTransaction的属性

5.5 ManagedTransaction的属性:dataSource level connection closeConnection

public class ManagedTransaction implements Transaction {
 
  private static final Log log = LogFactory.getLog(ManagedTransaction.class);   //打印之用
 
  private DataSource dataSource;   // 构造函数中设置，openConnection()方法中使用dataSource.getConnnection()获取Connection对象
  private TransactionIsolationLevel level;  //隔离水平，构造函数中设置，openConnection()方法中使用
  private Connection connection;      // Connection,构造函数或者openConnection()方法中设置，close()方法中使用
  private boolean closeConnection;    // 构造函数中设置，close()方法中使用
 
}

注意：如果我们使用MyBatis构建本地程序，即不是WEB程序，若将type设置成"MANAGED"，那么，我们执行的任何update操作，即使我们最后执行了commit操作，数据也不会保留，不会对数据库造成任何影响。因为我们将MyBatis配置成了“MANAGED”，即MyBatis自己不管理事务，而我们又是运行的本地程序，没有事务管理功能，所以对数据库的update操作都是无效的。

六、尾声

MyBatis事务管理机制，完成了。

天天打码，天天进步！！！