深入浅出Mybatis系列(五)Mybatis事务篇

举报
西魏陶渊明 发表于 2022/09/25 00:31:18 2022/09/25
【摘要】 在学习Mysql事务开始,分为两步。一.先看下Mysql的事务级别都有什么,然后看Mysql的事务级别设置命令。及常见问题。二.JDK是如何处理数据库操作的呢? Mybatis是如何实现JDK定义的...

在学习Mysql事务开始,分为两步。一.先看下Mysql的事务级别都有什么,然后看Mysql的事务级别设置命令。及常见问题。二.JDK是如何处理数据库操作的呢? Mybatis是如何实现JDK定义的事务级别操作。

一.Mysql的事务级别及常见概念

  • MySQL事务隔离级别
事务隔离级别 脏读 不可重复读 幻读 解释
读未提交(read-uncommitted) 可以读到未提交的事物
不可重复读(read-committed) 只能读提交的事物
可重复读(repeatable-read) 事务提交前后都能读【MySql默认】
串行化(serializable) serializable时会锁表,是最安全的,也是日常开发基本不会用
  • Mysql事务设置命令

  • 读未提交
    set session transaction isolation level read uncommitted;

  • 不可重复读(读已提交的)
    set session transaction isolation level read committed;

  • 可重复读
    set session transaction isolation level repeatable read;

  • 串行化
    set session transaction isolation level serializable;

举一个例子,我做了一个事务未提交,默认情况是看不到的,当设置了读未提交sql,就可以看到了

以上这四个事务级别最不常用的是串行化,因为他是最严格的会加行锁或者表锁。当一个事务在执行查询操作,其他的连接就不允许对表进行写操作,只允许读。显然这是不满足开发的,想想一下,支付宝当一个人A在查询账单时候,其他人B就不能消费了。因为A在对账单表进行查询,B要对账单表进行修改。

最适合的是可重复读,因为只会加行级锁。当两个事务同时进行时,其中一个事务修改数据对另一个事务不会造成影响,即使修改的事务已经提交也不会对另一个事务造成影响。
(当一个事务执行中他看到的数据是不会改变的,即在一个事务中不论查询数据多少次都不会改变,即便其他人对这个数据进行了修改,也看不到,只有在当前事务提交之后,然后在查询才能看到其他人的改变,这就解决了不可重复读和脏读的问题,但是会造成幻读)

  • √: 可能出现
  • ×: 不会出现

|脏读| 不可重复读 |幻读|
—|—|—|—
|Read uncommitted| √| √| √|
|Read committed| ×| √| √|
|Repeatable read| ×| × |√|
|Serializable| ×| ×| ×|

  • 什么是不可重复读?

就是说在一个事务中,查询了多次数据,每次看到的都不一样。因为别人对数据进行了修改。

  • 事务的并发问题

1、脏读:事务A读取了事务B更新的数据,然后B回滚操作,那么A读取到的数据是脏数据

2、不可重复读:事务 A 多次读取同一数据,事务 B 在事务A多次读取的过程中,对数据作了更新并提交,导致事务A多次读取同一数据时,结果 不一致。

3、幻读:系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级,但是系统管理员B就在这个时候插入了一条具体分数的记录,当系统管理员A改结束后发现还有一条记录没有改过来,就好像发生了幻觉一样,这就叫幻读。

小结:不可重复读的和幻读很容易混淆,不可重复读侧重于修改,幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行(Repeatable read),解决幻读需要锁表

  • 事务的基本要素(ACID)

1、原子性(Atomicity):事务开始后所有操作,要么全部做完,要么全部不做,不可能停滞在中间环节。事务执行过程中出错,会回滚到事务开始前的状态,所有的操作就像没有发生一样。也就是说事务是一个不可分割的整体,就像化学中学过的原子,是物质构成的基本单位。

2、一致性(Consistency):事务开始前和结束后,数据库的完整性约束没有被破坏 。比如A向B转账,不可能A扣了钱,B却没收到。

3、隔离性(Isolation):同一时间,只允许一个事务请求同一数据,不同的事务之间彼此没有任何干扰。比如A正在从一张银行卡中取钱,在A取钱的过程结束前,B不能向这张卡转账。

4、持久性(Durability):事务完成后,事务对数据库的所有更新将被保存到数据库,不能回滚。

参考地址

二.JDK是如何处理数据库操作的呢? Mybatis是如何实现JDK定义的事务级别操作。

