Spring AOP - 面向切面编程

// 没有AOP时 - 日志代码分散各处
public class UserServiceImpl {
    public void createUser(String name) {
        System.out.println("[日志] 方法开始");  // 重复代码
        // 业务逻辑
        System.out.println("[日志] 方法结束");  // 重复代码
    }
}

public class OrderServiceImpl {
    public void createOrder(String product) {
        System.out.println("[日志] 方法开始");  // 重复代码
        // 业务逻辑
        System.out.println("[日志] 方法结束");  // 重复代码
    }
}

// 代理类示意（非真实代码）
public class UserServiceProxy implements UserService {
    private UserService target;  // 目标对象
    private LoggerAdvice advice; // 增强逻辑
    
    public void createUser(String name) {
        advice.before();                    // 前置增强
        target.createUser(name);            // 调用目标方法
        advice.after();                     // 后置增强
    }
}

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.2.15</version>
</dependency>

<!-- AspectJ依赖（Spring AOP使用了AspectJ的切点表达式） -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.9.1</version>
</dependency>

<!-- 测试验证需要的Spring Test与JUnit Jupiter -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>6.2.15</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy  // 开启Spring AOP
public class SpringConfiguration {
}

@Component  // 注册为Spring Bean
@Aspect     // 标记为切面类
public class LoggingAspect {
    
    // 定义切入点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void servicePointCut() {}
    
    // 前置通知：方法执行前执行
    @Before("servicePointCut()")
    public void beforeLog(JoinPoint joinPoint) {
        System.out.println("[日志] 开始执行: " + joinPoint.getSignature().getName());
    }
    
    // 后置通知：方法执行后执行
    @After("servicePointCut()")
    public void afterLog(JoinPoint joinPoint) {
        System.out.println("[日志] 执行结束: " + joinPoint.getSignature().getName());
    }
}

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AopTest {
    
    @Autowired
    private UserService userService;
    
    @Test
    public void testAop() {
        userService.createUser("张三");
        // 输出：
        // [日志] 开始执行: createUser
        // 业务逻辑：创建用户
        // [日志] 执行结束: createUser
    }
}

execution(访问修饰符 返回值 包名.类名.方法名(参数列表))

// 1. 定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogOperation {
}

// 2. 使用注解
@Service
public class UserServiceImpl {
    @LogOperation
    public void createUser(String name) {
        // ...
    }
}

// 3. 定义切入点
@Pointcut("@annotation(com.example.annotation.LogOperation)")
public void logPointCut() {}

// 1. 定义类级别注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ServiceLog {
}

// 2. 标注在类上
@Service
@ServiceLog
public class UserServiceImpl {
    public void createUser(String name) { }  // 会被匹配
    public void deleteUser(String name) { }  // 也会被匹配
}

// 3. 定义切入点
@Pointcut("@target(com.example.annotation.ServiceLog)")
public void serviceLogPointCut() {}

正常执行流程：
@Before → 目标方法 → @AfterReturning → @After

异常执行流程：
@Before → 目标方法(抛出异常) → @AfterThrowing → @After

@Before("servicePointCut()")
public void beforeAdvice(JoinPoint joinPoint) {
    // 获取方法签名
    String methodName = joinPoint.getSignature().getName();
    // 获取参数
    Object[] args = joinPoint.getArgs();
    // 获取目标对象
    Object target = joinPoint.getTarget();
    
    System.out.println("[前置通知] 准备执行: " + methodName);
}

@AfterReturning(
    value = "servicePointCut()", 
    returning = "result"  // 绑定返回值到参数
)
public void afterReturning(JoinPoint joinPoint, Object result) {
    System.out.println("[返回通知] 返回值: " + result);
}

@AfterThrowing(
    value = "servicePointCut()",
    throwing = "ex"  // 绑定异常到参数
)
public void afterThrowing(JoinPoint joinPoint, Exception ex) {
    System.out.println("[异常通知] 发生异常: " + ex.getMessage());
}

@After("servicePointCut()")
public void afterAdvice(JoinPoint joinPoint) {
    System.out.println("[最终通知] 方法执行结束");
}

@Around("servicePointCut()")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    // 1. 前置逻辑
    System.out.println("[环绕通知-前]");
    
    // 2. 获取信息
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    
    Object result = null;
    try {
        // 3. 执行目标方法（如果不调用proceed，目标方法不会执行）
        result = joinPoint.proceed(args);
        
        // 4. 后置逻辑（正常返回）
        System.out.println("[环绕通知-后] 返回值: " + result);
    } catch (Throwable e) {
        // 5. 异常处理
        System.out.println("[环绕通知-异常] " + e.getMessage());
        throw e;
    } finally {
        // 6. 最终逻辑
        System.out.println("[环绕通知-最终]");
    }
    
    return result;
}

public interface JoinPoint {
    // 获取方法签名（包含方法名、参数类型等）
    Signature getSignature();
    
    // 获取目标对象（被代理的原始对象）
    Object getTarget();
    
    // 获取代理对象
    Object getThis();
    
    // 获取方法参数
    Object[] getArgs();
}

public interface ProceedingJoinPoint extends JoinPoint {
    // 执行目标方法
    Object proceed() throws Throwable;
    
    // 带参数执行目标方法
    Object proceed(Object[] args) throws Throwable;
}

@Around("servicePointCut()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
    // 方法信息
    String className = joinPoint.getTarget().getClass().getSimpleName();
    String methodName = joinPoint.getSignature().getName();
    Object[] args = joinPoint.getArgs();
    
    // 记录入参
    System.out.println("[" + className + "." + methodName + "] 入参: " + Arrays.toString(args));
    
    long startTime = System.currentTimeMillis();
    
    // 执行目标方法
    Object result = joinPoint.proceed();
    
    long endTime = System.currentTimeMillis();
    
    // 记录出参和执行时间
    System.out.println("[" + className + "." + methodName + "] 出参: " + result + " 耗时: " + (endTime - startTime) + "ms");
    
    return result;
}