Spring AOP面向切面编程深度解析：从动态代理到实战（2026年4月9日·个人AI助手专版）

@Service
public class UserService {
    
    public void saveUser(User user) {
        System.out.println("[LOG] 开始执行 saveUser 方法，参数：" + user);
        // 核心业务逻辑
        System.out.println("[LOG] saveUser 方法执行完毕");
    }
    
    public void deleteUser(Long id) {
        System.out.println("[LOG] 开始执行 deleteUser 方法，参数：" + id);
        // 核心业务逻辑
        System.out.println("[LOG] deleteUser 方法执行完毕");
    }
    
    // 假设还有几十个方法，每个都要重复这两行日志代码...
}

@Aspect
@Component
public class LoggingAspect {
    
    // 前置通知：目标方法执行前执行，适用于参数校验、权限控制
    @Before("execution( com.example.service..(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("【@Before】方法执行前：" + joinPoint.getSignature().getName());
    }
    
    // 返回后通知：目标方法正常返回后执行，可访问返回值
    @AfterReturning(pointcut = "execution( com.example.service..(..))", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【@AfterReturning】方法返回：" + result);
    }
    
    // 异常通知：目标方法抛出异常后执行，可捕获异常类型
    @AfterThrowing(pointcut = "execution( com.example.service..(..))", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        System.out.println("【@AfterThrowing】方法抛异常：" + ex.getMessage());
    }
    
    // 后置通知（类似finally）：方法执行后无论结果如何都执行，适用于资源清理
    @After("execution( com.example.service..(..))")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("【@After】方法执行完毕（无论是否异常）");
    }
    
    // 环绕通知：包裹目标方法，可完全控制方法执行流程（功能最强大）
    @Around("execution( com.example.service..(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【@Around】方法执行前");
        Object result = joinPoint.proceed();  // 手动调用原方法
        long elapsedTime = System.currentTimeMillis() - start;
        System.out.println("【@Around】方法执行后，耗时：" + elapsedTime + "ms");
        return result;
    }
}

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

// 匹配service包下所有类的所有方法
@Pointcut("execution( com.example.service..(..))")

// 匹配所有公共方法
@Pointcut("execution(public  (..))")

// 匹配UserService及其子类的所有方法
@Pointcut("execution( com.example.service.UserService+.(..))")

// 匹配被@Loggable注解标记的方法（基于注解的切点，更灵活）
@Pointcut("@annotation(com.example.anno.Loggable)")

// 1. 定义业务接口
public interface UserService {
    void saveUser(String name);
    void deleteUser(Long id);
}

// 2. 业务实现类
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(String name) {
        System.out.println("保存用户：" + name);
    }
    @Override
    public void deleteUser(Long id) {
        System.out.println("删除用户：" + id);
    }
}

// 3. 静态代理类（需要为每个接口手动编写）
public class UserServiceStaticProxy implements UserService {
    private UserService target;
    
    public UserServiceStaticProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void saveUser(String name) {
        System.out.println("[LOG] 前置：保存用户");
        target.saveUser(name);
        System.out.println("[LOG] 后置：保存完成");
    }
    
    @Override
    public void deleteUser(Long id) {
        System.out.println("[LOG] 前置：删除用户");
        target.deleteUser(id);
        System.out.println("[LOG] 后置：删除完成");
    }
}

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

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

@Aspect          // ① 标记该类为切面类
@Component       // ② 将切面类纳入Spring容器管理
public class LoggingAspect {
    
    // ③ 定义切点：哪些方法需要被增强
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethods() {}
    
    // ④ 前置通知
    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("【日志】开始执行：" + joinPoint.getSignature().getName());
    }
    
    // ⑤ 后置通知
    @AfterReturning(pointcut = "serviceMethods()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("【日志】执行完成：" + joinPoint.getSignature().getName() + "，返回值：" + result);
    }
    
    // ⑥ 环绕通知（最强大，可控制方法执行）
    @Around("serviceMethods()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【性能】" + joinPoint.getSignature().getName() + " 开始");
        Object result = joinPoint.proceed();   // 关键：手动调用原方法
        long elapsed = System.currentTimeMillis() - start;
        System.out.println("【性能】" + joinPoint.getSignature().getName() + " 耗时：" + elapsed + "ms");
        return result;
    }
}

@Service
public class UserService {
    // 业务方法中完全没有日志代码，干净整洁！
    public void saveUser(String name) {
        System.out.println("正在保存用户：" + name);
    }
    
    public String getUserById(Long id) {
        return "用户" + id;
    }
}