MyBatis事务管理机制

转自:《深入理解mybatis原理》 MyBatis事务管理机制

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

以下是本文的组织结构:

一、概述

    对数据库的事务而言,应该具有以下几点:创建(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. }

  如上述代码所示,如果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. }

  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.   public void setProperties(Properties props) {
  3.   }
  4.     /**
  5.      * 根据给定的数据库连接Connection创建Transaction
  6.      * @param conn Existing database connection
  7.      * @return
  8.      */
  9.   public Transaction newTransaction(Connection conn) {
  10.     return new JdbcTransaction(conn);
  11.   }
  12.     /**
  13.      * 根据DataSource、隔离级别和是否自动提交创建Transacion
  14.      *
  15.      * @param ds
  16.      * @param level Desired isolation level
  17.      * @param autoCommit Desired autocommit
  18.      * @return
  19.      */
  20.   public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
  21.     return new JdbcTransaction(ds, level, autoCommit);
  22.   }
  23. }

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

 

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.   private static final Log log = LogFactory.getLog(ManagedTransaction.class);
  15.   private DataSource dataSource;
  16.   private TransactionIsolationLevel level;
  17.   private Connection connection;
  18.   private boolean closeConnection;
  19.   public ManagedTransaction(Connection connection, boolean closeConnection) {
  20.     this.connection = connection;
  21.     this.closeConnection = closeConnection;
  22.   }
  23.   public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {
  24.     this.dataSource = ds;
  25.     this.level = level;
  26.     this.closeConnection = closeConnection;
  27.   }
  28.   public Connection getConnection() throws SQLException {
  29.     if (this.connection == null) {
  30.       openConnection();
  31.     }
  32.     return this.connection;
  33.   }
  34.   public void commit() throws SQLException {
  35.     // Does nothing
  36.   }
  37.   public void rollback() throws SQLException {
  38.     // Does nothing
  39.   }
  40.   public void close() throws SQLException {
  41.     if (this.closeConnection && this.connection != null) {
  42.       if (log.isDebugEnabled()) {
  43.         log.debug(“Closing JDBC Connection [“ + this.connection + “]”);
  44.       }
  45.       this.connection.close();
  46.     }
  47.   }
  48.   protected void openConnection() throws SQLException {
  49.     if (log.isDebugEnabled()) {
  50.       log.debug(“Opening JDBC Connection”);
  51.     }
  52.     this.connection = this.dataSource.getConnection();
  53.     if (this.level != null) {
  54.       this.connection.setTransactionIsolation(this.level.getLevel());
  55.     }
  56.   }
  57. }

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

以上就是 《深入理解mybatis原理》 MyBatis事务管理机制 的全部内容,如有错误或者不准确的地方,请读者指正,共同进步!

本文源自  http://blog.csdn.NET/luanlouis/,如需转载,请注明出处,谢谢!

此条目发表在java分类目录,贴了标签。将固定链接加入收藏夹。

发表评论

电子邮件地址不会被公开。 必填项已用*标注