AOP 面向切面编程

// 强制使用 CGLIB 代理（Spring Boot 2.x+ 默认就是如此）
@EnableAspectJAutoProxy(proxyTargetClass = true)

// 注解方式启用（推荐）
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {}

// 强制 CGLIB + 暴露代理对象
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = true)

@Aspect   // 标记为切面类
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("调用方法: " + joinPoint.getSignature().getName());
    }
}

execution(修饰符模式? 返回类型模式 方法名模式(参数模式) 异常模式?)

execution(* 包名.类名.方法名(参数列表))

// 1. 匹配所有 public 方法
execution(public * *(..))

// 2. 匹配所有以 set 开头的方法
execution(* set*(..))

// 3. 匹配 AccountService 接口的所有方法
execution(* com.example.service.AccountService.*(..))

// 4. 匹配 service 包下所有类的所有方法
execution(* com.example.service.*.*(..))

// 5. 匹配 service 包及其子包下所有类的所有方法（注意 .. 的位置）
execution(* com.example.service..*.*(..))

// 6. 匹配特定方法名，且参数为两个字符串
execution(* com.example.service.AccountService.create(String, String))

// 7. 匹配无参数方法
execution(* com.example.service.AccountService.*())

// 8. 匹配第一个参数为 String 的方法
execution(* com.example.service.*.*(String, ..))

// 9. 匹配返回值为 String 的方法
execution(String com.example.service.*.*(..))

// 10. 匹配抛出特定异常的方法
execution(* com.example.service.*.*(..) throws java.lang.IllegalArgumentException)

// 匹配所有带有 @Loggable 注解的方法
@annotation(com.example.annotation.Loggable)

// 绑定注解实例，在通知中获取注解属性
@Around("@annotation(loggable)")
public Object logMethod(ProceedingJoinPoint joinPoint, Loggable loggable) throws Throwable {
    String operation = loggable.value();  // 获取注解属性
    // ...
}

// 匹配所有带有 @Service 注解的类中的方法
@within(org.springframework.stereotype.Service)

// 匹配 AccountService 类中的所有方法
within(com.example.service.AccountService)

// 匹配 service 包下所有类中的方法
within(com.example.service..*)

// this: 匹配代理对象是指定类型的方法（受代理方式影响）
this(com.example.service.AccountService)

// target: 匹配目标对象是指定类型的方法（不受代理方式影响）
target(com.example.service.AccountService)

// 匹配第一个参数为 String 类型的方法
args(String, ..)

// 匹配两个参数，第一个为 String，第二个为 Long
args(String, Long)

// 匹配名称为 accountService 的 Bean 的所有方法
bean(accountService)

// 匹配名称以 Service 结尾的 Bean 的所有方法
bean(*Service)

// && (AND): 同时满足两个条件
@Pointcut("execution(* com.example.service.*.*(..)) && args(String, ..)")
public void serviceMethodWithStringParam() {}

// || (OR): 满足任意一个条件
@Pointcut("execution(* com.example.service.*.*(..)) || execution(* com.example.dao.*.*(..))")
public void serviceOrDaoMethod() {}

// ! (NOT): 取反
@Pointcut("execution(* com.example.service.*.*(..)) && !@annotation(com.example.annotation.SkipLog)")
public void serviceMethodWithoutSkipLog() {}

// 推荐：使用命名切入点
@Aspect
@Component
public class LoggingAspect {

    // 定义命名切入点
    @Pointcut("execution(* com.example.service..*.*(..))")
    public void serviceLayer() {}

    @Pointcut("@annotation(com.example.annotation.Loggable)")
    public void loggableMethod() {}

    // 复用切入点
    @Around("serviceLayer() && loggableMethod()")
    public Object logMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        // ...
    }
}

// × 从方法前缀区分是否是数据库操作，非常不可靠
@Around("execution(public * update*(..))")
public Object doLogging(ProceedingJoinPoint pjp) throws Throwable { ... }

package com.example.annotation;

@Target(ElementType.METHOD)           // 作用于方法
@Retention(RetentionPolicy.RUNTIME)   // 运行时保留（AOP 需要运行时反射）
public @interface MetricTime {
    String value();  // 监控名称
}

@Component
public class UserService {
    // 监控 register() 方法性能
    @MetricTime("register")
    public User register(String email, String password, String name) {
        User user = new User(email, password, name);
        return userRepository.save(user);
    }

    // 不需要监控的方法不标注注解
    public boolean isValidEmail(String email) {
        return email != null && email.contains("@");
    }
}

