Spring事务注解@Transactional参数详解与实战示例

public enum propagation {
    /**
     * 支持当前事务，如果不存在则新建一个（默认值）
     * 这是最常用的传播行为
     */
    required(transactiondefinition.propagation_required),
    /**
     * 支持当前事务，如果不存在则以非事务方式执行
     * 适用于不需要事务支持但可以参与现有事务的方法
     */
    supports(transactiondefinition.propagation_supports),
    /**
     * 支持当前事务，如果不存在则抛出异常
     * 强制要求必须在事务中调用
     */
    mandatory(transactiondefinition.propagation_mandatory),
    /**
     * 新建事务，如果当前存在事务则将其挂起
     * 适用于需要独立事务的子操作
     */
    requires_new(transactiondefinition.propagation_requires_new),
    /**
     * 以非事务方式执行，如果当前存在事务则将其挂起
     * 适用于不需要事务的只读操作
     */
    not_supported(transactiondefinition.propagation_not_supported),
    /**
     * 以非事务方式执行，如果当前存在事务则抛出异常
     * 强制要求不能在事务中调用
     */
    never(transactiondefinition.propagation_never),
    /**
     * 如果当前存在事务，则在嵌套事务中执行
     * 嵌套事务是外部事务的子事务，可以独立提交或回滚
     * 注意：并非所有数据源都支持嵌套事务
     */
    nested(transactiondefinition.propagation_nested)
}

@service
public class orderservice {
    @autowired
    private inventoryservice inventoryservice;
    @autowired
    private paymentservice paymentservice;
    @transactional(propagation = propagation.required)
    public void createorder(orderdto order) {
        // 创建订单记录
        orderrepository.save(order);
        try {
            // 扣减库存 - 需要独立事务，失败不影响订单创建
            inventoryservice.deductinventory(order.getproductid(), order.getquantity());
        } catch (exception e) {
            // 库存操作失败，但订单已创建，需要人工介入处理
            log.error("库存扣减失败，订单号: {}", order.getorderno(), e);
        }
        // 支付处理 - 必须与订单创建在同一个事务中
        paymentservice.processpayment(order);
    }
}
@service
class inventoryservice {
    @transactional(propagation = propagation.requires_new)
    public void deductinventory(long productid, integer quantity) {
        // 独立事务执行库存扣减
        inventoryrepository.reducestock(productid, quantity);
        // 记录库存变更日志
        inventorylogrepository.save(new inventorylog(productid, quantity));
    }
}

public enum isolation {
    /**
     * 使用底层数据源的默认隔离级别
     * mysql默认是repeatable_read，oracle默认是read_committed
     */
    default(transactiondefinition.isolation_default),
    /**
     * 读未提交 - 允许读取未提交的数据变更
     * 可能出现脏读、不可重复读和幻读
     * 性能最高，但数据一致性最差
     */
    read_uncommitted(transactiondefinition.isolation_read_uncommitted),
    /**
     * 读已提交 - 只能读取已提交的数据
     * 可以避免脏读，但可能出现不可重复读和幻读
     * 大多数数据库的默认级别
     */
    read_committed(transactiondefinition.isolation_read_committed),
    /**
     * 可重复读 - 同一事务中多次读取结果一致
     * 可以避免脏读和不可重复读，但可能出现幻读
     * mysql的默认级别（innodb通过mvcc避免了幻读）
     */
    repeatable_read(transactiondefinition.isolation_repeatable_read),
    /**
     * 串行化 - 完全串行执行事务
     * 可以避免所有并发问题，但性能最低
     * 适用于对数据一致性要求极高的场景
     */
    serializable(transactiondefinition.isolation_serializable)
}

@service
public class accountservice {
    // 场景：银行转账，需要最高级别的数据一致性
    @transactional(
        isolation = isolation.serializable,
        timeout = 30
    )
    public void transfer(transferrequest request) {
        // 检查账户余额（这里需要避免不可重复读）
        bigdecimal balance = accountrepository.getbalance(request.getfromaccount());
        if (balance.compareto(request.getamount()) < 0) {
            throw new insufficientbalanceexception("余额不足");
        }
        // 扣减转出账户金额
        accountrepository.deduct(request.getfromaccount(), request.getamount());
        // 增加转入账户金额
        accountrepository.add(request.gettoaccount(), request.getamount());
        // 记录交易流水（需要避免幻读）
        transactionrepository.save(createtransactionrecord(request));
    }
    // 场景：报表统计，对实时性要求不高但需要一致性视图
    @transactional(
        isolation = isolation.repeatable_read,
        readonly = true
    )
    public financialreport generatedailyreport(localdate date) {
        // 多次查询需要保持数据一致性
        bigdecimal totalincome = orderrepository.sumincomebydate(date);
        bigdecimal totalexpense = expenserepository.sumexpensebydate(date);
        list<transaction> transactions = transactionrepository.findbydate(date);
        return financialreport.builder()
                .date(date)
                .totalincome(totalincome)
                .totalexpense(totalexpense)
                .transactions(transactions)
                .build();
    }
}

