以下是按你的要求生成的 Spring AOP 原理文章，标题已融入“采购助手ai”并控制在30字以内，全文按照技术科普 + 原理讲解 + 代码示例 + 面试要点的结构组织。

public class OrderService {
    public void createOrder(Order order) {
        // 日志记录（重复代码）
        System.out.println("【日志】开始创建订单");
        // 权限校验（重复代码）
        if (!checkPermission()) throw new RuntimeException("无权限");
        // 核心业务逻辑
        System.out.println("执行业务：创建订单");
        // 日志记录（重复代码）
        System.out.println("【日志】创建订单完成");
    }
    
    public void cancelOrder(Long orderId) {
        // 同样的日志和权限代码再次出现...
    }
}

// 1. 定义接口（JDK 代理强制要求）
public interface UserService {
    void save();
}

// 2. 目标类实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        System.out.println("保存用户数据");
    }
}

// 3. 编写 InvocationHandler（定义增强逻辑）
public class LogHandler implements InvocationHandler {
    private Object target;
    
    public LogHandler(Object target) { this.target = target; }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("【前置增强】开始执行：" + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("【后置增强】执行完成：" + method.getName());
        return result;
    }
}

// 4. 生成代理对象
public class Main {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LogHandler(target)
        );
        proxy.save();
    }
}

【前置增强】开始执行：save
保存用户数据
【后置增强】执行完成：save

if (目标类实现了接口) {
    使用 JDK 动态代理（默认）
} else {
    使用 CGLIB 动态代理
}

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

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.;
import org.springframework.stereotype.Component;

@Aspect               // 标记这是一个切面类
@Component            // 交给 Spring 容器管理（关键！）
public class LogAspect {
    
    // 定义切点：拦截 com.example.service 包下所有类的所有方法
    @Pointcut("execution( com.example.service..(..))")
    public void serviceMethod() {}
    
    // 前置通知：方法执行前触发
    @Before("serviceMethod()")
    public void beforeMethod(JoinPoint joinPoint) {
        System.out.println("【Before】开始执行：" + joinPoint.getSignature().getName());
    }
    
    // 后置通知：方法执行后触发（无论是否异常）
    @After("serviceMethod()")
    public void afterMethod(JoinPoint joinPoint) {
        System.out.println("【After】执行完成：" + joinPoint.getSignature().getName());
    }
    
    // 环绕通知：完全控制方法执行（最强大）
    @Around("serviceMethod()")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("【Around】方法开始：" + joinPoint.getSignature().getName());
        
        Object result = joinPoint.proceed();  // 调用目标方法
        
        long end = System.currentTimeMillis();
        System.out.println("【Around】方法结束，耗时：" + (end - start) + "ms");
        return result;
    }
}

Spring 容器启动 → Bean 实例化 → 依赖注入 → Bean 初始化 
→ postProcessAfterInitialization() → 判断是否需要代理 
→ 创建代理对象 → 将代理对象放入容器（替换原对象）

public Object postProcessAfterInitialization(Object bean, String beanName) {
    // 查找当前 Bean 需要应用的增强（Advice）
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean);
    if (specificInterceptors != DO_NOT_PROXY) {
        // 创建代理对象
        return createProxy(bean.getClass(), beanName, specificInterceptors, bean);
    }
    return bean;
}