@Aspect @Component
public class MetricAspect {
    /**
     * 环绕通知：拦截所有标注了 @MetricTime 注解的方法
     *
     * @param joinPoint  连接点
     * @param metricTime 注解对象（参数名必须与注解类名首字母小写一致）
     */
    @Around("@annotation(metricTime)")
    public Object metric(ProceedingJoinPoint joinPoint, MetricTime metricTime) throws Throwable {
        String name = metricTime.value();  // 获取注解的 value 属性
        long start = System.currentTimeMillis();

        try {
            return joinPoint.proceed();
        } finally {
            long elapsed = System.currentTimeMillis() - start;
            System.err.println("[Metrics] " + name + ": " + elapsed + "ms");
        }
    }
}

[Metrics] register: 105ms

// 定义类级别注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ServiceMonitor {
    String serviceName();
}

// 使用
@ServiceMonitor(serviceName = "用户服务")
@Service
public class UserService {
    public User getUser(Long id) { ... }
}

// 切面
@Aspect @Component
public class ServiceMonitorAspect {
    @Around("@within(serviceMonitor)")
    public Object monitor(ProceedingJoinPoint joinPoint, ServiceMonitor serviceMonitor) throws Throwable {
        String serviceName = serviceMonitor.serviceName();
        String methodName = joinPoint.getSignature().getName();
        log.info("服务: {}, 方法: {}", serviceName, methodName);
        return joinPoint.proceed();
    }
}

// 组合事务 + 日志 + 权限
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Transactional
@Log
@RequirePermission
public @interface ServiceMethod {
    String value() default "";
    String permission() default "";
}

// 使用组合注解
@Service
public class UserService {
    @ServiceMethod(value = "创建用户", permission = "user:create")
    public User createUser(String name, String email) { ... }
}

@Aspect
@Component
public class ValidationAspect {

    // 通过 JoinPoint 获取方法信息
    @Before("execution(* com.example.service.*.*(..))")
    public void logParameters(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("调用方法: " + methodName + ", 参数: " + Arrays.toString(args));
    }

    // 通过 args 绑定直接获取参数
    @Before("execution(* com.example.service.*.create*(..)) && args(entity)")
    public void validateEntity(Object entity) {
        if (entity == null) {
            throw new IllegalArgumentException("实体不能为 null");
        }
        System.out.println("参数校验通过: " + entity);
    }
}

@Aspect
@Component
public class ResultLogAspect {

    @AfterReturning(
        pointcut = "execution(* com.example.service.*.find*(..))",
        returning = "result"
    )
    public void logReturnValue(Object result) {
        System.out.println("方法返回值: " + result);
    }

    // 修改返回值（谨慎使用）
    @AfterReturning(
        pointcut = "execution(* com.example.service.UserService.findById(..))",
        returning = "user"
    )
    public void maskSensitiveData(User user) {
        // 脱敏处理
        if (user != null) {
            user.setPassword("******");
        }
    }
}

@Aspect
@Component
public class ExceptionLogAspect {

    @AfterThrowing(
        pointcut = "execution(* com.example.service.*.*(..))",
        throwing = "ex"
    )
    public void logException(Exception ex) {
        System.err.println("方法抛出异常: " + ex.getMessage());
        // 发送告警
        alertService.sendAlert(ex);
    }
}

@Aspect
@Component
public class CleanupAspect {

    @After("execution(* com.example.service.*.*(..))")
    public void doCleanup() {
        // 清理工作
        ThreadLocalContext.clear();
        System.out.println("清理工作完成");
    }
}

@Aspect
@Component
public class AroundAspectExample {

    // 示例1：统计方法执行时间
    @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 cost = System.currentTimeMillis() - startTime;
            String methodName = joinPoint.getSignature().toShortString();
            System.out.println(methodName + " 执行耗时: " + cost + " ms");
        }
    }

    // 示例2：缓存
    @Around("execution(* com.example.service.*.findById(..)) && args(id)")
    public Object cacheResult(ProceedingJoinPoint joinPoint, Long id) throws Throwable {
        String cacheKey = "user:" + id;
        Object cachedValue = cacheService.get(cacheKey);

        if (cachedValue != null) {
            System.out.println("命中缓存: " + cacheKey);
            return cachedValue;
        }

        Object result = joinPoint.proceed();

        if (result != null) {
            cacheService.set(cacheKey, result, 3600);
        }

        return result;
    }

    // 示例3：重试机制
    @Around("@annotation(retry)")
    public Object retryOnFailure(ProceedingJoinPoint joinPoint, Retry retry) throws Throwable {
        int maxAttempts = retry.maxAttempts();
        int attempt = 0;
        Throwable lastException;

        do {
            attempt++;
            try {
                return joinPoint.proceed();
            } catch (Throwable ex) {
                lastException = ex;
                if (attempt < maxAttempts) {
                    System.out.println("第 " + attempt + " 次尝试失败，准备重试");
                    Thread.sleep(retry.delay());
                }
            }
        } while (attempt < maxAttempts);

        throw lastException;
    }
}

