mybatis之事务抽象

雨点打透心脏的1/2处 2022-09-10 03:27 134阅读 0赞

## 1：相关类 ##

mybatis使用工厂设计模式对数据库事务进行了抽象，如下图：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16]  
都是在`transaction`包中，如下图：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_14_color_FFFFFF_t_70_g_se_x_16]  
我们先看下事务抽象接口`org.apache.ibatis.transaction.Transaction`，源码如下：

org.apache.ibatis.transaction.Transaction
    // 维护数据库连接，并负责其生命周期管理
    public interface Transaction { 
      // 获取数据库连接
      Connection getConnection() throws SQLException;
      // 提交内部的数据库连接
      void commit() throws SQLException;
      // 回滚内部的数据库连接
      void rollback() throws SQLException;
      // 关闭内部的数据库连接
      void close() throws SQLException;
      // 获取事务的超时时间，如果是设置了的话
      Integer getTimeout() throws SQLException;
    }

该接口有2个子类，如下：  
![在这里插入图片描述][3f2e61fd30eb4d988b9b817f7dad9d0e.png]  
关于`org.apache.ibatis.transaction.jdbc.JdbcTransaction`参考`2：JdbcTransaction`。关于`org.apache.ibatis.transaction.managed.ManagedTransaction`参考`3：ManagedTransaction`。

## 2：JdbcTransaction ##

### 2.1：构造函数 ###

源码如下：

// JDBC 数据源对象
    protected DataSource dataSource;
    // 事务隔离级别枚举对象
    // 2021-09-04 10:24:34
    protected TransactionIsolationLevel level;
    // 是否自动提交
    protected boolean autoCommit;
    
    public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) { 
      dataSource = ds;
      level = desiredLevel;
      autoCommit = desiredAutoCommit;
    }

`2021-09-04 10:24:34`处对应的是数据库的事务隔离级别，具体参考`4：数据库隔离级别`。

### 2.2：主要方法 ###

主要方法源码如下：

// 获取数据库连接
    @Override
    public Connection getConnection() throws SQLException { 
      if (connection == null) { 
        openConnection();
      }
      return connection;
    }
    
    // 提交事务
    @Override
    public void commit() throws SQLException { 
      // 连接不为null，并且不是自动才继续
      if (connection != null && !connection.getAutoCommit()) { 
        if (log.isDebugEnabled()) { 
          log.debug("Committing JDBC Connection [" + connection + "]");
        }
        // 提交事务
        connection.commit();
      }
    }
    
    // 回滚事务
    @Override
    public void rollback() throws SQLException { 
      // 连接不为空，并且不是自动提交才继续
      if (connection != null && !connection.getAutoCommit()) { 
        if (log.isDebugEnabled()) { 
          log.debug("Rolling back JDBC Connection [" + connection + "]");
        }
        // 回滚事务
        connection.rollback();
      }
    }
    
    // 关闭连接
    @Override
    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) { 
        throw new TransactionException("Error configuring AutoCommit. "
            + "Your driver may not support getAutoCommit() or setAutoCommit(). "
            + "Requested setting: " + desiredAutoCommit + ". Cause: " + e, e);
      }
    }
    
    // 将自动提交设置为true
    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) { 
        if (log.isDebugEnabled()) { 
          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(autoCommit);
    }
    
    @Override
    public Integer getTimeout() throws SQLException { 
      return null;
    }

该类对应的工厂类是`org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory`,具体参考`5.2：JdbcTransactionFactory`。

## 3：ManagedTransaction ##

源码如下：

org.apache.ibatis.transaction.managed.ManagedTransaction
    
    // 提供了管理事务周期的模板方法，让自己所在的容器管理生命周期，比如spring容器
    public class ManagedTransaction implements Transaction { 
    
      private static final Log log = LogFactory.getLog(ManagedTransaction.class);
      // 数据源对象，用于获取数据库连接
      private DataSource dataSource;
      // 事务隔离级别
      // 2021-09-05 13:34:31
      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;
      }
    
      // 打开连接
      @Override
      public Connection getConnection() throws SQLException { 
        if (this.connection == null) { 
          openConnection();
        }
        return this.connection;
      }
    
      // 提交事务模板方法，让所在容器实现
      @Override
      public void commit() throws SQLException { 
        // Does nothing
      }
    
      // 回滚事务模板方法，让所在容器实现
      @Override
      public void rollback() throws SQLException { 
        // Does nothing
      }
    
      @Override
      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());
        }
      }
    
    }

`2021-09-05 13:34:31`事务隔离级别，具体参考`4：数据库隔离级别`。该类对应的工厂类是`org.apache.ibatis.transaction.factory.ManagedTransactionFactory`,具体参考`5.3：ManagedTransactionFactory`。

