朱雀助手ai深度剖析：2026年4月10日Spring AOP核心原理与面试考点

// 传统写法：每个业务方法都要手动添加日志和事务逻辑
@Service
public class OrderServiceImpl implements OrderService {
    
    @Override
    public void createOrder(Order order) {
        // 重复代码：日志记录
        log.info("开始创建订单，参数：{}", order);
        // 重复代码：权限校验
        if (!hasPermission()) throw new SecurityException("无权限");
        // 重复代码：开启事务
        beginTransaction();
        
        // 核心业务逻辑（只有这几行是真正的业务）
        orderRepository.save(order);
        
        // 重复代码：提交事务
        commitTransaction();
        log.info("订单创建成功");
    }
    
    @Override
    public void updateOrder(Order order) {
        // 同样的日志、权限、事务代码又要写一遍
        log.info("开始更新订单...");
        // ... 重复的横切逻辑
    }
}

@Component
@Aspect
public class LoggingAspect {
    
    @Before("execution( com.example.service..(..))")
    public void logBefore(JoinPoint jp) {
        // 前置通知：目标方法执行前运行
        System.out.println("方法即将执行：" + jp.getSignature());
    }
    
    @After("execution( com.example.service..(..))")
    public void logAfter(JoinPoint jp) {
        // 后置通知：目标方法执行后运行（无论是否异常，类似finally）
        System.out.println("方法执行完毕");
    }
    
    @AfterReturning(pointcut = "execution( com.example.service..(..))", returning = "result")
    public void logAfterReturning(JoinPoint jp, Object result) {
        // 返回通知：方法正常返回后运行
        System.out.println("方法返回：" + result);
    }
    
    @AfterThrowing(pointcut = "execution( com.example.service..(..))", throwing = "ex")
    public void logException(JoinPoint jp, Exception ex) {
        // 异常通知：方法抛出异常时运行
        System.out.println("方法异常：" + ex.getMessage());
    }
    
    @Around("execution( com.example.service..(..))")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        // 环绕通知：最强大，前后都能控制，需手动调用pjp.proceed()
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();  // 必须手动调用目标方法
        long cost = System.currentTimeMillis() - start;
        System.out.println("方法耗时：" + cost + "ms");
        return result;
    }
}

第一层：AOP（编程范式/设计思想）
    ↓ 具体实现
第二层：Spring AOP（轻量级实现，基于动态代理，运行时织入）
    ↓ 语法借用
第三层：AspectJ注解（@Aspect、@Pointcut等，Spring AOP借用了这套注解语法）

// 1. 定义接口
public interface UserService {
    void saveUser(String name);
}

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

// 3. 手动创建代理类（问题：每个业务类都要写一个代理类）
public class UserServiceProxy implements UserService {
    private UserService target;
    
    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void saveUser(String name) {
        // 手动添加增强逻辑
        System.out.println("【前置】开始保存用户");
        target.saveUser(name);
        System.out.println("【后置】用户保存成功");
    }
}

// 1. 业务代码保持纯粹，没有任何侵入
@Service
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(String name) {
        System.out.println("保存用户：" + name);  // 只有核心业务
    }
}

// 2. 切面类集中管理增强逻辑
@Component
@Aspect  // 标记这是一个切面类
public class LogAspect {
    
    // 定义切点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethod() {}
    
    // 环绕通知：集中处理日志和耗时统计
    @Around("serviceMethod()")
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long begin = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        
        System.out.println("【AOP】方法" + methodName + "开始执行");
        Object result = joinPoint.proceed();  // 调用原始业务方法
        long end = System.currentTimeMillis();
        
        System.out.println("【AOP】方法" + methodName + "执行耗时：" + (end - begin) + "ms");
        return result;
    }
}

// 3. 启用AOP自动代理
@Configuration
@EnableAspectJAutoProxy  // 开启基于注解的AOP支持
public class AppConfig {
    // Spring Boot项目中，@SpringBootApplication已隐含此注解
}

调用方 → 代理对象（Spring生成的） → @Around前置逻辑 → 目标方法执行 → @Around后置逻辑 → 返回调用方

// AbstractAutoProxyCreator实现了BeanPostProcessor
public abstract class AbstractAutoProxyCreator implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 在Bean完成初始化后被调用
        return wrapIfNecessary(bean, beanName);
    }
    
    protected Object wrapIfNecessary(Object bean, String beanName) {
        // 1. 获取适用于当前Bean的所有通知器（Advisor）
        Object[] advisors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName);
        
        // 2. 如果有匹配的通知器，说明需要创建代理
        if (advisors.length > 0) {
            // 3. 创建代理对象，替代原始Bean
            return createProxy(bean, beanName, advisors);
        }
        return bean;  // 无需代理，返回原始Bean
    }
}