Spring Boot中事务回滚后持久化异常详情的实现方案

原代码的核心问题是整个循环处于同一个事务中，单个Item处理失败时无法独立回滚，且错误日志会和主事务绑定，可能被回滚。要实现需求，需让每个Item的业务处理和错误日志保存都在独立事务中。

核心思路 #

• 移除主循环方法的事务注解，避免整个循环共享一个大事务。
• 为单个Item的业务处理方法添加@Transactional(propagation = Propagation.REQUIRES_NEW)，确保每次调用开启新事务，失败仅回滚当前Item的事务。
• 为错误日志保存方法也添加@Transactional(propagation = Propagation.REQUIRES_NEW)，保证异常信息的持久化不受其他事务回滚影响。

规范实现（拆分Bean，推荐） #

拆分职责到不同Spring Bean，符合单一职责原则，同时确保事务注解生效：

@Service
public class ItemProcessor {

    private final ItemService itemService;
    private final ErrorLogService errorLogService;

    // 构造注入（Spring 4.3+支持无@Autowired的构造注入）
    public ItemProcessor(ItemService itemService, ErrorLogService errorLogService) {
        this.itemService = itemService;
        this.errorLogService = errorLogService;
    }

    // 主循环无事务注解，每个Item的处理独立
    public void processBatch(List<Item> items) {
        for (Item item : items) {
            try {
                itemService.processSingleItem(item);
            } catch (Exception e) {
                errorLogService.recordError(item, e);
            }
        }
    }
}

@Service
public class ItemService {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processSingleItem(Item item) throws Exception {
        // 此处编写Item的业务逻辑（如持久化到数据库）
    }
}

@Service
public class ErrorLogService {

    private final ErrorRepo errorRepo;

    public ErrorLogService(ErrorRepo errorRepo) {
        this.errorRepo = errorRepo;
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void recordError(Item item, Exception e) {
        ErrorData errorData = new ErrorData(item.getId(), e.getMessage());
        errorRepo.save(errorData);
    }
}

代码说明 #

• ItemService.processSingleItem：用REQUIRES_NEW传播属性，每次调用都会创建全新事务。若抛出异常，仅回滚当前Item的业务操作，不影响其他Item和错误日志的事务。
• ErrorLogService.recordError：同样使用REQUIRES_NEW，确保错误日志的保存操作在独立事务中执行，即使前面的Item事务回滚，异常信息依然会被持久化。
• 主方法processBatch无事务注解，循环调用两个独立事务的方法，实现每个Item的事务隔离。

自调用实现（不拆分Bean的场景） #

如果不想拆分Bean，可通过Spring AOP代理实现自调用，前提是开启代理暴露：

1. 先在Spring配置类添加注解：

@Configuration
@EnableAspectJAutoProxy(exposeProxy = true) // 开启代理对象暴露
public class AppConfig {
    // 其他配置
}

2. 修改原服务类：

@Service
public class Test {

    private final ErrorRepo errorRepo;

    public Test(ErrorRepo errorRepo) {
        this.errorRepo = errorRepo;
    }

    // 主循环无事务注解
    public void startTxn(List<Item> items) {
        for (Item item : items) {
            try {
                // 通过代理对象调用方法，触发事务切面
                ((Test) AopContext.currentProxy()).processItem(item);
            } catch (Exception e) {
                ((Test) AopContext.currentProxy()).saveErrorDetails(item, e);
            }
        }
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processItem(Item item) throws Exception {
        // 业务逻辑
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveErrorDetails(Item item, Exception e) {
        ErrorData errorData = new ErrorData(item.getId(), e.getMessage());
        errorRepo.save(errorData);
    }
}

注意事项 #

• 必须通过AopContext.currentProxy()获取代理对象并调用方法，否则Spring事务切面不会生效（直接调用类内部方法不会经过代理）。
• 此方式虽能实现需求，但代码耦合度较高，不如拆分Bean的方式清晰。

关键事务属性说明 #

Propagation.REQUIRES_NEW的核心特性：

• 每次调用都会创建一个新的事务。
• 如果当前线程已有活跃事务，会将原事务挂起，待新事务完成后再恢复原事务。
• 新事务的提交/回滚与原事务完全独立，确保单个Item的失败不会影响其他操作。

内容的提问来源于stack exchange，提问作者Pushpak