Mybatis深入之事务管理

Mybatis之事务管理

简单介绍

Mybatis的事务管理分为两种JdbcTransaction。ManagedTransaction。

当中JdbcTransaction仅仅是对数据库连接Connection的一个包装、内部管理数据库事务还是调用Connection的提交、回滚等事务操作方法。ManagedTransaction更直接、什么也没有做。直接将事务交给外部容器管理。

Mybatis事务管理相关类结构图

类概览：

类UML图（典型的简单工厂模式来创建Transaction）：

  • Transaction 封装事务管理方法的接口
  • TransactionFactory 抽象事务工厂生产方法
  • JdbcTransactionFactory实现TransactionFactory、用于生产JdbcTransaction的工厂类
  • ManagedTransactionFactory实现TransactionFactory、用于生产ManagedTransaction的工厂类
  • JdbcTransaction实现Transaction、仅仅是对事务进行了一层包装、实际调用数据库连接Connection的事务管理方法
  • ManagedTransaction 实现Transaction没有对数据库连接做不论什么事务处理、交由外部容器管理

源代码事务

事务配置

Mybatis中关于事务的配置是通过<transaction type="xx"/>来指定的。配置例如以下：

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
  • type为”JDBC”时、使用JdbcTransaction管理事务。

  • type为”managed”时、使用ManagedTransaction管理事务（也就是交由外部容器管理）

    Mybatis深入之初始化过程中知道配置文件怎样解析的、当中关于事务方面的解析：

  private void environmentsElement(XNode context) throws Exception {
          //仅仅关注事务部分...
          TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
          ...
  }
  private TransactionFactory transactionManagerElement(XNode context) throws Exception {
    if (context != null) {
      String type = context.getStringAttribute("type");
      Properties props = context.getChildrenAsProperties();
      TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
      factory.setProperties(props);
      return factory;
    }
    throw new BuilderException("Environment declaration requires a TransactionFactory.");
  }

    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
  • 重点在于依据type类型推断实例化何种TransactionFactory
  • 前面已经知道Mybatis两种事务配置的方式、这里使用的jdbc类型的事务
  • 上一篇分析DataSource实例化过程中有一段是关于依据DataSource的type来获取何种Factory的、这里原理同样
  • 通过TypeAliasRegistry依据type=’JDBC’来获取TransactionFactory实现类JdbcTransactionFactory

关键在于JdbcTransactionFactory通过newInstance()使用无參构造函数时做了什么工作

public class JdbcTransactionFactory implements TransactionFactory {

  public void setProperties(Properties props) {
  }

  public Transaction newTransaction(Connection conn) {
    return new JdbcTransaction(conn);
  }

  public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
    return new JdbcTransaction(ds, level, autoCommit);
  }
}
  • JdbcTransactionFactory默认无參构造方法被调用
  • setProperties没有做不论什么实质性处理
  • 对照ManagedTransactionFactory不再贴代码

以下就是获取具有事务特性的数据库连接了

JdbcTransaction：

  public Transaction newTransaction(Connection conn) {
    return new JdbcTransaction(conn);
  }

ManagedTransaction：

  public Transaction newTransaction(Connection conn) {
    return new ManagedTransaction(conn, closeConnection);
  }
  • 两者都是通过Connection来创建详细的实例

JdbcTransaction：

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;
  }

  public void commit() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) {
      if (log.isDebugEnabled()) {
        log.debug("Committing JDBC Connection [" + connection + "]");
      }
      connection.commit();
    }
  }

  public void rollback() throws SQLException {
    if (connection != null && !connection.getAutoCommit()) {
      if (log.isDebugEnabled()) {
        log.debug("Rolling back JDBC Connection [" + connection + "]");
      }
      connection.rollback();
    }
  }

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

}
  • 从源代码中可知、JdbcTransaction怎样管理事务的、如前面所说调用DataSource事务操作方法。

  • 而且对select不进行事务控制
  • 当使用DataSource创建数据库连接时、数据库的事务隔离级别使用DataSource默认的事务隔离级别
  • 如需指定事务的隔离级别、必须手动创建JdbcTransaction(调用还有一个构造函数)
  • 关于事务隔离级别会在补充中有

ManagedTransaction：

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

}
  • 重点看一下commit() rollback()方法，没有方法体。验证前面其关于事务的管理方式

到这里事务暂时告一段落、一般在使用时会与spring结合、将数据库连接、事务管理都交由spring管理。

补充

数据库隔离级别：

先对不同隔离级别涉及到的名词解释：
?   脏读: 对于两个事物 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是暂时且无效的.
?   不可反复读: 对于两个事物 T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了.
?   幻读: 对于两个事物 T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 假设 T1 再次读取同一个表, 就会多出几

详细的隔离级别定义：


READ UNCOMMITTED(读未提交数据)    同意事务读取未被其它事务提交的变更，脏读、不可反复读和幻读的问题都会出现  

READ COMMITED(读已提交数据)   仅仅同意事务读取已经被其它事务提交的变更。能够避免脏读，但不可反复读和幻读问题仍然会出现  

REPEATABLE READ(可反复读)   确保事务能够多次从一个字段中读取同样的值，在这个事务持续期间，禁止其它事务对这个字段进行更新。能够避免脏读和不可反复读，但幻读的问题依旧存在  

