企业官网建设流程全解析

怎么用flash做网站,wordpress 网站积分打赏,移动端响应式布局,网站自适应开发前言#xff1a;事务的本质与重要性在分布式系统和企业级应用中#xff0c;事务管理是确保数据一致性和业务完整性的基石。Spring 框架提供了一套优雅而强大的事务管理抽象#xff0c;让开发者能够以声明式的方式处理事务#xff0c;而无需陷入繁琐的底层 API 调用。本文将…前言事务的本质与重要性在分布式系统和企业级应用中事务管理是确保数据一致性和业务完整性的基石。Spring 框架提供了一套优雅而强大的事务管理抽象让开发者能够以声明式的方式处理事务而无需陷入繁琐的底层 API 调用。本文将深入探讨 Spring 事务管理的核心原理、实现机制和最佳实践。第一部分事务基础概念1.1 什么是事务事务是数据库操作的最小工作单元是作为单个逻辑工作单元执行的一系列操作。这些操作要么全部成功要么全部失败这就是著名的ACID特性原子性Atomicity事务中的所有操作要么全部完成要么全部不完成一致性Consistency事务执行前后数据库从一个一致性状态转换到另一个一致性状态隔离性Isolation并发事务之间互相隔离互不干扰持久性Durability事务一旦提交其结果就是永久性的1.2 Spring 事务管理优势java// 传统 JDBC 事务管理 vs Spring 声明式事务 public class TraditionalTransaction { public void transferMoney(Connection conn, int fromId, int toId, double amount) { try { conn.setAutoCommit(false); // 手动管理事务 // 执行多个数据库操作 withdraw(conn, fromId, amount); deposit(conn, toId, amount); conn.commit(); // 提交事务 } catch (SQLException e) { try { conn.rollback(); // 回滚事务 } catch (SQLException ex) { // 处理异常 } } finally { // 清理资源 } } }Spring 事务管理通过 AOP 将事务管理代码从业务逻辑中解耦使代码更加简洁和可维护。第二部分Spring 事务核心架构2.1 事务抽象模型Spring 事务管理的核心是PlatformTransactionManager接口它为不同的事务 API 提供了统一的抽象javapublic interface PlatformTransactionManager { // 获取事务状态 TransactionStatus getTransaction(Nullable TransactionDefinition definition) throws TransactionException; // 提交事务 void commit(TransactionStatus status) throws TransactionException; // 回滚事务 void rollback(TransactionStatus status) throws TransactionException; }2.2 主要事务管理器实现Spring 支持多种事务管理器实现事务管理器适用场景配置示例DataSourceTransactionManager单个数据源 JDBC 事务Bean DataSourceTransactionManagerJpaTransactionManagerJPA/Hibernate 事务Bean JpaTransactionManagerJtaTransactionManager分布式事务JTABean JtaTransactionManagerHibernateTransactionManagerHibernate 特定事务Bean HibernateTransactionManager2.3 事务定义接口TransactionDefinition定义了事务的基本属性javapublic interface TransactionDefinition { // 传播行为 int getPropagationBehavior(); // 隔离级别 int getIsolationLevel(); // 超时时间秒 int getTimeout(); // 是否只读 boolean isReadOnly(); // 事务名称 String getName(); }第三部分声明式事务管理详解3.1 Transactional 注解解析Transactional是 Spring 声明式事务的核心注解javaTarget({ElementType.TYPE, ElementType.METHOD}) Retention(RetentionPolicy.RUNTIME) Inherited Documented public interface Transactional { // 事务管理器 Bean 名称 String value() default ; String transactionManager() default ; // 传播行为 Propagation propagation() default Propagation.REQUIRED; // 隔离级别 Isolation isolation() default Isolation.DEFAULT; // 超时时间 int timeout() default TransactionDefinition.TIMEOUT_DEFAULT; // 是否只读 boolean readOnly() default false; // 指定哪些异常触发回滚 Class? extends Throwable[] rollbackFor() default {}; String[] rollbackForClassName() default {}; // 指定哪些异常不触发回滚 Class? extends Throwable[] noRollbackFor() default {}; String[] noRollbackForClassName() default {}; }3.2 基于 XML 的声明式事务配置xml!-- 传统 XML 配置方式 -- bean idtransactionManager classorg.springframework.jdbc.datasource.DataSourceTransactionManager property namedataSource refdataSource/ /bean tx:advice idtxAdvice transaction-managertransactionManager tx:attributes tx:method namesave* propagationREQUIRED/ tx:method nameadd* propagationREQUIRED/ tx:method namedelete* propagationREQUIRED/ tx:method nameupdate* propagationREQUIRED/ tx:method nameget* read-onlytrue/ tx:method namefind* read-onlytrue/ tx:method name* propagationSUPPORTS read-onlytrue/ /tx:attributes /tx:advice aop:config aop:pointcut idserviceOperation expressionexecution(* com.example.service.*.*(..))/ aop:advisor advice-reftxAdvice pointcut-refserviceOperation/ /aop:config3.3 基于 Java Config 的配置javaConfiguration EnableTransactionManagement // 启用事务管理 public class TransactionConfig { Bean public DataSource dataSource() { // 配置数据源 return new HikariDataSource(); } Bean public PlatformTransactionManager transactionManager() { return new DataSourceTransactionManager(dataSource()); } Bean public JdbcTemplate jdbcTemplate() { return new JdbcTemplate(dataSource()); } }第四部分事务传播行为深度解析4.1 七种传播行为详解传播行为定义了事务方法之间如何共享事务上下文javapublic enum Propagation { /** * 支持当前事务如果不存在则新建一个默认 * 方法A有事务调用方法B - 方法B使用A的事务 * 方法A无事务调用方法B - 方法B新建事务 */ REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED), /** * 支持当前事务如果不存在则以非事务方式执行 * 方法A有事务调用方法B - 方法B使用A的事务 * 方法A无事务调用方法B - 方法B无事务执行 */ SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS), /** * 支持当前事务如果不存在则抛出异常 * 方法A有事务调用方法B - 方法B使用A的事务 * 方法A无事务调用方法B - 抛出IllegalTransactionStateException */ MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY), /** * 新建事务如果存在当前事务则挂起 * 方法A有事务调用方法B - 挂起A的事务B新建事务独立执行 */ REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW), /** * 以非事务方式执行如果存在当前事务则挂起 * 方法A有事务调用方法B - 挂起A的事务B无事务执行 */ NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED), /** * 以非事务方式执行如果存在事务则抛出异常 */ NEVER(TransactionDefinition.PROPAGATION_NEVER), /** * 如果存在当前事务则在嵌套事务中执行 * 仅部分事务管理器支持如 DataSourceTransactionManager */ NESTED(TransactionDefinition.PROPAGATION_NESTED) }4.2 传播行为实战示例javaService public class UserService { Autowired private OrderService orderService; Transactional(propagation Propagation.REQUIRED) public void createUserWithOrder(User user, Order order) { // 1. 保存用户在事务中执行 userRepository.save(user); try { // 2. 调用订单服务开启新事务 // 即使订单保存失败用户数据仍然保存 orderService.createOrderWithNewTransaction(order); } catch (Exception e) { // 处理异常不影响用户保存 log.error(创建订单失败, e); } } } Service class OrderService { Transactional(propagation Propagation.REQUIRES_NEW) public void createOrderWithNewTransaction(Order order) { orderRepository.save(order); // 这里抛出异常只会回滚当前事务 throw new RuntimeException(订单保存异常); } }第五部分事务隔离级别5.1 数据库并发问题问题描述示例脏读读取到其他事务未提交的数据事务A修改数据事务B读取事务A回滚不可重复读同一事务内多次读取结果不一致事务A读取数据事务B修改并提交事务A再次读取幻读同一查询条件返回不同的行数事务A查询数量事务B插入数据事务A再次查询5.2 Spring 事务隔离级别javapublic enum Isolation { DEFAULT(TransactionDefinition.ISOLATION_DEFAULT), // 使用数据库默认 READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED), // 读未提交 READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED), // 读已提交 REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ), // 可重复读 SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE) // 串行化 }5.3 隔离级别配置示例javaService public class FinancialService { Transactional( isolation Isolation.REPEATABLE_READ, timeout 30, readOnly false ) public BigDecimal calculateTotalBalance(Long accountId) { // 可重复读确保在事务期间多次读取余额一致 BigDecimal balance1 accountRepository.getBalance(accountId); // 其他业务逻辑... BigDecimal balance2 accountRepository.getBalance(accountId); return balance1.add(balance2); } Transactional( isolation Isolation.SERIALIZABLE, timeout 10 ) public void transfer(Long fromId, Long toId, BigDecimal amount) { // 串行化确保转账操作的绝对安全 withdraw(fromId, amount); deposit(toId, amount); } }第六部分事务失效场景与解决方案6.1 常见的 Transactional 失效场景javaService public class TransactionFailureDemo { // 场景1方法非public Transactional private void privateMethod() { // 事务失效AOP无法代理私有方法 } // 场景2自调用问题 public void selfInvocation() { saveUser(); // 事务失效自调用不走代理 otherMethod(); } Transactional public void saveUser() { userRepository.save(new User()); } // 场景3异常被捕获 Transactional public void saveWithCatch() { try { userRepository.save(new User()); throw new RuntimeException(); // 异常被捕获不回滚 } catch (Exception e) { // 处理异常 } } // 场景4默认只回滚RuntimeException Transactional public void saveWithCheckedException() throws Exception { userRepository.save(new User()); throw new Exception(); // 默认不会回滚 } }6.2 解决方案与最佳实践javaService public class TransactionBestPractice { // 方案1注入自身代理 Autowired private TransactionBestPractice selfProxy; public void correctSelfInvocation() { // 通过代理调用事务生效 selfProxy.saveUser(); } Transactional public void saveUser() { userRepository.save(new User()); } // 方案2明确指定回滚异常 Transactional(rollbackFor Exception.class) public void saveWithCheckedException() throws Exception { userRepository.save(new User()); throw new Exception(); // 现在会回滚 } // 方案3正确的异常处理 Transactional public void saveWithCorrectCatch() { try { userRepository.save(new User()); throw new RuntimeException(); } catch (RuntimeException e) { // 记录日志 log.error(保存失败, e); // 重新抛出异常触发回滚 throw e; } catch (Exception e) { log.error(其他异常, e); throw new RuntimeException(e); // 包装后抛出 } } }第七部分编程式事务管理7.1 TransactionTemplate 使用javaService public class TransactionTemplateService { Autowired private TransactionTemplate transactionTemplate; Autowired private UserRepository userRepository; Autowired private OrderRepository orderRepository; public void createUserAndOrder(final User user, final Order order) { // 使用 TransactionTemplate 执行事务 transactionTemplate.execute(new TransactionCallbackWithoutResult() { Override protected void doInTransactionWithoutResult(TransactionStatus status) { try { // 执行多个数据库操作 userRepository.save(user); orderRepository.save(order); // 可以手动设置回滚点 Object savepoint status.createSavepoint(); // 更多操作... } catch (Exception e) { // 标记事务为回滚 status.setRollbackOnly(); throw e; } } }); } // 配置 TransactionTemplate Bean public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) { TransactionTemplate template new TransactionTemplate(transactionManager); template.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); template.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED); template.setTimeout(30); return template; } }7.2 PlatformTransactionManager 直接使用javaService public class DirectTransactionManagerService { Autowired private PlatformTransactionManager transactionManager; public void complexTransaction() { // 定义事务属性 DefaultTransactionDefinition definition new DefaultTransactionDefinition(); definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); definition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED); definition.setTimeout(30); definition.setReadOnly(false); // 获取事务状态 TransactionStatus status transactionManager.getTransaction(definition); try { // 执行业务逻辑 executeBusinessLogic(); // 提交事务 transactionManager.commit(status); } catch (Exception e) { // 回滚事务 transactionManager.rollback(status); throw e; } } }第八部分分布式事务与多数据源事务8.1 JTA 分布式事务javaConfiguration EnableTransactionManagement public class JtaTransactionConfig { Bean public JtaTransactionManager transactionManager() { UserTransactionManager userTransactionManager new UserTransactionManager(); UserTransaction userTransaction new UserTransactionImp(); return new JtaTransactionManager(userTransaction, userTransactionManager); } Bean public DataSource dataSource1() { // 配置第一个数据源 return new AtomikosDataSourceBean(); } Bean public DataSource dataSource2() { // 配置第二个数据源 return new AtomikosDataSourceBean(); } } Service public class DistributedTransactionService { Transactional // 使用JTA管理分布式事务 public void distributedOperation() { // 操作第一个数据库 jdbcTemplate1.update(INSERT INTO db1.users VALUES (?), user1); // 操作第二个数据库 jdbcTemplate2.update(INSERT INTO db2.orders VALUES (?), order1); // 两个操作在一个分布式事务中 // 要么都成功要么都回滚 } }8.2 多数据源事务管理javaConfiguration public class MultiDataSourceConfig { Primary Bean(name primaryDataSource) ConfigurationProperties(prefix spring.datasource.primary) public DataSource primaryDataSource() { return DataSourceBuilder.create().build(); } Bean(name secondaryDataSource) ConfigurationProperties(prefix spring.datasource.secondary) public DataSource secondaryDataSource() { return DataSourceBuilder.create().build(); } 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 { Autowired Qualifier(primaryJdbcTemplate) private JdbcTemplate primaryJdbcTemplate; Autowired Qualifier(secondaryJdbcTemplate) private JdbcTemplate secondaryJdbcTemplate; // 使用 ChainedTransactionManager 管理多个事务管理器 Transactional(transactionManager chainedTransactionManager) public void multiDataSourceOperation() { primaryJdbcTemplate.update(INSERT INTO primary_db.users VALUES (?), user1); secondaryJdbcTemplate.update(INSERT INTO secondary_db.logs VALUES (?), log1); } Bean public PlatformTransactionManager chainedTransactionManager( Qualifier(primaryTransactionManager) PlatformTransactionManager primary, Qualifier(secondaryTransactionManager) PlatformTransactionManager secondary) { return new ChainedTransactionManager(primary, secondary); } }第九部分Spring 事务源码解析9.1 Transactional 工作原理Spring 事务管理基于 AOP 实现主要涉及以下核心组件java// 1. TransactionInterceptor - 事务拦截器 public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable { Override public Object invoke(MethodInvocation invocation) throws Throwable { Class? targetClass invocation.getThis() ! null ? AopUtils.getTargetClass(invocation.getThis()) : null; // 调用事务方法 return invokeWithinTransaction( invocation.getMethod(), targetClass, invocation::proceed); } } // 2. 事务执行流程 protected Object invokeWithinTransaction(Method method, Nullable Class? targetClass, final InvocationCallback invocation) throws Throwable { // 获取事务属性 TransactionAttributeSource tas getTransactionAttributeSource(); final TransactionAttribute txAttr tas.getTransactionAttribute(method, targetClass); // 确定事务管理器 final PlatformTransactionManager tm determineTransactionManager(txAttr); // 构造事务标识 final String joinpointIdentification methodIdentification(method, targetClass, txAttr); // 声明式事务处理 if (txAttr null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) { // 标准事务处理流程 TransactionInfo txInfo createTransactionIfNecessary(tm, txAttr, joinpointIdentification); Object retVal; try { // 执行业务方法 retVal invocation.proceedWithInvocation(); } catch (Throwable ex) { // 异常时回滚 completeTransactionAfterThrowing(txInfo, ex); throw ex; } finally { cleanupTransactionInfo(txInfo); } // 提交事务 commitTransactionAfterReturning(txInfo); return retVal; } }9.2 事务同步机制javapublic abstract class TransactionSynchronizationManager { // 线程局部变量存储事务上下文 private static final ThreadLocalMapObject, Object resources new NamedThreadLocal(Transactional resources); private static final ThreadLocalSetTransactionSynchronization synchronizations new NamedThreadLocal(Transaction synchronizations); private static final ThreadLocalString currentTransactionName new NamedThreadLocal(Current transaction name); private static final ThreadLocalBoolean currentTransactionReadOnly new NamedThreadLocal(Current transaction read-only status); private static final ThreadLocalInteger currentTransactionIsolationLevel new NamedThreadLocal(Current transaction isolation level); private static final ThreadLocalBoolean actualTransactionActive new NamedThreadLocal(Actual transaction active); }第十部分性能优化与监控10.1 事务性能优化策略javaService public class TransactionOptimizationService { // 策略1合理设置只读事务 Transactional(readOnly true) public ListUser findAllUsers() { // 只读查询数据库优化 return userRepository.findAll(); } // 策略2控制事务范围 Transactional public void batchInsertUsers(ListUser users) { for (User user : users) { // 避免在循环中执行数据库操作 processUser(user); } // 一次性批量提交 userRepository.batchInsert(processedUsers); } // 策略3使用合适的隔离级别 Transactional(isolation Isolation.READ_COMMITTED) public void highConcurrencyOperation() { // 读写频繁的场景使用较低隔离级别 // 提高并发性能 } // 策略4设置合理超时时间 Transactional(timeout 5) public void quickOperation() { // 快速操作设置较短超时 // 避免长时间占用连接 } }10.2 事务监控与诊断javaAspect Component Slf4j public class TransactionMonitorAspect { Around(annotation(org.springframework.transaction.annotation.Transactional)) public Object monitorTransaction(ProceedingJoinPoint joinPoint) throws Throwable { long startTime System.currentTimeMillis(); String methodName joinPoint.getSignature().toShortString(); log.info(事务开始: {}, methodName); 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.getMessage()); throw e; } } } // 使用 Micrometer 监控事务指标 Configuration public class TransactionMetricsConfig { Bean public MeterRegistryCustomizerMeterRegistry metricsCommonTags() { return registry - registry.config().commonTags( application, transaction-demo ); } Bean public PlatformTransactionManagerCustomizerDataSourceTransactionManager transactionManagerCustomizer( MeterRegistry meterRegistry) { return transactionManager - { // 监控事务提交次数 Counter.builder(transaction.commit.count) .description(Number of transaction commits) .register(meterRegistry); // 监控事务回滚次数 Counter.builder(transaction.rollback.count) .description(Number of transaction rollbacks) .register(meterRegistry); }; } }第十一部分实战案例与最佳实践11.1 电商订单事务处理javaService Slf4j public class OrderService { Autowired private InventoryService inventoryService; Autowired private PaymentService paymentService; Autowired private NotificationService notificationService; Transactional( propagation Propagation.REQUIRED, isolation Isolation.READ_COMMITTED, timeout 30, rollbackFor Exception.class ) public Order createOrder(CreateOrderRequest request) { // 1. 校验库存悲观锁或乐观锁 inventoryService.lockInventory(request.getSkuId(), request.getQuantity()); // 2. 创建订单记录 Order order saveOrder(request); // 3. 扣减库存 inventoryService.reduceInventory(request.getSkuId(), request.getQuantity()); // 4. 调用支付 PaymentResult payment paymentService.processPayment(order); if (!payment.isSuccess()) { // 支付失败抛出异常触发回滚 throw new PaymentException(支付失败); } // 5. 更新订单状态 order.markAsPaid(); orderRepository.save(order); // 6. 发送通知异步不影响主事务 notificationService.sendOrderCreatedNotification(order); return order; } // 使用事务传播实现库存补偿 Transactional(propagation Propagation.REQUIRES_NEW) public void compensateInventory(Long orderId) { Order order orderRepository.findById(orderId) .orElseThrow(() - new OrderNotFoundException(orderId)); // 恢复库存 inventoryService.restoreInventory(order.getSkuId(), order.getQuantity()); log.info(订单 {} 库存已恢复, orderId); } }11.2 金融系统事务设计javaService public class BankingService { Transactional( propagation Propagation.REQUIRED, isolation Isolation.SERIALIZABLE, // 最高隔离级别 timeout 60 ) public TransferResult transfer(TransferRequest request) { // 1. 验证账户 validateAccounts(request.getFromAccount(), request.getToAccount()); // 2. 获取锁防止并发转账 Account fromAccount accountRepository.findAndLockById(request.getFromAccount()); Account toAccount accountRepository.findAndLockById(request.getToAccount()); // 3. 检查余额 if (fromAccount.getBalance().compareTo(request.getAmount()) 0) { throw new InsufficientBalanceException(余额不足); } // 4. 执行转账 fromAccount.debit(request.getAmount()); toAccount.credit(request.getAmount()); // 5. 保存账户 accountRepository.save(fromAccount); accountRepository.save(toAccount); // 6. 记录交易流水 TransactionRecord record createTransactionRecord(request); transactionRepository.save(record); // 7. 发送审计事件 eventPublisher.publishEvent(new TransferCompletedEvent(this, record)); return new TransferResult(true, 转账成功, record.getId()); } // 批量处理的事务优化 Transactional public BatchTransferResult batchTransfer(ListTransferRequest requests) { // 使用批量操作提高性能 ListTransferResult results new ArrayList(); for (TransferRequest request : requests) { try { // 每个转账独立事务避免单个失败影响全部 TransferResult result transferSingle(request); results.add(result); } catch (Exception e) { // 记录失败继续处理其他 results.add(new TransferResult(false, e.getMessage(), null)); log.error(批量转账失败: {}, request, e); } } return new BatchTransferResult(results); } Transactional(propagation Propagation.REQUIRES_NEW) private TransferResult transferSingle(TransferRequest request) { // 独立的短事务 return transfer(request); } }第十二部分Spring Boot 事务自动配置12.1 自动配置原理Spring Boot 通过TransactionAutoConfiguration自动配置事务javaConfiguration(proxyBeanMethods false) ConditionalOnClass(PlatformTransactionManager.class) AutoConfigureAfter({ JtaAutoConfiguration.class, HibernateJpaAutoConfiguration.class, DataSourceAutoConfiguration.class, Neo4jAutoConfiguration.class }) EnableConfigurationProperties(TransactionProperties.class) public class TransactionAutoConfiguration { Configuration(proxyBeanMethods false) ConditionalOnSingleCandidate(DataSource.class) static class DataSourceTransactionManagerConfiguration { Bean ConditionalOnMissingBean(TransactionManager.class) public DataSourceTransactionManager transactionManager(DataSource dataSource, ObjectProviderTransactionManagerCustomizers transactionManagerCustomizers) { DataSourceTransactionManager transactionManager new DataSourceTransactionManager(dataSource); transactionManagerCustomizers.ifAvailable( (customizers) - customizers.customize(transactionManager)); return transactionManager; } } }12.2 配置示例yaml# application.yml 事务配置 spring: transaction: default-timeout: 30 # 默认超时时间秒 rollback-on-commit-failure: true # 提交失败时回滚 jpa: properties: javax: persistence: lock.timeout: 10000 # JPA锁超时 query.timeout: 5000 # 查询超时 datasource: hikari: auto-commit: false # 关闭自动提交 connection-timeout: 30000 # 连接超时 aop: auto: true # 启用AOP proxy-target-class: true # CGLIB代理总结Spring 事务管理是一个强大而灵活的系统它通过声明式事务将开发者从繁琐的事务管理代码中解放出来。通过深入理解事务传播行为、隔离级别、回滚规则等核心概念以及掌握事务失效场景和解决方案我们可以设计出既安全又高效的事务处理逻辑。