## 4：数据库隔离级别 ##

源码如下：

org.apache.ibatis.session.TransactionIsolationLevel
    public enum TransactionIsolationLevel { 
      // 不支持事务 int TRANSACTION_NONE = 0;
      
      NONE(Connection.TRANSACTION_NONE),
      // 读已提交 int TRANSACTION_READ_COMMITTED = 2;
      // 不会发生脏读：读不到其它事务未提交的修改
      // 会发生幻读：读到其它事务已提交的新增或删除
      // 会发生不可重复度：读到其它事务已提交的修改
      READ_COMMITTED(Connection.TRANSACTION_READ_COMMITTED),
      // 读未提交 int TRANSACTION_READ_UNCOMMITTED = 1;
      // 会发生脏读：读到其它事务未提交的修改
      // 会发生幻读：读到其它事务已提交的数据新增或删除
      // 会发生不可重复读：读到其它事务已提交的修改
      READ_UNCOMMITTED(Connection.TRANSACTION_READ_UNCOMMITTED),
      // 可重复读 int TRANSACTION_REPEATABLE_READ = 4;
      // 不会发生脏读：读不到其它事务未提交的修改
      // 会发生幻读：读到其它事务已提交的新增或删除
      // 不会发生不可重复度：读不到其它事务已提交的修改
      REPEATABLE_READ(Connection.TRANSACTION_REPEATABLE_READ),
      // 串行化 int TRANSACTION_SERIALIZABLE = 8;
      // 此时只有一个事务在执行，因此脏读，幻读，不可重复读都不会有
      SERIALIZABLE(Connection.TRANSACTION_SERIALIZABLE);
    
      private final int level;
    
      TransactionIsolationLevel(int level) { 
        this.level = level;
      }
    
      public int getLevel() { 
        return level;
      }
    }

## 5：工厂类 ##

### 5.1：TransactionFactory ###

接口权限定名称`org.apache.ibatis.transaction.TransactionFactory`，负责定义创建相关事务实现类的规范，源码如下：

org.apache.ibatis.transaction.TransactionFactory
    
    // 创建org.apache.ibatis.transaction.Transaction实例
    public interface TransactionFactory { 
    
      // 设置用户自定义的属性信息到工厂类中
      void setProperties(Properties props);
    
      // 通过已经存在的数据库连接对象创建事务对象
      Transaction newTransaction(Connection conn);
    
      // 通过已存在的数据源对象创建事务对象
      // dataSource：数据源对象
      // level：事务隔离级别
      // autoCommit：是否自动提交
      Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit);
    
    }

其实现类如下图：  
![在这里插入图片描述][0d8fe9e18e08434b839f5d1a644d3461.png]  
其中的`JdbcTransactionFacotry`用于创建`JdbcTransaction`对象，`ManagedTransaction`用于创建`ManagedTransaction`,关于JdbcTransactionFactory具体参考`5.2：JdbcTransactionFactory`。关于ManagedTransactionFactory具体参考`5.3：ManagedTransactionFactory`。

### 5.2：JdbcTransactionFactory ###

源码如下：

// 创建JdbcTransaction对象
    public class JdbcTransactionFactory implements TransactionFactory { 
      // 不需要自定义属性
      @Override
      public void setProperties(Properties props) { 
      }
    
      @Override
      public Transaction newTransaction(Connection conn) { 
        return new JdbcTransaction(conn);
      }
    
      @Override
      public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) { 
        return new JdbcTransaction(ds, level, autoCommit);
      }
    }

### 5.3：ManagedTransactionFactory ###

源码如下：

// 创建ManagedTransactionFactory实例的工厂类
    public class ManagedTransactionFactory implements TransactionFactory { 
    
      private boolean closeConnection = true;
    
      @Override
      public void setProperties(Properties props) { 
        if (props != null) { 
          // 设置closeConnection属性
          String closeConnectionProperty = props.getProperty("closeConnection");
          if (closeConnectionProperty != null) { 
            closeConnection = Boolean.valueOf(closeConnectionProperty);
          }
        }
      }
    
      @Override
      public Transaction newTransaction(Connection conn) { 
        return new ManagedTransaction(conn, closeConnection);
      }
    
      @Override
      public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) { 
        return new ManagedTransaction(ds, level, closeConnection);
      }
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/a4d7b6c6334f4bca8a845310d01220a4.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAd2FuZzA5MDc_size_14_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/b26d9eabf7b74da099beb83187054248.png
[3f2e61fd30eb4d988b9b817f7dad9d0e.png]: /images/20220829/a10cf080f82d4ba79dfd65510ea78f08.png
[0d8fe9e18e08434b839f5d1a644d3461.png]: /images/20220829/832db40b16974fc989a38717537e76d2.png