考研AI助手精选｜Spring AOP面向切面编程原理与面试要点（2026年4月10日）

// 痛点示例：每个方法都要重复写日志、权限等代码
public void login() {
    log.info("登录开始");
    checkPermission();
    long start = System.currentTimeMillis();
    // 核心业务逻辑
    doLogin();
    log.info("登录结束，耗时: {}", System.currentTimeMillis() - start);
}

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

// execution方式：匹配特定包下的所有方法
@Around("execution( com.example.service..(..))")

// @annotation方式：匹配带有@Loggable注解的方法
@Before("@annotation(com.example.Loggable)")

@Service
public class UserServiceImpl implements UserService {
    @Override
    public User getUser(Long id) {
        // 重复的日志代码
        System.out.println("[LOG] 开始查询用户，id=" + id);
        long start = System.currentTimeMillis();
        
        // 核心业务逻辑
        User user = userDao.findById(id);
        
        System.out.println("[LOG] 查询完成，耗时=" + (System.currentTimeMillis() - start) + "ms");
        return user;
    }
    
    @Override
    public void updateUser(User user) {
        // 同样的重复代码又写一遍...
    }
}

// 1. 切面类：统一处理日志和性能监控
@Aspect
@Component
public class LogAspect {
    
    private static final Logger log = LoggerFactory.getLogger(LogAspect.class);
    
    // 定义切点：匹配service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethod() {}
    
    // 环绕通知：记录执行耗时
    @Around("serviceMethod()")
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long begin = System.currentTimeMillis();
        Object result = joinPoint.proceed();  // 调用原始业务方法
        long end = System.currentTimeMillis();
        log.info("{} 执行耗时: {} ms", joinPoint.getSignature().getName(), (end - begin));
        return result;
    }
}

// 2. 业务类：只关注核心逻辑，干净整洁
@Service
public class UserServiceImpl implements UserService {
    @Override
    public User getUser(Long id) {
        return userDao.findById(id);  // 只写业务逻辑
    }
}

@Aspect
@Component
public class FullAspect {
    
    @Pointcut("execution( com.example.service..(..))")
    public void pointcut() {}
    
    // 前置通知：方法执行前
    @Before("pointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("【@Before】方法执行前，参数：" + Arrays.toString(joinPoint.getArgs()));
    }
    
    // 后置返回通知：正常返回后
    @AfterReturning(pointcut = "pointcut()", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        System.out.println("【@AfterReturning】方法正常返回，结果：" + result);
    }
    
    // 异常通知：抛出异常时
    @AfterThrowing(pointcut = "pointcut()", throwing = "ex")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {
        System.out.println("【@AfterThrowing】方法异常：" + ex.getMessage());
    }
    
    // 最终通知：无论是否异常都执行
    @After("pointcut()")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("【@After】方法执行完毕（finally类似）");
    }
    
    // 环绕通知：最强大，完全控制执行过程
    @Around("pointcut()")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("【@Around】前置逻辑");
        Object result = joinPoint.proceed();  // 必须调用，否则原方法不执行
        System.out.println("【@Around】后置逻辑");
        return result;
    }
}

// Spring的DefaultAopProxyFactory中的核心选择逻辑
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    Class<?> targetClass = config.getTargetClass();
    if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
        return new JdkDynamicAopProxy(config);  // 接口 → JDK
    }
    return new ObjenesisCglibAopProxy(config); // 类 → CGLIB
} else {
    return new JdkDynamicAopProxy(config);
}