SERIALIZABLE(串行化)   确保事务能够从一个表中读取同样的行。在这个事务持续期间。禁止其它事务对该表运行插入、更新和删除操作，全部并发问题都能够避免。但性能十分低  

Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE. Oracle 默认的事务隔离级别为: READ COMMITED
Mysql 支持 4 中事务隔离级别. Mysql 默认的事务隔离级别为: REPEATABLE READ

很多其它内容：Mybatis 文件夹

时间： 2024-10-21 13:30:10

Mybatis深入之事务管理的相关文章

mybatis源码分析(四) mybatis与spring事务管理分析

mybatis源码分析(四) mybatis与spring事务管理分析 一丶从jdbc的角度理解什么是事务 从mysql获取一个连接之后, 默认是自动提交, 即执行完sql之后, 就会提交事务. 这种事务的范围是一条sql语句. 将该连接设置非自动提交, 可以执行多条sql语句, 然后由程序决定是提交事务, 还是回滚事务. 这也是我们常说的事务. Connection connection = dataSource.getConnection(); // connection.setTransa

SpringMVC、MyBatis声明式事务管理

采用的基本搭建环境:SpringMVC.MyBatis.MySQL.tomcat         Spring事务管理分解了传统的全局事务管理和本地事务管理的劣势,使得在任何环境中都可以使用统一的事务管理模型,你可以写一次代码,然后在不同的环境从你的代码里面配置不同的事务管理策略,Spring提供两种事务管理策略:一种是声明式事务管理策略,另一种是编程式事务管理策略,这里主要介绍声明式事务管理策略         由于采用的是SpringMVC. MyBatis,故统一采用了标注来声明Servi

springmvc mybatis 声明式事务管理回滚失效,(checked回滚)捕捉异常,传输错误信息

一.知识点及问题 后端框架: Spring .Spring mvc .mybatis 业务需求: client先从服务端获取用户大量信息到client,编辑完毕之后统一Post至服务端,对于数据的改动要么全成功,要么全失败,所以须要使用事务支持. 问题: 配置Spring声明式事务,运行中出现异常未回滚.从网上查询得到一開始是自己的配置出了问题,因为配置文件的载入顺序决定了容器的载入顺序导致Spring事务没有起作用. 详情例如以下: 因为採用的是SpringMVC. MyBatis,故统一採用

Spring整合mybatis时使用事务管理器

异常报告:java.lang.AbstractMethodError: org.mybatis.spring.transaction.SpringManagedTransaction.getTimeout()Ljava/lang/Integer; 可以尝试更换更高版本的mybatis-spring.xxx.jar包 原文地址:https://www.cnblogs.com/SysoCjs/p/9460514.html

SSM框架中以注解形式实现事务管理

上一篇博文<SSM三大框架整合详细教程>详细说了如何整合Spring.SpringMVC和MyBatis这三大框架.但是没有说到如何配置mybatis的事务管理,实现开发中,事务是必不可少的.本篇作为对上一篇的补充,说明在SSM框架中如何使用注解的形式进行事务管理. 什么是事务? 在编写业务的过程中,会需要进行事务处理,当需要执行多条插入语句时,如果前几条成功,而最后一条失败,那么我们需要回滚数据库操作,保持数据的一致性和完整性,此时,就需要利用DB的事务处理.事务是恢复和并发控制的基本单位.

SSM框架——以注解形式实现事务管理

上一篇博文<SSM三大框架整合详细教程>详细说了如何整合Spring.SpringMVC和MyBatis这三大框架.但是没有说到如何配置mybatis的事务管理,在编写业务的过程中,会需要进行事务处理,当需要执行多条插入语句时,如果前几条成功,而最后一条失败,那么我们需要回滚数据库操作,保持数据的一致性和完整性,此时,就需要利用DB的事务处理.事务是恢复和并发控制的基本单位. 简单来说,所谓的事务,是一个操作序列,这些操作要么都执行,要么都不执行,它是一个不可分割的工作单位. 事务应该具有4个

spring与mybatis整合及事务控制

一. 简介 本文将会使用spring整合mybatis, 并添加事务管理, 以此为记, 方便以后查阅. 二. 例子 1. 代码结构图: 2. 建表语句: DROP DATABASE test; CREATE DATABASE test; USE test; CREATE TABLE USER( id VARCHAR(36) PRIMARY KEY, username VARCHAR(64), address VARCHAR(128) ) INSERT INTO USER (id, usernam

Spring事务管理Transaction

Spring提供了许多内置事务管理器实现: DataSourceTransactionManager:位于org.springframework.jdbc.datasource包中,数据源事务管理器,提供对单个javax.sql.DataSource事务管理,用于Spring JDBC抽象框架.iBATIS或MyBatis框架的事务管理: JdoTransactionManager:位于org.springframework.orm.jdo包中,提供对单个javax.jdo.Persistenc

spring与mybatis集成和事务控制

一个. 基本介绍 本文将使用spring整合mybatis, 并加入事务管理, 以此为记, 方便以后查阅. 二. 样例 1. 代码结构图: 2. 建表语句: DROP DATABASE test; CREATE DATABASE test; USE test; CREATE TABLE USER( id VARCHAR(36) PRIMARY KEY, username VARCHAR(64), address VARCHAR(128) ) INSERT INTO USER (id, usern