【JAVA 进阶】Spring AOP核心原理：JDK与CGLib动态代理实战解析

public interface InvocationHandler {
    /**
     * 代理对象方法调用的核心处理方法
     * @param proxy 代理对象本身
     * @param method 被调用的目标方法
     * @param args 目标方法的参数数组
     * @return 目标方法的返回值
     * @throws Throwable 目标方法可能抛出的异常
     */
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

// 目标接口
public interface UserService {
    // 查询用户
    User findUserById(Long id);
    // 新增用户
    void addUser(User user);
}

// 目标对象（业务实现类）
public class UserServiceImpl implements UserService {
    @Override
    public User findUserById(Long id) {
        // 模拟数据库查询
        System.out.println("执行数据库查询：根据ID=" + id + "查询用户");
        return new User(id, "张三", 25);
    }

    @Override
    public void addUser(User user) {
        // 模拟数据库新增
        System.out.println("执行数据库新增：添加用户" + user.getName());
    }
}

// 实体类User
public class User {
    private Long id;
    private String name;
    private Integer age;

    // 构造方法、getter、setter省略
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.time.LocalDateTime;

public class LogInvocationHandler implements InvocationHandler {
    // 目标对象（被代理的业务对象）
    private Object target;

    // 构造方法注入目标对象
    public LogInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1. 前置通知：日志记录（方法调用时间、方法名）
        String methodName = method.getName();
        System.out.println("【日志前置通知】" + LocalDateTime.now() + " 调用方法：" + methodName);

        // 2. 调用目标对象的原始方法
        Object result = null;
        try {
            result = method.invoke(target, args);
            // 3. 返回通知：记录方法返回值
            System.out.println("【日志返回通知】方法" + methodName + "返回值：" + (result == null ? "无" : result.toString()));
        } catch (Exception e) {
            // 4. 异常通知：记录方法异常信息
            System.out.println("【日志异常通知】方法" + methodName + "抛出异常：" + e.getMessage());
            throw e; // 抛出异常，不影响业务逻辑
        } finally {
            // 5. 后置通知：记录方法调用结束
            System.out.println("【日志后置通知】方法" + methodName + "调用结束\n");
        }

