《深入理解mybatis原理》 MyBatis事務管理機制

本文轉載自查看原文 2017-12-29 10:09 6129 Mybatis

MyBatis作為Java語言的數據庫框架，對數據庫的事務管理是其非常重要的一個方面。本文將講述MyBatis的事務管理的實現機制。首先介紹MyBatis的事務Transaction的接口設計以及其不同實現JdbcTransaction 和 ManagedTransaction；接着，從MyBatis的XML配置文件入手，講解MyBatis事務工廠的創建和維護，進而闡述了MyBatis事務的創建和使用；最后分析JdbcTransaction和ManagedTransaction的實現和二者的不同特點。

以下是本文的組織結構：

一、概述

對數據庫的事務而言，應該具有以下幾點：創建（create）、提交（commit）、回滾（rollback）、關閉（close）。對應地，MyBatis將事務抽象成了Transaction接口：其接口定義如下：

MyBatis的事務管理分為兩種形式：

一、使用JDBC的事務管理機制：即利用java.sql.Connection對象完成對事務的提交（commit()）、回滾（rollback()）、關閉（close()）等

二、使用MANAGED的事務管理機制：這種機制MyBatis自身不會去實現事務管理，而是讓程序的容器如（JBOSS，Weblogic）來實現對事務的管理

這兩者的類圖如下所示：

二、事務的配置、創建和使用

1. 事務的配置

我們在使用MyBatis時，一般會在MyBatisXML配置文件中定義類似如下的信息：

<environment>節點定義了連接某個數據庫的信息，其子節點<transactionManager> 的type 會決定我們用什么類型的事務管理機制。

2.事務工廠的創建

MyBatis事務的創建是交給TransactionFactory 事務工廠來創建的，如果我們將<transactionManager>的type 配置為"JDBC",那么，在MyBatis初始化解析<environment>節點時，會根據type="JDBC"創建一個JdbcTransactionFactory工廠，其源碼如下：

 1     /**
 2      * 解析<transactionManager>節點，創建對應的TransactionFactory
 3      * @param context
 4      * @return
 5      * @throws Exception
 6      */
 7   private TransactionFactory transactionManagerElement(XNode context) throws Exception {
 8     if (context != null) {
 9       String type = context.getStringAttribute("type");
10       Properties props = context.getChildrenAsProperties();
11       /*
12             在Configuration初始化的時候，會通過以下語句，給JDBC和MANAGED對應的工廠類
13             typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
14             typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
15             下述的resolveClass(type).newInstance()會創建對應的工廠實例
16        */
17       TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
18       factory.setProperties(props);
19       return factory;
20     }
21     throw new BuilderException("Environment declaration requires a TransactionFactory.");
22   }

View Code

如上述代碼所示，如果type = "JDBC",則MyBatis會創建一個JdbcTransactionFactory.class 實例；如果type="MANAGED"，則MyBatis會創建一個MangedTransactionFactory.class實例。

MyBatis對<transactionManager>節點的解析會生成 TransactionFactory實例；而對<dataSource>解析會生成datasouce實例(關於dataSource的解析和原理，讀者可以參照我的另一篇博文：《深入理解mybatis原理》 Mybatis數據源與連接池
)，作為<environment>節點，會根據TransactionFactory和DataSource實例創建一個Environment對象，代碼如下所示：

 1   private void environmentsElement(XNode context) throws Exception {
 2     if (context != null) {
 3       if (environment == null) {
 4         environment = context.getStringAttribute("default");
 5       }
 6       for (XNode child : context.getChildren()) {
 7         String id = child.getStringAttribute("id");
 8         //是和默認的環境相同時，解析之
 9         if (isSpecifiedEnvironment(id)) {
10           //1.解析<transactionManager>節點，決定創建什么類型的TransactionFactory
11           TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
12           //2. 創建dataSource
13           DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
14           DataSource dataSource = dsFactory.getDataSource();
15           //3. 使用了Environment內置的構造器Builder，傳遞id 事務工廠TransactionFactory和數據源DataSource
16           Environment.Builder environmentBuilder = new Environment.Builder(id)
17               .transactionFactory(txFactory)
18               .dataSource(dataSource);
19           configuration.setEnvironment(environmentBuilder.build());
20         }
21       }
22     }
23   }

View Code

