Office AI助手带你深入浅出掌握Spring AOP核心原理与实战

public class OrderService {
    
    // 创建订单——日志、权限、事务逻辑混在一起
    public void createOrder(Order order) {
        // 日志开始
        System.out.println("【日志】开始创建订单");
        // 权限校验
        if (!hasPermission("order:create")) {
            throw new SecurityException("无权限");
        }
        // 事务开始
        beginTransaction();
        try {
            // 核心业务逻辑
            doCreateOrder(order);
            // 事务提交
            commitTransaction();
            // 日志结束
            System.out.println("【日志】订单创建成功");
        } catch (Exception e) {
            rollbackTransaction();
            System.out.println("【日志】订单创建失败：" + e.getMessage());
            throw e;
        }
    }
    
    // 取消订单——同样的代码再写一遍
    public void cancelOrder(Long orderId) {
        // 又是日志、权限、事务...（100行重复代码）
    }
    
    // 支付订单——再来一遍
    public void payOrder(Long orderId) {
        // 又是日志、权限、事务...
    }
}

execution(修饰符? 返回值类型 类路径.方法名(参数) 异常?)

切面(Aspect) = 通知(Advice) + 切点(Pointcut)
        ↓
    切点匹配连接点(Join Point)
        ↓
    通知定义在连接点执行的动作
        ↓
    Spring通过代理(Proxy)将切面织入(Weaving)目标对象(Target)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

package com.example.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.;
import org.springframework.stereotype.Component;

@Component           // ① 将切面类纳入Spring容器管理
@Aspect              // ② 标记这是一个切面类
public class LogAspect {
    
    // ③ 定义切点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void servicePointcut() {}
    
    // ④ 前置通知：方法执行前记录参数
    @Before("servicePointcut()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("【前置通知】调用方法：" + methodName + "，参数：" + Arrays.toString(args));
    }
    
    // ⑤ 返回后通知：方法正常返回后记录返回值
    @AfterReturning(pointcut = "servicePointcut()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【返回通知】方法：" + methodName + "，返回值：" + result);
    }
    
    // ⑥ 异常通知：方法抛异常时记录异常信息
    @AfterThrowing(pointcut = "servicePointcut()", throwing = "e")
    public void logAfterThrowing(JoinPoint joinPoint, Exception e) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【异常通知】方法：" + methodName + "，异常：" + e.getMessage());
    }
    
    // ⑦ 后置通知：方法执行后（无论结果如何）执行资源清理
    @After("servicePointcut()")
    public void logAfter(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【后置通知】方法：" + methodName + " 执行完毕");
    }
    
    // ⑧ 环绕通知：最强大，可完全控制方法执行
    @Around("servicePointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        long start = System.currentTimeMillis();
        
        System.out.println("【环绕前置】开始执行：" + methodName);
        
        try {
            Object result = joinPoint.proceed();  // 必须调用，执行目标方法
            long elapsed = System.currentTimeMillis() - start;
            System.out.println("【环绕后置】执行完成：" + methodName + "，耗时：" + elapsed + "ms");
            return result;
        } catch (Exception e) {
            System.out.println("【环绕异常】执行失败：" + methodName);
            throw e;
        }
    }
}

package com.example.service;

import org.springframework.stereotype.Service;

@Service
public class OrderService {
    
    // 业务代码完全不需要关心日志逻辑
    public String createOrder(String orderNo) {
        System.out.println("【业务逻辑】正在创建订单：" + orderNo);
        if (orderNo == null || orderNo.isEmpty()) {
            throw new IllegalArgumentException("订单号不能为空");
        }
        return "订单创建成功：" + orderNo;
    }
}

【环绕前置】开始执行：createOrder
【前置通知】调用方法：createOrder，参数：[ORD001]
【业务逻辑】正在创建订单：ORD001
【返回通知】方法：createOrder，返回值：订单创建成功：ORD001
【后置通知】方法：createOrder 执行完毕
【环绕后置】执行完成：createOrder，耗时：2ms

调用方 → @Around前置 → @Before → 目标方法 → @AfterReturning → @After → @Around后置 → 返回结果
                         ↓（如抛异常）
                    @AfterThrowing → @After → @Around异常

// 订单服务接口
public interface OrderService {
    void createOrder(String orderNo);
}

// 接口实现类
public class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder(String orderNo) {
        System.out.println("创建订单：" + orderNo);
    }
}

// InvocationHandler：定义增强逻辑
public class LogInvocationHandler implements InvocationHandler {
    private Object target;
    
    public LogInvocationHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("【日志开始】" + method.getName());
        Object result = method.invoke(target, args);  // 反射调用目标方法
        System.out.println("【日志结束】" + method.getName());
        return result;
    }
}

// 生成代理对象
OrderService target = new OrderServiceImpl();
OrderService proxy = (OrderService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    target.getClass().getInterfaces(),  // 必须传入接口
    new LogInvocationHandler(target)
);
proxy.createOrder("ORD001");