跳至主要內容

事务管理

yykygcd2026/1/15大约 3 分钟

事务管理

声明式事务

@Transactional 注解

@Service
public class UserService {
    
    @Transactional
    public void createUser(User user) {
        userDao.insert(user);
        accountDao.insert(new Account(user.getId()));
    }
}

注解属性

属性说明默认值
propagation传播行为REQUIRED
isolation隔离级别DEFAULT
timeout超时时间（秒）-1（不超时）
readOnly是否只读false
rollbackFor回滚异常类型RuntimeException
noRollbackFor不回滚异常类型-
@Transactional(
    propagation = Propagation.REQUIRED,
    isolation = Isolation.READ_COMMITTED,
    timeout = 30,
    readOnly = false,
    rollbackFor = Exception.class
)
public void updateUser(User user) {
    // ...
}

事务传播行为

传播行为说明
REQUIRED有事务则加入，没有则新建（默认）
SUPPORTS有事务则加入，没有则非事务执行
MANDATORY有事务则加入，没有则抛异常
REQUIRES_NEW新建事务，挂起当前事务
NOT_SUPPORTED非事务执行，挂起当前事务
NEVER非事务执行，有事务则抛异常
NESTED有事务则嵌套执行，没有则新建

REQUIRED（默认）

@Transactional
public void methodA() {
    // 开启事务 A
    methodB();  // 加入事务 A
}

@Transactional
public void methodB() {
    // 使用事务 A
}

REQUIRES_NEW

@Transactional
public void methodA() {
    // 开启事务 A
    methodB();  // 挂起事务 A，开启事务 B
    // 恢复事务 A
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB() {
    // 使用事务 B
}

NESTED

@Transactional
public void methodA() {
    // 开启事务 A
    try {
        methodB();  // 创建保存点，嵌套事务
    } catch (Exception e) {
        // methodB 回滚到保存点，methodA 可以继续
    }
}

@Transactional(propagation = Propagation.NESTED)
public void methodB() {
    // 嵌套事务
}

REQUIRES_NEW vs NESTED

特性REQUIRES_NEWNESTED
事务关系独立事务嵌套事务
外层回滚内层不回滚内层回滚
内层回滚外层不回滚外层可选择是否回滚
实现方式新建连接保存点

事务隔离级别

隔离级别说明
DEFAULT使用数据库默认隔离级别
READ_UNCOMMITTED读未提交
READ_COMMITTED读已提交
REPEATABLE_READ可重复读
SERIALIZABLE串行化
@Transactional(isolation = Isolation.READ_COMMITTED)
public void updateUser(User user) {
    // ...
}

事务回滚

默认回滚规则

  • RuntimeException 和 Error 回滚
  • 检查异常（Exception）不回滚

自定义回滚规则

// 指定回滚异常
@Transactional(rollbackFor = Exception.class)
public void method1() throws Exception {
    // 所有异常都回滚
}

// 指定不回滚异常
@Transactional(noRollbackFor = BusinessException.class)
public void method2() {
    // BusinessException 不回滚
}

手动回滚

@Transactional
public void method() {
    try {
        // 业务逻辑
    } catch (Exception e) {
        // 手动标记回滚
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

事务失效场景

1. 方法不是 public

@Transactional
private void method() {  // 事务失效
    // ...
}

2. 自调用

@Service
public class UserService {
    
    public void methodA() {
        methodB();  // 事务失效，直接调用不走代理
    }
    
    @Transactional
    public void methodB() {
        // ...
    }
}

3. 异常被捕获

@Transactional
public void method() {
    try {
        // 业务逻辑
        throw new RuntimeException();
    } catch (Exception e) {
        // 异常被捕获，事务不回滚
        log.error("error", e);
    }
}

4. 抛出检查异常

@Transactional
public void method() throws Exception {
    // 抛出检查异常，默认不回滚
    throw new Exception();
}

// 解决方案
@Transactional(rollbackFor = Exception.class)
public void method() throws Exception {
    throw new Exception();
}

5. 数据库不支持事务

MyISAM 引擎不支持事务。

6. 未被 Spring 管理

// 没有 @Service 注解，不是 Spring Bean
public class UserService {
    @Transactional
    public void method() {
        // 事务失效
    }
}

7. 多线程

@Transactional
public void method() {
    new Thread(() -> {
        // 新线程，不在同一个事务中
        userDao.insert(user);
    }).start();
}

编程式事务

TransactionTemplate

@Service
public class UserService {
    
    @Autowired
    private TransactionTemplate transactionTemplate;
    
    public void createUser(User user) {
        transactionTemplate.execute(status -> {
            try {
                userDao.insert(user);
                accountDao.insert(new Account(user.getId()));
                return true;
            } catch (Exception e) {
                status.setRollbackOnly();
                return false;
            }
        });
    }
}

PlatformTransactionManager

@Service
public class UserService {
    
    @Autowired
    private PlatformTransactionManager transactionManager;
    
    public void createUser(User user) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            userDao.insert(user);
            accountDao.insert(new Account(user.getId()));
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }
    }
}

分布式事务

常见方案

方案说明
2PC两阶段提交
TCCTry-Confirm-Cancel
本地消息表基于消息队列
Saga长事务拆分
Seata阿里开源分布式事务框架

Seata 示例

@GlobalTransactional
public void purchase(String userId, String commodityCode, int count) {
    // 扣减库存
    storageService.deduct(commodityCode, count);
    // 创建订单
    orderService.create(userId, commodityCode, count);
}
技术文档
Copyright © 2026 yykygcd