Environment表示着一個數據庫的連接，生成后的Environment對象會被設置到Configuration實例中，以供后續的使用。

上述一直在講事務工廠TransactionFactory來創建的Transaction，現在讓我們看一下MyBatis中的TransactionFactory的定義吧。

3. 事務工廠TransactionFactory

事務工廠Transaction定義了創建Transaction的兩個方法：一個是通過指定的Connection對象創建Transaction，另外是通過數據源DataSource來創建Transaction。與JDBC 和MANAGED兩種Transaction相對應，TransactionFactory有兩個對應的實現的子類：如下所示：

4. 事務Transaction的創建

通過事務工廠TransactionFactory很容易獲取到Transaction對象實例。我們以JdbcTransaction為例，看一下JdbcTransactionFactory是怎樣生成JdbcTransaction的，代碼如下：

 1 public class JdbcTransactionFactory implements TransactionFactory {
 2 
 3   public void setProperties(Properties props) {
 4   }
 5 
 6     /**
 7      * 根據給定的數據庫連接Connection創建Transaction
 8      * @param conn Existing database connection
 9      * @return
10      */
11   public Transaction newTransaction(Connection conn) {
12     return new JdbcTransaction(conn);
13   }
14 
15     /**
16      * 根據DataSource、隔離級別和是否自動提交創建Transacion
17      *
18      * @param ds
19      * @param level Desired isolation level
20      * @param autoCommit Desired autocommit
21      * @return
22      */
23   public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
24     return new JdbcTransaction(ds, level, autoCommit);
25   }
26 }

View Code

如上說是，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  * @see JdbcTransactionFactory
  3  */
  4 /**
  5  * @author Clinton Begin
  6  */
  7 public class JdbcTransaction implements Transaction {
  8 
  9   private static final Log log = LogFactory.getLog(JdbcTransaction.class);
 10 
 11   //數據庫連接
 12   protected Connection connection;
 13   //數據源
 14   protected DataSource dataSource;
 15   //隔離級別
 16   protected TransactionIsolationLevel level;
 17   //是否為自動提交
 18   protected boolean autoCommmit;
 19 
 20   public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
 21     dataSource = ds;
 22     level = desiredLevel;
 23     autoCommmit = desiredAutoCommit;
 24   }
 25 
 26   public JdbcTransaction(Connection connection) {
 27     this.connection = connection;
 28   }
 29 
 30   public Connection getConnection() throws SQLException {
 31     if (connection == null) {
 32       openConnection();
 33     }
 34     return connection;
 35   }
 36 
 37     /**
 38      * commit()功能 使用connection的commit()
 39      * @throws SQLException
 40      */
 41   public void commit() throws SQLException {
 42     if (connection != null && !connection.getAutoCommit()) {
 43       if (log.isDebugEnabled()) {
 44         log.debug("Committing JDBC Connection [" + connection + "]");
 45       }
 46       connection.commit();
 47     }
 48   }
 49 
 50     /**
 51      * rollback()功能 使用connection的rollback()
 52      * @throws SQLException
 53      */
 54   public void rollback() throws SQLException {
 55     if (connection != null && !connection.getAutoCommit()) {
 56       if (log.isDebugEnabled()) {
 57         log.debug("Rolling back JDBC Connection [" + connection + "]");
 58       }
 59       connection.rollback();
 60     }
 61   }
 62 
 63     /**
 64      * close()功能 使用connection的close()
 65      * @throws SQLException
 66      */
 67   public void close() throws SQLException {
 68     if (connection != null) {
 69       resetAutoCommit();
 70       if (log.isDebugEnabled()) {
 71         log.debug("Closing JDBC Connection [" + connection + "]");
 72       }
 73       connection.close();
 74     }
 75   }
 76 
 77   protected void setDesiredAutoCommit(boolean desiredAutoCommit) {
 78     try {
 79       if (connection.getAutoCommit() != desiredAutoCommit) {
 80         if (log.isDebugEnabled()) {
 81           log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");
 82         }
 83         connection.setAutoCommit(desiredAutoCommit);
 84       }
 85     } catch (SQLException e) {
 86       // Only a very poorly implemented driver would fail here,
 87       // and there's not much we can do about that.
 88       throw new TransactionException("Error configuring AutoCommit.  "
 89           + "Your driver may not support getAutoCommit() or setAutoCommit(). "
 90           + "Requested setting: " + desiredAutoCommit + ".  Cause: " + e, e);
 91     }
 92   }
 93 
 94   protected void resetAutoCommit() {
 95     try {
 96       if (!connection.getAutoCommit()) {
 97         // MyBatis does not call commit/rollback on a connection if just selects were performed.
 98         // Some databases start transactions with select statements
 99         // and they mandate a commit/rollback before closing the connection.
100         // A workaround is setting the autocommit to true before closing the connection.
101         // Sybase throws an exception here.
102         if (log.isDebugEnabled()) {
103           log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");
104         }
105         connection.setAutoCommit(true);
106       }
107     } catch (SQLException e) {
108       log.debug("Error resetting autocommit to true "
109           + "before closing the connection.  Cause: " + e);
110     }
111   }
112 
113   protected void openConnection() throws SQLException {
114     if (log.isDebugEnabled()) {
115       log.debug("Opening JDBC Connection");
116     }
117     connection = dataSource.getConnection();
118     if (level != null) {
119       connection.setTransactionIsolation(level.getLevel());
120     }
121     setDesiredAutoCommit(autoCommmit);
122   }
123 
124 }