@service
public class batchprocessingservice {
    // 批量数据处理，设置较长的超时时间
    @transactional(
        timeout = 300,  // 5分钟超时
        propagation = propagation.requires_new
    )
    public void processlargebatch(list<data> datalist) {
        // 大数据量处理操作
        datalist.foreach(data -> {
            processitem(data);
            // 每处理100条记录提交一次，避免长时间占用连接
            if (counter.get() % 100 == 0) {
                entitymanagerhelper.flushandclear();
            }
        });
    }
    // 快速查询操作，设置较短的超时时间
    @transactional(
        timeout = 5,  // 5秒超时
        readonly = true
    )
    public quickresult quicksearch(searchcriteria criteria) {
        return searchrepository.quicksearch(criteria);
    }
}

@repository
public interface userrepository extends jparepository<user, long> {
    @transactional(readonly = true)
    @query("select u from user u where u.status = 'active'")
    list<user> findallactiveusers();
    @transactional(readonly = true)
    @query("select new com.example.userdto(u.id, u.username, u.email) " +
           "from user u where u.department = :dept")
    list<userdto> findusersbydepartment(@param("dept") string department);
}
@service
public class reportservice {
    @transactional(readonly = true)
    public complexreport generatecomplexreport(reportrequest request) {
        // 多个查询操作，使用只读事务优化
        list<data> dataset1 = repository1.findbycriteria(request);
        list<data> dataset2 = repository2.findbycriteria(request);
        statistics stats = repository3.calculatestatistics(request);
        return assemblereport(dataset1, dataset2, stats);
    }
}

@service
public class orderprocessingservice {
    // 业务异常不回滚，系统异常回滚
    @transactional(
        rollbackfor = {systemexception.class, dataaccessexception.class},
        norollbackfor = {businessexception.class, validationexception.class}
    )
    public orderresult processorder(orderrequest request) {
        // 参数验证失败不触发事务回滚
        validateorder(request);
        try {
            // 业务处理
            order order = createorder(request);
            processpayment(order);
            updateinventory(order);
            // 发送通知（即使失败也不应该回滚整个事务）
            try {
                notificationservice.sendorderconfirmation(order);
            } catch (notificationexception e) {
                log.warn("订单通知发送失败，订单号: {}", order.getorderno(), e);
                // 记录通知失败，但不回滚事务
                notificationlogrepository.savefailurelog(order, e);
            }
            return orderresult.success(order);
        } catch (insufficientstockexception e) {
            // 库存不足是业务异常，需要特殊处理但不一定回滚
            log.error("库存不足，订单处理失败", e);
            throw new businessexception("库存不足，请调整商品数量", e);
        }
    }
    // 自定义回滚逻辑
    @transactional
    public void processwithcustomrollback(processrequest request) {
        try {
            step1(request);
            step2(request);
            step3(request);
        } catch (exception e) {
            // 记录错误信息
            errorlogrepository.save(createerrorlog(request, e));
            // 根据异常类型决定是否回滚
            if (shouldrollback(e)) {
                // 重新抛出异常触发spring事务回滚
                throw e;
            } else {
                // 执行补偿操作但不回滚
                executecompensation(request);
            }
        }
    }
}

@configuration
public class datasourceconfig {
    @primary
    @bean(name = "primarytransactionmanager")
    public platformtransactionmanager primarytransactionmanager(
            @qualifier("primarydatasource") datasource datasource) {
        return new datasourcetransactionmanager(datasource);
    }
    @bean(name = "secondarytransactionmanager")
    public platformtransactionmanager secondarytransactionmanager(
            @qualifier("secondarydatasource") datasource datasource) {
        return new datasourcetransactionmanager(datasource);
    }
}
@service
public class multidatasourceservice {
    // 使用主数据源的事务
    @transactional("primarytransactionmanager")
    public void processwithprimarydatasource() {
        primaryrepository.save(new primaryentity());
        // 主数据源操作
    }
    // 使用次要数据源的事务
    @transactional("secondarytransactionmanager")
    public void processwithsecondarydatasource() {
        secondaryrepository.save(new secondaryentity());
        // 次要数据源操作
    }
    // 分布式事务场景（需要xa事务管理器）
    @transactional("xatransactionmanager")
    public void processdistributedtransaction() {
        // 操作多个资源管理器
        resource1repository.update();
        resource2repository.update();
        jmstemplate.send(destination, messagecreator);
    }
}

