AI专业者开发社区 1 号成员
  •  0 回帖  •  5 浏览  •  5 个月前
 

MyBatis事务管理机制

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

目录

一、概述

二、事务的配置创建和使用

  1. 事务的配置
  2. 事务工厂的创建
  3. 事务工厂 TransactionFactory
  4. 事务 Transaction 的创建
  5. JdbcTransaction
  6. ManagedTransaction

一、概述

    对数据库的事务而言，应该具有以下几点：创建（create）、提交（commit）、回滚（rollback）、关闭（close）。对应地，MyBatis 将事务抽象成了 Transaction 接口：其接口定义如下：

MyBatis 的事务管理分为两种形式：

  1. 使用JDBC的事务管理机制：即利用 java.sql.Connection 对象完成对事务的提交（commit()）、回滚（rollback()）、关闭（close()）等。
  2. 使用MANAGED的事务管理机制：这种机制 MyBatis 自身不会去实现事务管理，而是让程序的容器如（JBOSS，Weblogic）来实现对事务的管理。

这两者的类图如下所示：

二、事务的配置、创建和使用

1. 事务的配置 

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<?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>
    <!--映入外部文件定义的属性，供此配置文件使用-->
    <properties resource="jdbc.properties"></properties>
 
    <environments default="development">
        <!-- 连接环境信息，取一个任意唯一的名字 -->
        <environment id="development">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="pooled">
                <!-- 配置与数据库交互的4个必要属性 -->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
     
    <!-- 加载映射文件-->
    <mappers>
        <mapper resource="com/mybatis/EmployeeMapper.xml"/>
    </mappers>   
</configuration>

<environment> 节点定义了连接某个数据库的信息，其子节点 <transactionManager> 的 type 会决定我们用什么类型的事务管理机制。

2. 事务工厂的创建

    MyBatis 事务的创建是交给 TransactionFactory 事务工厂来创建的，如果我们将 <transactionManager> 的 type 配置为 "JDBC", 那么，在 MyBatis 初始化解析 <environment> 节点时，会根据 type="JDBC" 创建一个 JdbcTransactionFactory 工厂，其源码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  /**
   * 解析<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实例。
 
MyBatis 对 <transactionManager> 节点的解析会生成 TransactionFactory 实例；而对 <dataSource> 解析会生成 datasouce 实例 ( 关于 dataSource 的解析和原理，读者可以参照我的另一篇博文：《Mybatis 数据源与连接池》)

作为 <environment> 节点，会根据 TransactionFactory 和 DataSource 实例创建一个 Environment 对象，代码如下所示：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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
        Environment.Builder environmentBuilder = new Environment.Builder(id)
            .transactionFactory(txFactory)
            .dataSource(dataSource);
        configuration.setEnvironment(environmentBuilder.build());
      }
    }
  }
}
 
Environment表示着一个数据库的连接，生成后的 Environment 对象会被设置到 Configuration 实例中，以供后续的使用。

    上述一直在讲事务工厂 TransactionFactory 来创建的 Transaction，现在让我们看一下 MyBatis 中的 TransactionFactory 的定义吧。

3. 事务工厂 TransactionFactory

    事务工厂 Transaction 定义了创建 Transaction 的两个方法：

  1. 通过指定的 Connection 对象创建 Transaction
  2. 通过数据源 DataSource 来创建 Transaction

与 JDBC 和 MANAGED 两种 Transaction 相对应，TransactionFactory 有两个对应的实现的子类：如下所示：

4. 事务 Transaction 的创建

通过事务工厂 TransactionFactory 很容易获取到 Transaction 对象实例。我们以 JdbcTransaction 为例，看一下 JdbcTransactionFactory 是怎样生成 JdbcTransaction 的，代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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，看它们到底是怎样实现事务管理的。

5. JdbcTransaction

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

    直观地讲，就是 JdbcTransaction 是使用的 java.sql.Connection 上的 commit 和 rollback 功能，JdbcTransaction 只是相当于对 java.sql.Connection 事务处理进行了一次包装（wrapper），Transaction 的事务管理都是通过 java.sql.Connection 实现的。JdbcTransaction 的代码实现如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/**
 * @see JdbcTransactionFactory
 */
/**
 * @author Clinton Begin
 */
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;
  }
  
  public Connection getConnection() throws SQLException {
    if (connection == null) {
      openConnection();
    }
    return connection;
  }
  
    /**
     * commit()功能 使用connection的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()
     * @throws SQLException
     */
  public void rollback() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) {
      if (log.isDebugEnabled()) {
        log.debug("Rolling back JDBC Connection [" + connection + "]");
      }
      connection.rollback();
    }
  }
  
    /**
     * close()功能 使用connection的close()
     * @throws SQLException
     */
  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.
        // Some databases start transactions with select statements
        // 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) {
      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);
  }
  
}

6. ManagedTransaction

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/**
 *
 * 让容器管理事务transaction的整个生命周期
 * connection的获取延迟到getConnection()方法的调用
 * 忽略所有的commit和rollback操作
 * 默认情况下，可以关闭一个连接connection，也可以配置它不可以关闭一个连接
 * 让容器来管理transaction的整个生命周期
 * @see ManagedTransactionFactory
 */
/**
 * @author Clinton Begin
 */
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;
  }
  
  public Connection getConnection() throws SQLException {
    if (this.connection == null) {
      openConnection();
    }
    return this.connection;
  }
  
  public void commit() throws SQLException {
    // Does nothing
  }
  
  public void rollback() throws SQLException {
    // Does nothing
  }
  
  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());
    }
  }
  
}
 
注意：如果我们使用 MyBatis 构建本地程序，即不是 WEB 程序，若将 type 设置成 "MANAGED"，那么，我们执行的任何 update 操作，即使我们最后执行了 commit 操作，数据也不会保留，不会对数据库造成任何影响。因为我们将 MyBatis 配置成了“MANAGED”，即 MyBatis 自己不管理事务，而我们又是运行的本地程序，没有事务管理功能，所以对数据库的 update 操作都是无效的。