// 重试注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Retry {
    int maxAttempts() default 3;
    long delay() default 1000;
}

@Around 前置 → @Before → 目标方法 → @AfterReturning/@AfterThrowing → @After → @Around 后置

@Aspect
@Component
@Order(1)  // 数字越小，优先级越高（最先进入，最后退出）
public class LoggingAspect {
    // ...
}

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

@AfterReturning → @After

@Service
public class OrderService {

    public void createOrder() {
        // 直接调用同类方法，不经过代理
        validateOrder();  // × AOP 不生效
    }

    @Transactional
    public void validateOrder() {
        // 事务不生效
    }
}

// 方案1：注入自己，通过代理调用（推荐）
@Service
public class OrderService {

    @Autowired
    private OrderService self;  // 注入自己

    public void createOrder() {
        self.validateOrder();  // √ 经过代理
    }

    @Transactional
    public void validateOrder() {
        // 事务生效
    }
}

// 方案2：使用 AopContext 获取当前代理对象
@Service
public class OrderService {

    public void createOrder() {
        OrderService proxy = (OrderService) AopContext.currentProxy();
        proxy.validateOrder();  // √ 经过代理
    }

    @Transactional
    public void validateOrder() {
        // 事务生效
    }
}

// 注意：使用 AopContext 需要配置
@EnableAspectJAutoProxy(exposeProxy = true)

@Component
public class UserService {
    // final 成员变量
    public final ZoneId zoneId = ZoneId.systemDefault();

    public ZoneId getZoneId() {
        return zoneId;
    }

    public final ZoneId getFinalZoneId() {
        return zoneId;
    }
}

@Component
public class MailService {
    @Autowired
    UserService userService;

    public String sendMail() {
        ZoneId zoneId = userService.zoneId;  // 直接访问字段
        return "Hello, it is " + ZonedDateTime.now(zoneId).toString();
    }
}

// 我们写的代码
public class UserService {
    public final ZoneId zoneId = ZoneId.systemDefault();
    public UserService() {}
}

// 编译器实际生成的代码
public class UserService {
    public final ZoneId zoneId;
    public UserService() {
        super();                          // 自动添加
        zoneId = ZoneId.systemDefault();  // 成员变量初始化移入构造方法
    }
}

@Component
public class MailService {
    @Autowired
    UserService userService;

    public String sendMail() {
        // × 直接访问字段：proxy.zoneId = null
        // ZoneId zoneId = userService.zoneId;

        // √ 通过方法访问：代理类覆写了 getZoneId()，委托给原始实例
        ZoneId zoneId = userService.getZoneId();
        return "Hello, it is " + ZonedDateTime.now(zoneId).toString();
    }
}

// CGLIB 生成的代理类（伪代码）
public class UserService$$EnhancerBySpringCGLIB extends UserService {
    private UserService target;  // 持有原始实例

    @Override
    public ZoneId getZoneId() {
        return target.getZoneId();  // 委托给原始实例，zoneId 已正确初始化
    }
}

DEBUG o.s.aop.framework.CglibAopProxy - Final method [public final java.time.ZoneId
  xxx.UserService.getFinalZoneId()] cannot get proxied via CGLIB:
  Calls to this method will NOT be routed to the target instance and might
  lead to NPEs against uninitialized fields in the proxy instance.

public interface UserService {
    User getUser(Long id);
}

@Service
public class UserServiceImpl implements UserService {
    @Override
    public User getUser(Long id) {
        return userRepository.findById(id);
    }
}

// 另一个 Bean 注入时
@Service
public class OrderService {
    // × 注入实现类类型
    @Autowired
    private UserServiceImpl userServiceImpl;
}

Bean not of required type [com.example.service.UserServiceImpl]

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    // × 构造方法中调用被代理方法
    public UserService() {
        initUserCache();  // 此时代理对象还未创建
    }

    @Cacheable("userCache")
    public List<User> initUserCache() {
        return userRepository.findAll();
    }
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    // √ 使用 @PostConstruct，在 Bean 初始化后执行
    @PostConstruct
    public void init() {
        initUserCache();  // 此时代理对象已创建
    }

    @Cacheable("userCache")
    public List<User> initUserCache() {
        return userRepository.findAll();
    }
}

@Service
public class UserService {

    @Transactional
    private void internalMethod() {
        // × 事务不生效，private 方法无法被代理
    }
}

@Service
public final class FinalService {

    @Transactional
    public void doSomething() {
        // × 如果使用 CGLIB，final 类无法被代理
    }
}

@Service
public class OrderService {

