Java代码设置数据库隔离级别

https://www.bilibili.com/video/BV1eJ411c7rf?p=41

验证Java代码中事务隔离级别为 READ-UNCOMMITTED 的情况

    @Test
    public void testTransactionSelect() throws Exception {
        Connection conn = JDBCUtils.getConnection();
        /*
        获取当前连接的隔离级别
        int TRANSACTION_NONE             = 0;
        int TRANSACTION_READ_UNCOMMITTED = 1;
        int TRANSACTION_READ_COMMITTED   = 2;
        int TRANSACTION_REPEATABLE_READ  = 4;
        int TRANSACTION_SERIALIZABLE     = 8;
         */
        System.out.printf("conn.getTransactionIsolation():%d\n", conn.getTransactionIsolation());

        //设置禁用自动提交
        conn.setAutoCommit(false);
        String sql = "select user, password, balance from user_table where user = ?";
        User user = getInstance(conn, User.class, sql, "AA");
        System.out.println(user);
    }

    @Test
    public void testTransactionUpdate() throws Exception {
        Connection conn = JDBCUtils.getConnection();
        conn.setAutoCommit(false);
        String sql = "update user_table set balance = ? where user = ?";
        update(conn, sql, 5000, "AA");
        TimeUnit.SECONDS.sleep(15);
    }


    //通用的查询操作，用于返回数据表中的一条记录（version 2.0；考虑上事务）
    public <T> T getInstance(Connection conn, Class<T> clazz, String sql, Object... args) {
        T t = null;

        PreparedStatement ps = null;
        ResultSet rs = null;

        Map<String, Field> fieldMap = new HashMap<>();
        for (Field declaredField : clazz.getDeclaredFields()) {
            fieldMap.put(declaredField.getName(), declaredField);
        }

        try {

            ps = conn.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            //执行获取结果集
            rs = ps.executeQuery();

            //获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();

            int columnCount = rsmd.getColumnCount();

            if (rs.next()) {

                t = clazz.newInstance();

                for (int i = 0; i < columnCount; i++) {
                    //获取每个列的列值：通过ResultSet
                    Object value = rs.getObject(i + 1);

                    //获取每个列的列名：通过ResultSetMetaData
                    //获取列的列名：getColumnName() --不推荐使用
                    //获取列的别名：getColumnLabel()
                    String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);
//                    System.out.printf("columnName:%s, columnLabel:%s\n", columnName, columnLabel);

                    //通过反射，将对象指定名 columnName 的属性赋值为指定的值 columnValue
//                    Field field = Order.class.getDeclaredField(columnName);

                    if (fieldMap.containsKey(columnLabel)) {
                        Field field = clazz.getDeclaredField(columnLabel);
                        field.setAccessible(true);
                        field.set(t, value);
                    }
                }
                //获取每个列的列名

            }//end if

        } catch (SQLException e) {
            throw new RuntimeException(e);

        } catch (Exception e) {
            throw new RuntimeException(e);

        } finally {
            JDBCUtils.closeResource(null, ps, rs);

        }

        return t;

    }

1. 先运行 testTransactionUpdate 方法；
2. 再运行 testTransactionSelect 方法，控制台显示：

   conn.getTransactionIsolation():1
   User{user='AA', password='123456', balance=5000}
   

3. 等待 testTransactionUpdate 中：

   TimeUnit.SECONDS.sleep(15);
   

   休眠结束，再运行一次 testTransactionSelect 方法：

   conn.getTransactionIsolation():1
   User{user='AA', password='123456', balance=4000}
   

因为现在数据库中全局事务隔离级别为 READ-UNCOMMITTED（读未提交）；

所以在 testTransactionSelect 第一次执行时能查询到 testTransactionUpdate 中 update 但未提交的数据（脏读）；

但因为 testTransactionUpdate 在休眠之后没有进行事务提交、自动回滚了事务，所以 balance回滚为了 update 为 5000之前的 4000；

这时 第二次运行 testTransactionSelect 进行查询得到的数据就又变成了 4000。

验证Java代码中修改事务的隔离级别为 READ-COMMITTED 时的情况

    @Test
    public void testTransactionSelect() throws Exception {
        Connection conn = JDBCUtils.getConnection();
        /*
        获取当前连接的隔离级别
        int TRANSACTION_NONE             = 0;
        int TRANSACTION_READ_UNCOMMITTED = 1;
        int TRANSACTION_READ_COMMITTED   = 2;
        int TRANSACTION_REPEATABLE_READ  = 4;
        int TRANSACTION_SERIALIZABLE     = 8;
         */
        System.out.printf("conn.getTransactionIsolation():%d\n", conn.getTransactionIsolation());

        //设置事务的隔离级别为读已提交
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

        //设置禁用自动提交
        conn.setAutoCommit(false);
        String sql = "select user, password, balance from user_table where user = ?";
        User user = getInstance(conn, User.class, sql, "AA");
        System.out.println(user);
    }

• 首先，第一次运行 testTransactionSelect 查看数据：

  conn.getTransactionIsolation():1
  conn.getTransactionIsolation():2
  User{user='AA', password='123456', balance=4000}
  

• 然后，运行 testTransactionUpdate 进行数据更新，但不提交事务：

      @Test
      public void testTransactionUpdate() throws Exception {
          Connection conn = JDBCUtils.getConnection();
          System.out.printf("conn.getTransactionIsolation():%d\n", conn.getTransactionIsolation());
          conn.setAutoCommit(false);
          String sql = "update user_table set balance = ? where user = ?";
          update(conn, sql, 5000, "AA");
          TimeUnit.SECONDS.sleep(15);
          System.out.println("修改结束");
      }
  

  conn.getTransactionIsolation():1
  

• 之后，再第二次运行 testTransactionSelect 查看数据：

  conn.getTransactionIsolation():1
  conn.getTransactionIsolation():2
  User{user='AA', password='123456', balance=4000}
  

这次因为在 testTransactionSelect 中将事务隔离级别设置为了 READ COMMITTED（读已提交）；

所以在 testTransactionSelect 第二次执行时就不会查询到 testTransactionUpdate 中 update 但未提交的数据（避免了脏读的情况发生）；

https://github.com/jihch/jdbc_2/blob/main/src/main/java/io/github/jihch/transaction/TransactionTest.java