        return result;
    }
}

import java.lang.reflect.Proxy;

public class JdkProxyTest {
    public static void main(String[] args) {
        // 1. 创建目标对象
        UserService target = new UserServiceImpl();

        // 2. 创建InvocationHandler实例（传入目标对象）
        LogInvocationHandler invocationHandler = new LogInvocationHandler(target);

        // 3. 生成代理对象：参数分别为目标类加载器、目标接口数组、InvocationHandler
        UserService proxy = (UserService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                invocationHandler
        );

        // 4. 调用代理对象的方法
        proxy.findUserById(1L);
        proxy.addUser(new User(2L, "李四", 30));
    }
}

public final class $Proxy0 extends Proxy implements UserService {
    // 静态代码块：获取目标接口的方法实例
    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.example.service.UserService").getMethod("findUserById", Class.forName("java.lang.Long"));
            m4 = Class.forName("com.example.service.UserService").getMethod("addUser", Class.forName("com.example.entity.User"));
            // ...省略其他方法
        } catch (NoSuchMethodException e) {
            throw new NoSuchMethodError(e.getMessage());
        }
    }

    // 构造方法：接收InvocationHandler参数并传给父类Proxy
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    // 实现UserService的findUserById方法
    public final User findUserById(Long var1) throws  {
        try {
            // 调用InvocationHandler的invoke方法
            return (User)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    // 实现UserService的addUser方法
    public final void addUser(User var1) throws  {
        try {
            // 调用InvocationHandler的invoke方法
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
}

public interface MethodInterceptor extends Callback {
    /**
     * 代理对象方法调用的核心处理方法
     * @param obj 代理对象
     * @param method 被调用的目标方法
     * @param args 目标方法的参数数组
     * @param proxy MethodProxy对象，用于调用目标方法（比反射更高效）
     * @return 目标方法的返回值
     * @throws Throwable 目标方法可能抛出的异常
     */
    Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
}

// 无接口的目标对象
public class OrderService {
    // 订单查询方法
    public Order findOrderById(Long id) {
        System.out.println("执行数据库查询：根据ID=" + id + "查询订单");
        return new Order(id, "20251205001", 199.9);
    }

    // 订单创建方法
    public void createOrder(Order order) {
        System.out.println("执行数据库新增：创建订单" + order.getOrderNo());
        // 模拟异常场景
        // if (order.getAmount() < 0) {
        //     throw new IllegalArgumentException("订单金额不能为负数");
        // }
    }
}

// 实体类Order
public class Order {
    private Long id;
    private String orderNo;
    private Double amount;

    // 构造方法、getter、setter省略
}

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import java.time.LocalDateTime;

public class LogMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 1. 前置通知：日志记录
        String methodName = method.getName();
        System.out.println("【CGLib日志前置通知】" + LocalDateTime.now() + " 调用方法：" + methodName);

        // 2. 调用目标对象的原始方法（通过MethodProxy调用，效率更高）
        Object result = null;
        try {
            result = proxy.invokeSuper(obj, args); // 注意：此处是invokeSuper，调用父类（目标类）的方法
            // 3. 返回通知
            System.out.println("【CGLib日志返回通知】方法" + methodName + "返回值：" + (result == null ? "无" : result.toString()));
        } catch (Exception e) {
            // 4. 异常通知
            System.out.println("【CGLib日志异常通知】方法" + methodName + "抛出异常：" + e.getMessage());
            throw e;
        } finally {
            // 5. 后置通知
            System.out.println("【CGLib日志后置通知】方法" + methodName + "调用结束\n");
        }

        return result;
    }
}

import net.sf.cglib.proxy.Enhancer;

public class CglibProxyTest {
    public static void main(String[] args) {
        // 1. 创建目标对象
        OrderService target = new OrderService();

        // 2. 创建方法拦截器实例
        LogMethodInterceptor interceptor = new LogMethodInterceptor();

        // 3. 创建Enhancer对象（代理生成器）
        Enhancer enhancer = new Enhancer();
        // 设置目标类为父类（代理类继承自目标类）
        enhancer.setSuperclass(OrderService.class);
        // 设置方法拦截器（代理类的方法调用会委托给该拦截器）
        enhancer.setCallback(interceptor);

        // 4. 生成代理对象（通过create方法）
        OrderService proxy = (OrderService) enhancer.create();

        // 5. 调用代理对象的方法
        proxy.findOrderById(1L);
        proxy.createOrder(new Order(2L, "20251205002", 299.9));

        // 测试异常场景（解开OrderService中createOrder的异常注释）
        // proxy.createOrder(new Order(3L, "20251205003", -50.0));
    }
}

public class OrderService$$EnhancerByCGLIB$$1234 extends OrderService implements Factory {
    // MethodProxy对象，用于调用目标方法
    private static MethodProxy CGLIB_findOrderById_0;
    private static MethodProxy CGLIB_createOrder_1;

    // 静态代码块：初始化MethodProxy
    static {
        CGLIB_findOrderById_0 = MethodProxy.create(
            OrderService.class, 
            OrderService$$EnhancerByCGLIB$$1234.class, 
            "(Ljava/lang/Long;)Lcom/example/entity/Order;", 
            "findOrderById", 
            "CGLIB$findOrderById$0"
        );
        // ...初始化其他MethodProxy
    }

    // 重写findOrderById方法
    @Override
    public Order findOrderById(Long var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        // 调用MethodInterceptor的intercept方法
        return var10000 != null ? (Order)var10000.intercept(
            this, 
            CGLIB$findOrderById$0$Method, 
            new Object[]{var1}, 
            CGLIB_findOrderById_0
        ) : super.findOrderById(var1);
    }

    // 目标方法的快速调用方法（由MethodProxy调用）
    final Order CGLIB$findOrderById$0(Long var1) {
        return super.findOrderById(var1);
    }

    // ...其他重写方法和辅助方法
}

public class ProxyPerformanceTest {
    public static void main(String[] args) {
        // 测试次数
        int count = 1000000;

        // JDK动态代理性能测试
        UserService jdkTarget = new UserServiceImpl();
        UserService jdkProxy = (UserService) Proxy.newProxyInstance(
            jdkTarget.getClass().getClassLoader(),
            jdkTarget.getClass().getInterfaces(),
            new LogInvocationHandler(jdkTarget)
        );
        long jdkStart = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            jdkProxy.findUserById(1L);
        }
        long jdkEnd = System.currentTimeMillis();
        System.out.println("JDK动态代理100万次调用耗时：" + (jdkEnd - jdkStart) + "ms");

        // CGLib动态代理性能测试
        OrderService cglibTarget = new OrderService();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(OrderService.class);
        enhancer.setCallback(new LogMethodInterceptor());
        OrderService cglibProxy = (OrderService) enhancer.create();
        long cglibStart = System.currentTimeMillis();
        for (int i = 0; i < count; i++) {
            cglibProxy.findOrderById(1L);
        }
        long cglibEnd = System.currentTimeMillis();
        System.out.println("CGLib动态代理100万次调用耗时：" + (cglibEnd - cglibStart) + "ms");
    }
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;

// 切面类：日志切面
@Aspect
@Component
public class LogAspect {
    // 切入点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void servicePointcut() {}

    // 前置通知
    @Before("servicePointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP前置通知】" + LocalDateTime.now() + " 调用方法：" + methodName);
    }

    // 后置通知
    @After("servicePointcut()")
    public void afterAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP后置通知】方法" + methodName + "调用结束");
    }

    // 返回通知
    @AfterReturning(value = "servicePointcut()", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP返回通知】方法" + methodName + "返回值：" + (result == null ? "无" : result));
    }

    // 异常通知
    @AfterThrowing(value = "servicePointcut()", throwing = "ex")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP异常通知】方法" + methodName + "抛出异常：" + ex.getMessage());
    }

    // 环绕通知
    @Around("servicePointcut()")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP环绕通知-前】" + LocalDateTime.now() + " 准备调用方法：" + methodName);
        Object result = null;
        try {
            // 执行目标方法
            result = joinPoint.proceed();
            System.out.println("【Spring AOP环绕通知-后】方法" + methodName + "执行完成");
        } catch (Throwable e) {
            System.out.println("【Spring AOP环绕通知-异常】方法" + methodName + "执行异常：" + e.getMessage());
            throw e;
        }
        return result;
    }
}

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;

