如何快速上手【Spring AOP】？从动态代理到源码剖析（下篇）

// 定义房屋交易业务接口
public interface HouseSubject {
    void saleHouse();  // 房屋出售业务
    void rentHouse();  // 房屋租赁业务
}

// 实现具体的房屋交易业务
public class RealHouseSubject implements HouseSubject {
    @Override
    public void saleHouse() {
        System.out.println("业主执行房屋出售流程：签订合同 → 办理过户");
    }

    @Override
    public void rentHouse() {
        System.out.println("业主执行房屋租赁流程：签订租约 → 交付房屋");
    }
}

// 中介代理类，增强房屋交易流程
public class HouseProxy implements HouseSubject {
    private HouseSubject realSubject;  // 持有真实主题引用

    // 通过构造器注入真实主题实例
    public HouseProxy(HouseSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void saleHouse() {
        // 前置增强逻辑：中介审核房源
        System.out.println("[中介] 审核房屋产权证明 → 评估市场价格 → 发布出售信息");
        // 调用真实主题业务方法
        realSubject.saleHouse();
        // 后置增强逻辑：中介跟进交易
        System.out.println("[中介] 协助办理水电过户 → 交易归档\n");
    }

    @Override
    public void rentHouse() {
        // 前置增强逻辑：中介筛选租客
        System.out.println("[中介] 核实租客身份 → 签订租赁担保协议");
        // 调用真实主题业务方法
        realSubject.rentHouse();
        // 后置增强逻辑：中介定期巡检
        System.out.println("[中介] 每月房屋状况巡检 → 租金代收\n");
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建真实业务对象
        HouseSubject realHouse = new RealHouseSubject();
        // 创建代理对象并注入真实业务对象
        HouseProxy proxy = new HouseProxy(realHouse);
        
        // 通过代理执行房屋出售
        proxy.saleHouse();
        // 通过代理执行房屋租赁
        proxy.rentHouse();
    }
}

[中介] 审核房屋产权证明 → 评估市场价格 → 发布出售信息
业主执行房屋出售流程：签订合同 → 办理过户
[中介] 协助办理水电过户 → 交易归档

[中介] 核实租客身份 → 签订租赁担保协议
业主执行房屋租赁流程：签订租约 → 交付房屋
[中介] 每月房屋状况巡检 → 租金代收

public class JDKInvocationHandler implements InvocationHandler {
    private final Object target; // 目标对象

    public JDKInvocationHandler(Object target) {
        this.target = target;
    }

    /**
     * 代理方法调用的转发入口
     * @param proxy 生成的代理对象
     * @param method 目标方法
     * @param args 方法参数
     * @return 方法执行结果
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1. 增强逻辑（前置处理）
        System.out.println("JDK Proxy: 执行前置增强");
        
        // 2. 调用目标方法
        Object result = method.invoke(target, args);
        
        // 3. 增强逻辑（后置处理）
        System.out.println("JDK Proxy: 执行后置增强");
        
        return result;
    }

    // 创建代理对象
    public static Object createProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(), // 类加载器：用于加载动态生成的代理类
            target.getClass().getInterfaces(),   // 目标接口数组：代理类需实现的接口
            new JDKInvocationHandler(target)     // InvocationHandler实例：处理代理逻辑
        );
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CGlibMethodInterceptor implements MethodInterceptor {
    private final Object target; // 目标对象

    public CGlibMethodInterceptor(Object target) {
        this.target = target;
    }

    /**
     * 代理方法调用的拦截入口
     * @param obj 生成的代理对象
     * @param method 目标方法
     * @param args 方法参数
     * @param methodProxy 方法代理对象（用于高效调用父类方法）
     * @return 方法执行结果
     */
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 1. 增强逻辑（前置处理）
        System.out.println("CGLIB Proxy: 执行前置增强");
        
        // 2. 调用目标方法（推荐使用methodProxy.invokeSuper提高性能）
        Object result = methodProxy.invokeSuper(obj, args); 
        // 等价于：method.invoke(target, args)，但invokeSuper性能更优
        
        // 3. 增强逻辑（后置处理）
        System.out.println("CGLIB Proxy: 执行后置增强");
        
        return result;
    }

    // 创建代理对象
    public static Object createProxy(Class<?> targetClass) {
        return Enhancer.create(
            targetClass,                // 目标类Class对象：指定被代理的类
            new CGlibMethodInterceptor() // MethodInterceptor实例：处理代理逻辑
        );
    }
}

AbstractAutoProxyCreator 
└── AbstractAdvisorAutoProxyCreator
    └── AnnotationAwareAspectJAutoProxyCreator

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 判断是否需要跳过代理（如AOP基础设施类本身）
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 核心逻辑：判断是否需要创建代理并执行
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 1. 如果已处理过或无需代理（如Advice/Pointcut类型Bean），直接返回原Bean
    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    // 2. 检查是否需要跳过（如AOP基础设施类）
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 3. 核心：获取匹配当前Bean的Advisor列表
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) { // 存在匹配的Advisor，需要代理
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 4. 创建代理对象
        Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                             @Nullable Object[] specificInterceptors, TargetSource targetSource) {
    // 1. 创建ProxyFactory并配置参数（目标类、Advisor、是否暴露代理等）
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    // 2. 配置代理目标类
    if (!proxyFactory.isProxyTargetClass()) {
        // 根据目标类是否实现接口决定是否使用CGLIB
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        } else {
            // 注册目标类实现的接口
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    // 3. 添加Advisor（通知+切入点）
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    proxyFactory.addAdvisors(advisors);
    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);

    // 4. 生成代理对象
    return proxyFactory.getProxy(getProxyClassLoader());
}