// 基础服务类定义通用事务配置
@service
@transactional(
    readonly = true,
    timeout = 30,
    propagation = propagation.supports
)
public abstract class baseservice {
    protected void commonoperation() {
        // 通用操作
    }
}
// 具体服务类可以覆盖事务配置
@service
public class userservice extends baseservice {
    // 覆盖为读写事务
    @transactional(
        readonly = false,
        propagation = propagation.required,
        rollbackfor = exception.class
    )
    public user createuser(usercreaterequest request) {
        // 创建用户操作
        return userrepository.save(converttoentity(request));
    }
    // 继承基类的只读事务配置
    public user getuserbyid(long id) {
        return userrepository.findbyid(id).orelse(null);
    }
}

@service
public class complexbusinessservice {
    @autowired
    private accountservice accountservice;
    @autowired
    private auditservice auditservice;
    // 外层事务方法
    @transactional(propagation = propagation.required)
    public void complexbusinessprocess(businessrequest request) {
        // 步骤1：数据准备（在同一个事务中）
        preparedata(request);
        // 步骤2：调用内层事务方法
        try {
            // 内层方法使用requires_new，创建独立事务
            accountservice.processpayment(request.getpayment());
        } catch (paymentexception e) {
            // 支付失败，但外层事务继续执行
            handlepaymentfailure(request, e);
        }
        // 步骤3：记录审计日志（使用not_supported，挂起当前事务）
        auditservice.logoperation(request);
        // 步骤4：最终提交（如果前面的requires_new事务失败，这里仍可提交）
        completeprocess(request);
    }
    private void preparedata(businessrequest request) {
        // 准备业务数据
    }
    private void handlepaymentfailure(businessrequest request, paymentexception e) {
        // 处理支付失败
    }
    private void completeprocess(businessrequest request) {
        // 完成处理
    }
}

@service
public class transactiontrapservice {
    // 陷阱1：自调用导致事务失效
    public void selfinvocationtrap() {
        // 直接调用内部方法，事务注解不会生效
        internaltransactionmethod();
        // 解决方案：通过aopcontext获取代理对象
        // ((transactiontrapservice) aopcontext.currentproxy()).internaltransactionmethod();
    }
    @transactional
    public void internaltransactionmethod() {
        // 这个方法的事务不会生效
    }
    // 陷阱2：异常被捕获未抛出
    @transactional
    public void exceptionhandlingtrap() {
        try {
            riskyoperation();
        } catch (exception e) {
            // 异常被捕获，事务不会回滚
            log.error("操作失败", e);
            // 解决方案1：重新抛出异常
            // throw e;
            // 解决方案2：手动回滚
            // transactionaspectsupport.currenttransactionstatus().setrollbackonly();
        }
    }
    // 陷阱3：非public方法
    @transactional
    protected void nonpublicmethod() {
        // spring基于代理的事务只对public方法生效
    }
}

@aspect
@component
@slf4j
public class transactionmonitoringaspect {
    @around("@annotation(transactional)")
    public object monitortransaction(proceedingjoinpoint joinpoint, 
                                     transactional transactional) throws throwable {
        string methodname = joinpoint.getsignature().toshortstring();
        log.info("事务开始 - 方法: {}, 传播行为: {}, 隔离级别: {}", 
                 methodname, 
                 transactional.propagation(),
                 transactional.isolation());
        long starttime = system.currenttimemillis();
        try {
            object result = joinpoint.proceed();
            long duration = system.currenttimemillis() - starttime;
            log.info("事务提交成功 - 方法: {}, 耗时: {}ms", 
                     methodname, duration);
            return result;
        } catch (exception e) {
            long duration = system.currenttimemillis() - starttime;
            log.error("事务回滚 - 方法: {}, 耗时: {}ms, 异常: {}", 
                      methodname, duration, e.getclass().getsimplename());
            throw e;
        }
    }
}