View Code

6. ManagedTransaction

ManagedTransaction讓容器來管理事務Transaction的整個生命周期，意思就是說，使用ManagedTransaction的commit和rollback功能不會對事務有任何的影響，它什么都不會做，它將事務管理的權利移交給了容器來實現。看如下Managed的實現代碼大家就會一目了然：

 1 /**
 2  * 
 3  * 讓容器管理事務transaction的整個生命周期
 4  * connection的獲取延遲到getConnection()方法的調用
 5  * 忽略所有的commit和rollback操作
 6  * 默認情況下，可以關閉一個連接connection，也可以配置它不可以關閉一個連接
 7  * 讓容器來管理transaction的整個生命周期
 8  * @see ManagedTransactionFactory
 9  */
10 /**
11  * @author Clinton Begin
12  */
13 public class ManagedTransaction implements Transaction {
14 
15   private static final Log log = LogFactory.getLog(ManagedTransaction.class);
16 
17   private DataSource dataSource;
18   private TransactionIsolationLevel level;
19   private Connection connection;
20   private boolean closeConnection;
21 
22   public ManagedTransaction(Connection connection, boolean closeConnection) {
23     this.connection = connection;
24     this.closeConnection = closeConnection;
25   }
26 
27   public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {
28     this.dataSource = ds;
29     this.level = level;
30     this.closeConnection = closeConnection;
31   }
32 
33   public Connection getConnection() throws SQLException {
34     if (this.connection == null) {
35       openConnection();
36     }
37     return this.connection;
38   }
39 
40   public void commit() throws SQLException {
41     // Does nothing
42   }
43 
44   public void rollback() throws SQLException {
45     // Does nothing
46   }
47 
48   public void close() throws SQLException {
49     if (this.closeConnection && this.connection != null) {
50       if (log.isDebugEnabled()) {
51         log.debug("Closing JDBC Connection [" + this.connection + "]");
52       }
53       this.connection.close();
54     }
55   }
56 
57   protected void openConnection() throws SQLException {
58     if (log.isDebugEnabled()) {
59       log.debug("Opening JDBC Connection");
60     }
61     this.connection = this.dataSource.getConnection();
62     if (this.level != null) {
63       this.connection.setTransactionIsolation(this.level.getLevel());
64     }
65   }
66 
67 }

View Code

注意：如果我們使用MyBatis構建本地程序，即不是WEB程序，若將type設置成"MANAGED"，那么，我們執行的任何update操作，即使我們最后執行了commit操作，數據也不會保留，不會對數據庫造成任何影響。因為我們將MyBatis配置成了“MANAGED”，即MyBatis自己不管理事務，而我們又是運行的本地程序，沒有事務管理功能，所以對數據庫的update操作都是無效的。

轉自：http://blog.csdn.net/luanlouis/article/details/37992171

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Spring3數據庫事務管理機制深入理解事務與鎖機制（上） springboot mybatis 事務管理 MyBatis深入理解一深入理解mybatis 深入理解 Android 消息機制原理深入理解Spring Security授權機制原理深入理解Redis的持久化機制和原理深入理解Notification機制深入理解session機制