JDK是如何处理数据库操作的呢? 其实更直接操作MySql数据库命令一样,只不过Java进行了命令的封装,是你在调用Java方法时候就自动执行了命令,下面我们看看吧.

  1. 定义底层通用接口,实现交给框架开发者来实现。

Connection。事务级JDK已经定义好了

public interface Connection  extends Wrapper, AutoCloseable {
    /**
     * 表示不支持事务的常量。
     */
    int TRANSACTION_NONE             = 0;
   /**
     * 可读到未提交
     */
    int TRANSACTION_READ_UNCOMMITTED = 1;
    /**
     * 只能读已提交
     */
    int TRANSACTION_READ_COMMITTED   = 2;
   /**
     * 可重复读
     */
    int TRANSACTION_REPEATABLE_READ  = 4;
   /**
     * 串行化操作
     */
    int TRANSACTION_SERIALIZABLE     = 8;
   /**
     * 设置事务
     */
    void setTransactionIsolation(int level) throws SQLException;
}


  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

留给开发者自己实现,下图Mybatis中ConnectionImpl实现。在进行数据库操作前,会先执行设置事务。

JdbcTransaction如何设置事务呢?

在打开数据库连接时候设置事务

根据事务级别,执行不同的sql命令。

以上就是事务的底层实现,那么我们在带到项目中来看看,以一个数据库操作的例子来看看Mybatis的调用过程吧。

@Test
  public void transactionTest(){
    //拿到mybatis的配置文件输入流
    InputStream mapperInputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("mybatisConfig.xml");
    //SqlSessionFactoryBuilder通过XMLConfigBuilder解析器读取配置信息生成Configuration信息
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(mapperInputStream);
    SqlSession sqlSession = sqlSessionFactory.openSession(TransactionIsolationLevel.READ_COMMITTED);
    TUserMapper mapper = sqlSession.getMapper(TUserMapper.class);
    TUser tUser = new TUser();
    tUser.setId(10233);
    tUser.setName("事务测试");
    mapper.insert(tUser);
//    sqlSession.commit();
    sqlSession.rollback(true);
  }


  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

SqlSession就是数据库的会话,要想创建数据库会话,首先要打开数据库连接。由此来判断事务级别就是在SqlSessionFactory,在获取SqlSession的时候来执行sql语句的。我们看流程图

此时事务还并没有设置,只有在
SimpleExecutor执行任意数据库操作时候才会调用

@Override
  public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
      //执行事务
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.update(stmt);
    } finally {
      closeStatement(stmt);
    }
  }
 private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //JdbcTransaction打开连接。
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection, transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
  }

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

最终调用
JdbcTransaction打开连接。

以上就是Mybatis中的事务级别控制。但是这里所说的除了在学习源码时候会看到,在日常开发中不会经常看到。大部分Java的开发都是基于Spring框架之上,Spring对事务的处理有进一步的处理。Spring提出了事务传播方式的概念,这个概念怎么理解呢?

Spring的事务传播方式

前面所说的事务,是不涉及嵌套条调用的,即是不会再事务中嵌套事务调用。但是在开发中难免会遇到这种情况。
比如,一个事务在没有执行commit之前,有调用了一个事务。
那这个时候,遇到两个都有事务的方法怎么办呢,因为Spring提出了事务传播方式这个概念。

1、PROPAGATION_REQUIRED:如果当前没有事务,就创建一个新事务,如果当前存在事务,就加入该事务,该设置是最常用的设置。

2、PROPAGATION_SUPPORTS:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就以非事务执行。‘

3、PROPAGATION_MANDATORY:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就抛出异常。

4、PROPAGATION_REQUIRES_NEW:创建新事务,无论当前存不存在事务,都创建新事务。

5、PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。

6、PROPAGATION_NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。

7、PROPAGATION_NESTED:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与PROPAGATION_REQUIRED类似的操作。

eg:

当前是有事务的,如果调用方法中也有一个含有事务的接口,那么就放弃里面的事务,而加入到当前的事务

   @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, rollbackFor = Exception.class)
   public String doOpt() throws Exception {
	    ...
   }

  
 
  • 1
  • 2
  • 3
  • 4

Spring的事务传播方式的实现类

AbstractPlatformTransactionManager使用的技术手段就是代理。

其实就是set autocommit=off; 当方法执行完成无指定的异常,在进行commit;

下面我们自己来写伪代码

