Spring AOP 深度解析与项目实战：原理+应用+性能优化（附完整代码）

<!-- Spring AOP 核心依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.20</version>
</dependency>
<!-- AOP 注解支持 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

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

@Component
@Aspect
public class LogAspect {
    // 切面逻辑...
}

// 匹配指定包下所有类的所有方法
@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceMethods() {}

// 匹配指定类的所有public方法
@Pointcut("execution(public * com.example.service.UserService.*(..))")
public void userServicePublicMethods() {}

// 匹配指定类的特定方法（参数匹配）
@Pointcut("execution(* com.example.service.OrderService.createOrder(Long, String))")
public void createOrderMethod() {}

// 匹配标注了@Transactional注解的方法
@Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
public void transactionalMethods() {}

// 匹配标注了@Service注解的类中的所有方法
@Pointcut("@within(org.springframework.stereotype.Service)")
public void serviceClassMethods() {}

// 匹配指定参数类型的方法
@Pointcut("args(Long, String)")
public void methodsWithLongAndStringArgs() {}

@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    System.out.printf("方法%s开始执行，参数：%s%n", methodName, Arrays.toString(args));
}

@After("serviceMethods()")
public void logAfter(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    System.out.printf("方法%s执行结束%n", methodName);
}

@AfterReturning(pointcut = "serviceMethods()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
    String methodName = joinPoint.getSignature().getName();
    System.out.printf("方法%s执行成功，返回值：%s%n", methodName, result);
}

@AfterThrowing(pointcut = "serviceMethods()", throwing = "ex")
public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
    String methodName = joinPoint.getSignature().getName();
    System.out.printf("方法%s执行异常，异常信息：%s%n", methodName, ex.getMessage());
}

@Around("serviceMethods()")
public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
    String methodName = pjp.getSignature().getName();
    long startTime = System.currentTimeMillis();
    
    try {
        // 执行目标方法
        Object result = pjp.proceed();
        long endTime = System.currentTimeMillis();
        System.out.printf("方法%s执行耗时：%dms%n", methodName, (endTime - startTime));
        return result;
    } catch (Throwable e) {
        System.out.printf("方法%s执行异常：%s%n", methodName, e.getMessage());
        throw e; // 继续抛出异常，不掩盖原异常
    }
}

@Service
public class UserService {
    public User getUserById(Long id) {
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("用户ID无效");
        }
        return new User(id, "张三", 25);
    }
    
    public User createUser(String name, Integer age) {
        User user = new User(System.currentTimeMillis(), name, age);
        return user;
    }
}

// 用户实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
}

@Component
@Aspect
public class LoggingAspect {
    // 定义切点：匹配UserService的所有方法
    @Pointcut("execution(* com.example.service.UserService.*(..))")
    public void userServiceMethods() {}
    
    // 前置通知
    @Before("userServiceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        String method = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("【前置日志】方法：" + method + "，参数：" + Arrays.toString(args));
    }
    
    // 返回通知
    @AfterReturning(pointcut = "userServiceMethods()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        String method = joinPoint.getSignature().getName();
        System.out.println("【返回日志】方法：" + method + "，结果：" + result);
    }
    
    // 异常通知
    @AfterThrowing(pointcut = "userServiceMethods()", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        String method = joinPoint.getSignature().getName();
        System.out.println("【异常日志】方法：" + method + "，异常：" + ex.getMessage());
    }
    
    // 环绕通知：记录方法执行时间
    @Around("userServiceMethods()")
    public Object logExecutionTime(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();
        long end = System.currentTimeMillis();
        System.out.println("【性能日志】方法：" + pjp.getSignature().getName() + "，耗时：" + (end - start) + "ms");
        return result;
    }
}

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy // 启用AOP注解支持
public class AppConfig {
}

// 测试类
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        
        // 测试正常方法
        userService.getUserById(1L);
        
        // 测试异常方法
        try {
            userService.getUserById(-1L);
        } catch (Exception e) {
            // 预期异常，不处理
        }
        
        // 测试创建用户
        userService.createUser("李四", 30);
    }
}

【前置日志】方法：getUserById，参数：[1]
【性能日志】方法：getUserById，耗时：1ms
【返回日志】方法：getUserById，结果：User(id=1, name=张三, age=25)
【前置日志】方法：getUserById，参数：[-1]
【异常日志】方法：getUserById，异常：用户ID无效
【性能日志】方法：getUserById，耗时：0ms
【前置日志】方法：createUser，参数：[李四, 30]
【性能日志】方法：createUser，耗时：0ms
【返回日志】方法：createUser，结果：User(id=1655234567890, name=李四, age=30)

@Order(1) // 优先级高于Order(2)
@Component
@Aspect
public class SecurityAspect { ... }

@Order(2)
@Component
@Aspect
public class LogAspect { ... }

// 通用切点：所有服务层方法
@Pointcut("within(com.example.service..*)")
public void serviceLayer() {}

// 通用切点：所有public方法
@Pointcut("execution(public * *(..))")
public void publicMethods() {}

// 组合切点：服务层的public方法
@Pointcut("serviceLayer() && publicMethods()")
public void publicServiceMethods() {}