Java中事务的传播机制和隔离级别

不念不忘少年蓝@ 2024-03-22 15:25 43阅读 0赞

## 一、传播机制 ##

Spring事务的传播机制是指在方法调用链中，对于已经开启的事务以及后续子方法如何处理事务。Spring框架提供了7种传播行为来控制事务的传播过程，分别为：

1.  PROPAGATION\_REQUIRED：默认传播行为，当前有事务，则沿用当前事务，不存在则创建新事务。
2.  PROPAGATION\_REQUIRES\_NEW：将当前事务挂起，创建一个新的事务进行处理，当前方法执行结束，再将新事务提交或回滚。
3.  PROPAGATION\_NESTED：嵌套事务，如果没有上级事务，那么和PROPAGATION\_REQUIRED一样，否则在上级事务的控制下进行提交或回滚。
4.  PROPAGATION\_SUPPORTS：支持当前事务，有事务则用，没有事务则不用。
5.  PROPAGATION\_NOT\_SUPPORTED：不支持当前事务，不使用事务处理逻辑。
6.  PROPAGATION\_MANDATORY：强制当前事务，必须在某个事务内部执行，否则将抛出异常。
7.  PROPAGATION\_NEVER：绝不使用当前事务，不使用事务处理逻辑，如果某个方法已经在事务中被创建，将抛出异常。

下面是一些具体的例子，来解释Spring事务传播行为的使用：

@Service
    public class UserServiceImpl implements UserService {
        
        @Autowired
        private UserDao userDao;
    
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void addRequired(User user) {
        
            userDao.addUser(user);
            // 继续调用其他方法，传播方式为REQUIRED
            addRequiredOther(user);
        }
    
        private void addRequiredOther(User user) {
        
            userDao.addOtherUser(user);
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void addRequiresNew(User user) {
        
            userDao.addUser(user);
            // 继续调用其他方法，传播方式为REQUIRES_NEW
            addRequiresNewOther(user);
        }
    
        private void addRequiresNewOther(User user) {
        
            userDao.addOtherUser(user);
        }
    
        @Override
        @Transactional(propagation = Propagation.NESTED)
        public void addNested(User user) {
        
            userDao.addUser(user);
            // 继续调用其他方法，传播方式为NESTED
            addNestedOther(user);
        }
    
        private void addNestedOther(User user) {
        
            userDao.addOtherUser(user);
        }
    }

在上面的代码中，addRequired方法、addRequiresNew方法和addNested方法的传播行为分别为REQUIRED、REQUIRES\_NEW和NESTED。当执行addRequired方法时，如果外围没有事务，它会自己创建一个事务并使用，如果外围已经存在了一个事务，它就加入到这个事务中并与外围事务一同提交或回滚。当执行addRequiresNew方法时，始终创建新的事务，它不会受外围事务的影响。当执行addNested方法时，如果外围存在事务，它将会在嵌套的事务中运行，并受到外围事务的控制，但是它也可以独立提交或回滚这个嵌套事务。

在使用Spring事务传播行为时，需要根据业务需求和场景选择合适的传播行为，以避免事务失效或其他不必要的问题。

## 二、隔离级别 ##

关系型数据库中，事务的隔离级别是指在并发访问下，对于不同的事务之间能否看到彼此的数据变化。常见的四种隔离级别分别是：

1.  读未提交（Read uncommitted）：一个事务可以读取到其他未提交事务的数据修改。
2.  读已提交（Read committed）：一个事务只能读取到已经提交的数据，无法读取到其他事务未提交的数据。
3.  可重复读（Repeatable read）：一个事务只能读取到已经提交的数据，并且在该事务中多次读取同一数据时，始终保证读取到的是同一份数据版本。
4.  串行化（Serializable）：所有的并发操作都须按照某种顺序串行执行。即每个事务都是在其他事务执行完之后才能执行。

隔离级别越高，事务并发性越弱，但是数据一致性越高。在选择隔离级别时，需要根据具体场景的并发量、数据一致性要求以及数据库性能等因素来选择。

以下是使用Java编写的一个简单的示例程序，演示事务隔离级别的不同影响：

import java.sql.*;
    
    public class TransactionExample {
        
        public static void main(String[] args) throws Exception {
        
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useSSL=false", "root", "123456");
    
            // 关闭自动提交事务
            conn.setAutoCommit(false);
    
            // 设置事务隔离级别为读未提交
            conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
    
            // 执行查询
            System.out.println("查询结果1：");
            executeQuery(conn);
            System.out.println("******************************");
    
            // 开启一个新的线程执行数据修改操作
            new Thread(() -> {
        
                try {
        
                    Connection conn2 = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useSSL=false", "root", "123456");
                    conn2.setAutoCommit(false);
                    conn2.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
                    Statement stmt2 = conn2.createStatement();
                    stmt2.executeUpdate("update t_user set balance = balance + 50 where id = 1");
                    conn2.commit();
                    System.out.println("线程2执行成功！");
                    conn2.close();
                } catch (SQLException e) {
        
                    e.printStackTrace();
                }
            }).start();
    
            // 等待线程执行完成
            Thread.sleep(2000);
    
            // 再次执行查询
            System.out.println("查询结果2：");
            executeQuery(conn);
            System.out.println("******************************");
    
            // 回滚事务并关闭连接
            conn.rollback();
            conn.close();
        }
    
        private static void executeQuery(Connection conn) throws SQLException {
        
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("select * from t_user where id = 1");
            while (rs.next()) {
        
                System.out.println(rs.getString("name") + ", " + rs.getDouble("balance"));
            }
            rs.close();
            stmt.close();
        }
    }

上述示例程序演示了在事务隔离级别为“读未提交”时，一个事务可以读取到另一个未提交事务的修改。在上述程序中，开启了一个新的线程修改了数据库中的数据，然后主线程又查询了一次数据库中的数据，可以看到主线程读取到的数据已经包含了新的修改。

注：示例程序仅为演示事务隔离级别的效果，并不符合实际应用开发的规范，实际应用开发中需要注意事务的提交和回滚操作，并选择合适的隔离级别。