MyTransactional

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyTransactional {
  //传播方式
  Propagation propagation() default Propagation.REQUIRED;
  //捕捉异常
  Class<? extends Throwable>[] rollbackFor() default {};
}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

SqlSession保证每个线程一个连接实例


public class SqlSession {

  private static ThreadLocal<Connection> connections = new ThreadLocal();

  static {
    try {//注册驱动,反射方式加载
      Class.forName("com.mysql.jdbc.Driver");
    } catch (Exception e) {
    }
  }

  public SqlSession(boolean autocommit, int level) {
    try {
      String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false";
      //设置用户名
      String username = "root";
      //设置密码
      String password = "";
      //获得连接对象
      Connection con = DriverManager.getConnection(url, username, password);
      con.setAutoCommit(autocommit);
      setTransactionIsolation(level, con.createStatement());
      connections.set(con);
    } catch (Exception e) {
    }
  }


  public void execute(String sql) {
    try {
      Console.normal("执行Sql: " + sql);
//      connections.get().createStatement().execute(sql)
    } catch (Exception e) {
    }
  }

  private static void setTransactionIsolation(int level, Statement statement) throws SQLException {
    String sql;
    switch (level) {
      case 0:
        throw SQLError.createSQLException(Messages.getString("Connection.24"), null);
      case 1:
        sql = "SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED";
        break;
      case 2:
        sql = "SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED";
        break;
      case 3:
      case 5:
      case 6:
      case 7:
      default:
        throw SQLError.createSQLException(Messages.getString("Connection.25", new Object[]{level}), "S1C00", null);
      case 4:
        sql = "SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ";
        break;
      case 8:
        sql = "SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE";
    }
    Console.customerNormal("设置事务级别Sql: ", sql);
//    statement.execute(sql);
  }

  public void commit() throws Exception {
//    Connection connection = connections.get();
//    connection.commit();
    Console.customerNormal("执行提交Sql:", "commit;");
  }

  public void rollback() throws Exception {
//    Connection connection = connections.get();
//    connection.rollback();
    Console.customerNormal("设置事务级别Sql: ", "roolback");
  }

}


  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78

UserService

public interface UserService {
  void save();
}
public class UserServiceImpl implements UserService {
  SqlSession sqlSession = new SqlSession(false, 4);
  @MyTransactional(propagation = Propagation.REQUIRED, rollbackFor = ArithmeticException.class)
  public void save() {
    //执行sql1
    sqlSession.execute("select * from t");
    try {
      int i = 2 / 0;
    } catch (Exception e) {
      throw e;
    }
    //执行sql2
    sqlSession.execute("select * from t");
  }


  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

测试代码

 public static void main(String[] args) {
    
    UserService userService = new UserServiceImpl();
    //生成JDK代理
    UserService userServiceProxy = (UserService) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{UserService.class}, new InvocationHandler() {
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Method declaredMethod = userService.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());
        MyTransactional declaredAnnotation = declaredMethod.getDeclaredAnnotation(MyTransactional.class);
        Class<? extends Throwable>[] classes = declaredAnnotation.rollbackFor();
        //传播方式处理逻辑
        //.....
        Object res = null;
        try {
          res = declaredMethod.invoke(userService);
        } catch (Exception e) {
          Throwable cause = e.getCause();
          if (cause.getClass().equals(classes[0])) {
            //执行回滚
            ((UserServiceImpl) userService).sqlSession.rollback();
            return res;
          }
        }
        //执行提交
        ((UserServiceImpl) userService).sqlSession.commit();
        return res;
      }
    });
    userServiceProxy.save();
  }

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

结果

  • 成功
[设置事务级别Sql: ]: SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ
[正常]: 执行Sql: update T_USER set name = 'china' where id = 1;
[正常]: 执行Sql: update T_USER set name = '中国' where id = 1;
[执行提交Sql:]: commit;

  
 
  • 1
  • 2
  • 3
  • 4
  • 失败
[设置事务级别Sql: ]: SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ
[正常]: 执行Sql: update T_USER set name = 'china' where id = 1;
[设置事务级别Sql: ]: roolback

  
 
  • 1
  • 2
  • 3

以上就是Mybatis关于事务小编想说的。有问题可以提出,我们一起学习,如果有写错的地方或者想讨论的,希望能提出,再次感谢!

文章来源: springlearn.blog.csdn.net,作者:西魏陶渊明,版权归原作者所有,如需转载,请联系作者。

原文链接:springlearn.blog.csdn.net/article/details/89533045

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。