【Mybatis 004】原理层面:数据支撑层:谈一谈你对MyBatis事务的理解?

一、前言

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事务:
对数据库的事务而言,应该具有以下几点:创建(create)、提交(commit)、回滚(rollback)、关闭(close)
MyBatis中将对事务的处理封装到Transaction接口中,该接口可以完成对事务的创建(create)、提交(commit)、回滚(rollback)、关闭(close)。
第二,MyBatis的事务管理分为两种形式,即Transaction接口两个实现类(JdbcTransaction和ManagedTransaction):
(1)使用JDBC的事务管理机制:即利用java.sql.Connection对象完成对事务的提交(commit())、回滚(rollback())、关闭(close())等;
(2)使用MANAGED的事务管理机制:这种机制MyBatis自身不会去实现事务管理,而是让程序的容器如(JBOSS,Weblogic、Tomcat)来实现对事务的管理。

三、事务的配置、创建和使用(附:源码解析)

3.1 第一步,mybatis-config.xml中配置

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

在这里插入图片描述

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

3.2 第二步,创建事务工厂

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

3.2.1 创建事务工厂三步骤

创建事务工厂的过程:
parse()方法概述XMLConfigBuilder类中,parse()在mybatis初始化的时候,会从XPathParser中取出 节点对应的Node对象,然后解析此Node节点的子Node,都设置到configuration类对象中,最后返回configuration对象。
第一步,parse()方法调用parseConfiguration()方法
parseConfiguration()方法内部:解析configuration下的子节点,其中包括environments节点
第二步,parseConfiguration()方法调用environmentsElement()方法
environmentsElement()方法内部:解析environments节点下面的子节点
第三步,environmentsElement()方法调用transactionManagerElement()方法和dataSourceElement()方法
transactionManagerElement()内部:解析transactionManager节点
dataSourceElement()解析dataSource节点,然后通过反射方法构建TransactionFactory

3.2.2 第三步的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.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.解析节点,决定创建什么类型的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.3 第三步,创建事务Transaction(TransactionFactory及其两个实现类的源码解析)

通过事务工厂TransactionFactory很容易获取到Transaction对象实例。我们以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,看它们到底是怎样实现事务管理的。

举一反三:
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)

3.4 JdbcTransaction源码解析

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

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

JdbcTransaction直接使用JDBC的提交commit和回滚rollback事务管理机制。

JdbcTransaction的事务提交、事务回滚、事务关闭都是通过调用connection中的方法来完成的。在这里插入图片描述

3.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()方法完成三件事,设置类的connection变量、设置隔离级别(如果类的level变量不为null,通过类的level变量设置隔离级别,这里是通过JdbcTransaction类设置,因为这个隔离级别就是在JdbcTransaction类中使用的,作为commit和rollback的判断依据)、设置自动提交(底层还是使用connection去设置)

3.4.3 忽略commit和rollback(如果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();
    }   } 

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

 /**
 * 三大功能之一 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);
}   }

3.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)设置是否自动提交
}

3.5 ManagedTransaction源码解析

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

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

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

commit()+rollback()

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

close()

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

3.5.2 getConnection()和openConnection()逻辑

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

// 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());
    }
  }

3.5.3 忽略commit和rollback操作

忽略所有的commit和rollback操作

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

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

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

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

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

3.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操作都是无效的。

四、面试金手指(要记忆的东西)

金手指1:Mybatis事务的两点(数据库事务到Mybatis事务、MyBatis事务的两种形式)

小结两点:
第一,从数据库事务到Mybatis事务:
对数据库的事务而言,应该具有以下几点:创建(create)、提交(commit)、回滚(rollback)、关闭(close)
MyBatis中将对事务的处理封装到Transaction接口中,该接口可以完成对事务的创建(create)、提交(commit)、回滚(rollback)、关闭(close)。
第二,MyBatis的事务管理分为两种形式,即Transaction接口两个实现类(JdbcTransaction和ManagedTransaction):
(1)使用JDBC的事务管理机制:即利用java.sql.Connection对象完成对事务的提交(commit())、回滚(rollback())、关闭(close())等;
(2)使用MANAGED的事务管理机制:这种机制MyBatis自身不会去实现事务管理,而是让程序的容器如(JBOSS,Weblogic、Tomcat)来实现对事务的管理。

金手指2:mybatis-config.xml中配置

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

金手指3:创建事务工程JdbcTransactionFactory

创建事务工厂的过程:
parse()方法概述XMLConfigBuilder类中,parse()在mybatis初始化的时候,会从XPathParser中取出 节点对应的Node对象,然后解析此Node节点的子Node,都设置到configuration类对象中,最后返回configuration对象。
第一步,parse()方法调用parseConfiguration()方法
parseConfiguration()方法内部:解析configuration下的子节点,其中包括environments节点,该方法结果:类变量configuration完全被设置好
第二步,parseConfiguration()方法调用environmentsElement()方法
environmentsElement()方法内部:解析environments节点下面的子节点,该方法结果:transactionManager和dataSource拼接到environment,设置configuration
第三步,environmentsElement()方法调用transactionManagerElement()方法和dataSourceElement()方法
transactionManagerElement()内部:解析transactionManager节点
dataSourceElement()解析dataSource节点,该方法结果:通过反射方法构建TransactionFactory

金手指4:创建事务JdbcTransaction(记住下面三个)

4.1 举一反三:
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);
}

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

4.3 举一反三,整个事务创建过程涉及的类与接口
XMLConfigBuilder类
JdbcTransactionFactory(TransactionFactory)
ManagedTransactionFactory(TransactionFactory)
JdbcTransaction(Transaction)
ManagedTransaction(Transaction)

金手指5:JdbcTransaction和ManagedTransaction的操作与源码

直接看上面的,记住五点就好
1、commit()+rollback()+close()的调用
2、getConnection()和openConnection()的逻辑
3、自动提交,忽略commit()+rollback()
4、close()逻辑
5、JdbcTransaction/ManagedTransaction中的属性

五、小结

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

天天打码,天天进步!!!

©️2020 CSDN 皮肤主题: 终极编程指南 设计师:CSDN官方博客 返回首页