LOL助手AI深度解析：Spring AOP面向切面编程，从动态代理到底层实现全攻略（2026年4月更新）

public class OrderServiceImpl implements OrderService {
    
    @Override
    public void createOrder(Order order) {
        // 日志记录——重复代码开始
        System.out.println("〖LOG〗开始执行创建订单方法，参数：" + order);
        long startTime = System.currentTimeMillis();
        try {
            // 核心业务逻辑
            System.out.println("核心：创建订单业务逻辑");
        } catch (Exception e) {
            System.out.println("〖LOG〗方法执行异常：" + e.getMessage());
            throw e;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("〖LOG〗方法执行结束，耗时：" + (endTime - startTime) + "ms");
        // 日志记录——重复代码结束
    }
    
    @Override
    public void cancelOrder(Long orderId) {
        // 同样的日志代码又写了一遍...
    }
    
    @Override
    public void updateOrderStatus(Order order) {
        // 同样的日志代码又写了一遍...
    }
}

// 步骤1：定义接口（JDK代理要求必须有接口）
public interface UserService {
    void register(String username);
    void login(String username, String password);
}

// 步骤2：实现类
public class UserServiceImpl implements UserService {
    @Override
    public void register(String username) {
        System.out.println("核心业务：用户注册 -> " + username);
    }
    @Override
    public void login(String username, String password) {
        System.out.println("核心业务：用户登录 -> " + username);
    }
}

// 步骤3：手工实现AOP代理——这是最关键的代码！
import java.lang.reflect.;

public class ManualAopProxy {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) 
                        throws Throwable {
                    // 【前置增强】方法执行前记录日志
                    System.out.println("〖BEFORE〗即将执行方法：" + method.getName());
                    long startTime = System.currentTimeMillis();
                    
                    // 【核心】调用原始对象的方法
                    Object result = method.invoke(target, args);
                    
                    // 【后置增强】方法执行后记录耗时
                    long endTime = System.currentTimeMillis();
                    System.out.println("〖AFTER〗方法执行完成，耗时：" + 
                                       (endTime - startTime) + "ms");
                    return result;
                }
            }
        );
    }
}

// 测试运行
public class Main {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        UserService proxy = (UserService) ManualAopProxy.getProxy(target);
        proxy.register("张三");
        // 输出：
        // 〖BEFORE〗即将执行方法：register
        // 核心业务：用户注册 -> 张三
        // 〖AFTER〗方法执行完成，耗时：0ms
    }
}

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

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

@Aspect          // 标记该类为切面类
@Component       // 将切面类纳入Spring容器管理
public class LogAspect {
    
    // 定义切入点：匹配com.example.service包下所有类的所有public方法
    @Pointcut("execution(public  com.example.service..(..))")
    public void servicePointcut() {}
    
    // 前置通知：方法执行前执行
    @Before("servicePointcut()")
    public void logBefore() {
        System.out.println("〖前置通知〗方法开始执行");
    }
    
    // 后置返回通知：方法正常返回后执行
    @AfterReturning(pointcut = "servicePointcut()", returning = "result")
    public void logAfterReturning(Object result) {
        System.out.println("〖返回通知〗方法执行完毕，返回：" + result);
    }
    
    // 环绕通知：功能最强，可以完全控制方法执行过程
    @Around("servicePointcut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("〖环绕-前〗进入方法：" + methodName + "，参数：" + Arrays.toString(args));
        
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();  // 执行目标方法
        long endTime = System.currentTimeMillis();
        
        System.out.println("〖环绕-后〗方法执行完成，耗时：" + (endTime - startTime) + "ms");
        return result;
    }
    
    // 异常通知：方法抛出异常时执行
    @AfterThrowing(pointcut = "servicePointcut()", throwing = "ex")
    public void logAfterThrowing(Exception ex) {
        System.out.println("〖异常通知〗方法执行异常：" + ex.getMessage());
    }
}

if (目标类实现了接口) {
    优先使用 JDK 动态代理
} else {
    使用 CGLIB 代理
}

// 核心流程（简化版）
public Object postProcessAfterInitialization(Object bean, String beanName) {
    // 1. 查找当前Bean需要应用的增强（Advice）
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean);
    
    // 2. 如果需要增强，创建代理对象
    if (specificInterceptors != DO_NOT_PROXY) {
        return createProxy(bean.getClass(), beanName, specificInterceptors, bean);
    }
    
    // 3. 不需要增强，直接返回原Bean
    return bean;
}