Spring事务管理与AOP实践指南

小厂永远得不到的男人
299 阅读3分钟

一、事务管理深度解析

1.1 事务核心概念

事务（Transaction）是数据库操作的最小工作单元，具备ACID特性：

  • 原子性（Atomicity）：操作不可分割，全部成功或全部失败
  • 一致性（Consistency）：数据状态始终保持合法
  • 隔离性（Isolation）：并发操作互不干扰
  • 持久性（Durability）：提交后数据永久保存

SQL事务操作模板

START TRANSACTION;

UPDATE account SET balance = balance - 100 WHERE id = 1;
UPDATE account SET balance = balance + 100 WHERE id = 2;

-- 模拟异常场景
-- SET @error = 1 / 0; 

COMMIT;
-- ROLLBACK;

1.2 Spring声明式事务

通过@Transactional注解实现事务管理：

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private InventoryMapper inventoryMapper;

    @Transactional(rollbackFor = Exception.class, 
                  propagation = Propagation.REQUIRED)
    public void createOrder(OrderDTO orderDTO) {
        // 扣减库存
        inventoryMapper.deduct(orderDTO.getSkuId(), orderDTO.getQuantity());
        
        // 创建订单
        Order order = convertToOrder(orderDTO);
        orderMapper.insert(order);
        
        // 更新用户积分
        userService.updatePoints(orderDTO.getUserId(), orderDTO.getAmount());
    }
}

核心配置参数

参数名称默认值说明
isolationDEFAULT事务隔离级别
propagationREQUIRED事务传播行为
rollbackForRuntimeException触发回滚的异常类型
timeout-1事务超时时间（秒）

1.3 高级事务配置

事务传播行为对比

传播行为类型特性说明适用场景
REQUIRED支持当前事务，不存在则创建新事务常规业务操作
REQUIRES_NEW始终创建新事务，挂起当前事务独立日志记录
NESTED嵌套事务，保存点机制复杂业务流程
NOT_SUPPORTED非事务方式执行，挂起当前事务非核心操作

自定义异常回滚

@Transactional(rollbackFor = {BusinessException.class, SystemException.class})
public void processPayment() {
    // 业务逻辑
}

二、AOP核心原理与实践

2.1 AOP核心概念

面向切面编程（AOP）通过预编译方式和运行期动态代理实现程序功能的统一维护。

AOP术语体系

术语说明
Aspect（切面）封装横切逻辑的模块
Join Point（连接点）程序执行过程中的特定点
Advice（通知）在连接点执行的动作
Pointcut（切点）匹配连接点的表达式

2.2 AOP通知类型详解

通知类型对比表

通知类型执行时机接口方法
@Before目标方法执行前void before()
@After目标方法执行后void after()
@Around包裹目标方法执行Object around(ProceedingJoinPoint)
@AfterReturning目标方法正常返回后void afterReturning()
@AfterThrowing目标方法抛出异常后void afterThrowing()

环绕通知最佳实践

@Aspect
@Component
public class PerformanceAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        
        try {
            Object result = joinPoint.proceed();
            return result;
        } finally {
            long duration = System.currentTimeMillis() - startTime;
            String methodName = joinPoint.getSignature().getName();
            System.out.println(methodName + " executed in " + duration + "ms");
        }
    }
}

2.3 切点表达式语法

表达式语法规范

execution(
    [访问权限] 返回类型 [全限定类名].方法名(参数列表) [异常类型]
)

常见表达式模式

表达式模式匹配目标
execution(* com.service..(..))service包下所有类的所有方法
execution(public * *(..))所有public方法
execution(* set*(..))所有set开头的方法
@annotation(org.springframework.transaction.annotation.Transactional)带有@Transactional注解的方法

三、综合应用案例

3.1 操作日志记录实现

日志注解定义

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OperateLog {
    String module() default "";
    String operation() default "";
}

切面实现

@Aspect
@Component
public class LogAspect {

    @Autowired
    private LogService logService;

    @Around("@annotation(logAnnotation)")
    public Object recordLog(ProceedingJoinPoint joinPoint, 
                           OperateLog logAnnotation) throws Throwable {
        String username = getCurrentUser();
        String module = logAnnotation.module();
        String operation = logAnnotation.operation();
        
        long beginTime = System.currentTimeMillis();
        try {
            Object result = joinPoint.proceed();
            saveLog(username, module, operation, System.currentTimeMillis() - beginTime, null);
            return result;
        } catch (Exception e) {
            saveLog(username, module, operation, System.currentTimeMillis() - beginTime, e.getMessage());
            throw e;
        }
    }

    private void saveLog(String user, String module, String operation, 
                        long duration, String error) {
        OperateLog log = new OperateLog();
        log.setUser(user);
        log.setModule(module);
        log.setOperation(operation);
        log.setExecutionTime(duration);
        log.setErrorInfo(error);
        log.setCreateTime(LocalDateTime.now());
        logService.save(log);
    }
}

3.2 服务层性能监控

监控配置

@Aspect
@Component
public class PerformanceMonitor {

    @Around("execution(* com.example..service..*(..))")
    public Object monitorService(ProceedingJoinPoint pjp) throws Throwable {
        String className = pjp.getTarget().getClass().getName();
        String methodName = pjp.getSignature().getName();
        String key = className + "#" + methodName;

        long start = System.currentTimeMillis();
        try {
            return pjp.proceed();
        } finally {
            long elapsed = System.currentTimeMillis() - start;
            Metrics.recordTiming(key, elapsed);
        }
    }
}

四、最佳实践建议

  1. 事务管理准则：

    • 保持事务边界清晰
    • 避免长事务（>3秒）
    • 合理设置事务隔离级别
    • 正确配置回滚规则

  2. AOP应用规范：

    • 切面代码保持无状态
    • 优先使用注解方式配置切点
    • 避免在切面中进行复杂业务处理
    • 注意执行顺序（使用@Order控制）

  3. 性能优化建议：

    # 开启AOP代理优化（Spring 5.2+）
spring.aop.proxy-target-class=false

通过合理运用事务管理和AOP技术，可以有效提升系统的可靠性、可维护性和扩展性。建议根据具体业务场景选择合适的实现方案，并通过完善的监控体系持续优化系统性能。

avatar
文章
阅读
粉丝