// 切面类：日志切面
@Aspect
@Component
public class LogAspect {
    // 切入点：匹配com.example.service包下所有类的所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void servicePointcut() {}

    // 前置通知
    @Before("servicePointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP前置通知】" + LocalDateTime.now() + " 调用方法：" + methodName);
    }

    // 后置通知
    @After("servicePointcut()")
    public void afterAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP后置通知】方法" + methodName + "调用结束");
    }

    // 返回通知
    @AfterReturning(value = "servicePointcut()", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP返回通知】方法" + methodName + "返回值：" + (result == null ? "无" : result));
    }

    // 异常通知
    @AfterThrowing(value = "servicePointcut()", throwing = "ex")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP异常通知】方法" + methodName + "抛出异常：" + ex.getMessage());
    }

    // 环绕通知
    @Around("servicePointcut()")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("【Spring AOP环绕通知-前】" + LocalDateTime.now() + " 准备调用方法：" + methodName);
        Object result = null;
        try {
            // 执行目标方法
            result = joinPoint.proceed();
            System.out.println("【Spring AOP环绕通知-后】方法" + methodName + "执行完成");
        } catch (Throwable e) {
            System.out.println("【Spring AOP环绕通知-异常】方法" + methodName + "执行异常：" + e.getMessage());
            throw e;
        }
        return result;
    }
}