    @Transactional
    public void createOrder() {
        try {
            orderDao.save(order);
            inventoryService.deduct(order);  // 可能抛异常
        } catch (Exception e) {
            log.error("创建订单失败", e);
            // × 异常被吞掉，事务不会回滚
        }
    }
}

// 解决方案1：重新抛出异常
@Transactional
public void createOrder() {
    try {
        orderDao.save(order);
        inventoryService.deduct(order);
    } catch (Exception e) {
        log.error("创建订单失败", e);
        throw e;  // √ 重新抛出，事务回滚
    }
}

// 解决方案2：手动标记回滚
@Transactional
public void createOrder() {
    try {
        orderDao.save(order);
        inventoryService.deduct(order);
    } catch (Exception e) {
        log.error("创建订单失败", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();  // √ 手动回滚
    }
}

// 1. 检查是否创建了代理对象
AopUtils.isAopProxy(bean);          // 是否是代理
AopUtils.isCglibProxy(bean);        // 是否是 CGLIB 代理
AopUtils.isJdkDynamicProxy(bean);   // 是否是 JDK 代理

// 2. 查看代理对象的 Advisor 链
Advisor[] advisors = ((Advised) bean).getAdvisors();

// 3. 查看实际类型
bean.getClass().getName();
// 输出: UserService$$EnhancerBySpringCGLIB$$1c76af9d

# application.yml
logging:
  level:
    org.springframework.aop: DEBUG
    org.springframework.beans.factory.support.DefaultListableBeanFactory: DEBUG

@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Override
    public void transfer(String outUser, String inUser, Double money) {
        accountDao.out(outUser, money);  // 成功提交
        int i = 1 / 0;                   // 模拟异常
        accountDao.in(inUser, money);     // 未执行，钱转出了但对方没收到
    }
}

// × 每个方法都重复事务模板代码
public void transfer(String outUser, String inUser, Double money) {
    try {
        transactionManager.beginTransaction();
        accountDao.out(outUser, money);
        accountDao.in(inUser, money);
        transactionManager.commit();
    } catch (Exception e) {
        transactionManager.rollback();
    } finally {
        transactionManager.release();
    }
}

// √ 业务代码只关注业务
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Transactional  // 声明式事务，AOP 自动织入
    @Override
    public void transfer(String outUser, String inUser, Double money) {
        accountDao.out(outUser, money);
        accountDao.in(inUser, money);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd
           http://www.springframework.org/schema/context
           https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 启用 AspectJ 自动代理（等价于 @EnableAspectJAutoProxy） -->
    <aop:aspectj-autoproxy/>

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.example"/>

</beans>

<aop:config>
    <!-- 定义切入点 -->
    <aop:pointcut id="serviceMethod"
        expression="execution(* com.example.service.*.*(..))"/>

    <!-- 定义切面 -->
    <aop:aspect id="loggingAspect" ref="loggingAdvice">
        <!-- 前置通知 -->
        <aop:before pointcut-ref="serviceMethod" method="beforeAdvice"/>
        <!-- 环绕通知 -->
        <aop:around pointcut-ref="serviceMethod" method="aroundAdvice"/>
        <!-- 后置返回通知 -->
        <aop:after-returning pointcut-ref="serviceMethod"
            method="afterReturningAdvice" returning="result"/>
        <!-- 异常通知 -->
        <aop:after-throwing pointcut-ref="serviceMethod"
            method="afterThrowingAdvice" throwing="ex"/>
        <!-- 最终通知 -->
        <aop:after pointcut-ref="serviceMethod" method="afterAdvice"/>
    </aop:aspect>
</aop:config>

<!-- 切面逻辑类（普通 Bean，无需 @Aspect 注解） -->
<bean id="loggingAdvice" class="com.example.advice.LoggingAdvice"/>

// 纯 XML 方式的切面类：不需要任何注解
public class LoggingAdvice {

    public void beforeAdvice(JoinPoint joinPoint) {
        System.err.println("[Before] " + joinPoint.getSignature().getName());
    }

    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        System.err.println("[Around] start " + pjp.getSignature());
        Object result = pjp.proceed();
        System.err.println("[Around] done " + pjp.getSignature());
        return result;
    }

    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        System.err.println("[AfterReturning] result = " + result);
    }

    public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {
        System.err.println("[AfterThrowing] exception = " + ex.getMessage());
    }

    public void afterAdvice(JoinPoint joinPoint) {
        System.err.println("[After] " + joinPoint.getSignature().getName());
    }
}

<!-- 强制使用 CGLIB 代理（Spring Boot 2.x+ 默认行为） -->
<aop:aspectj-autoproxy proxy-target-class="true"/>

<!-- 暴露代理对象（等价于 @EnableAspectJAutoProxy(exposeProxy = true)） -->
<aop:aspectj-autoproxy expose-proxy="true"/>