Spring AOP 切面中获取目标类原始对象之TargetSource 底层机制与原型 Bean 代理

[普通的直觉模型 (错误)]
  Proxy ---> 直接强引用 ---> 固定的 Target 实例
========================================================================
[Spring AOP 真实的物理内核 (TargetSource 解耦)]
  Proxy (动态代理对象)
    |
    v (每次方法调用均经过拦截器 proceed)
  ReflectiveMethodInvocation
    |
    v
  TargetSource.getTarget() <----+ 关键抽象! 每次调用时动态向 TargetSource 索要实例!
    |                           |
    +---> [1. SingletonTargetSource]  : 永远返回同一个单例 (Spring 默认行为)
    |
    +---> [2. PrototypeTargetSource]  : 每次方法调用都全新 new 一个实例!
    |
    +---> [3. ThreadLocalTargetSource]: 每个线程绑定独立的目标实例!
    |
    +---> [4. CustomHotSwapTargetSource]: 运行时动态无缝热替换目标实例!

// org.springframework.aop.TargetSource
public interface TargetSource extends TargetClassAware {
    @Override
    @Nullable
    Class<?> getTargetClass();
    boolean isStatic();
    // 核心方法 1: 获取当前调用的目标对象
    @Nullable
    Object getTarget() throws Exception;
    // 核心方法 2: 调用完毕后的释放钩子 (用于池化对象归还)
    void releaseTarget(Object target) throws Exception;
}

// org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    TargetSource targetSource = this.advised.getTargetSource();
    Object target = null;
    try {
        // 关键点！在真正调用方法前，向 targetSource 索要具体的物理对象！
        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);
        // 获取该方法的拦截器链 (Interceptors)
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
            // 没有拦截器，直接反射调用 target
            retVal = methodProxy.invoke(target, args);
        } else {
            // 进入经典的责任链驱动 ReflectiveMethodInvocation
            retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
        }
        return retVal;
    } finally {
        if (target != null && !targetSource.isStatic()) {
            // 关键点！如果是非静态 TargetSource (如 Prototype 或池化)，执行安全释放归还！
            targetSource.releaseTarget(target);
        }
    }
}

package com.yali.trade.engine;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.target.HotSwappableTargetSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class EngineHotSwapConfiguration {
    @Bean
    public CalculationEngine localRuleEngine() {
        return new LocalRuleCalculationEngine(); // 备用稳定引擎
    }
    @Bean
    public CalculationEngine aiDrivenEngine() {
        return new AiDrivenCalculationEngine(); // 主力智能引擎
    }
    /**
     * 构建 HotSwappable 目标源，初始指向 AI 引擎
     */
    @Bean
    public HotSwappableTargetSource calculationTargetSource(CalculationEngine aiDrivenEngine) {
        return new HotSwappableTargetSource(aiDrivenEngine);
    }
    /**
     * 对外暴露同一个 CalculationEngine 门面代理对象！
     */
    @Bean("dynamicCalculationEngine")
    public CalculationEngine dynamicCalculationEngine(HotSwappableTargetSource targetSource) {
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setInterfaces(CalculationEngine.class);
        // 将 HotSwappableTargetSource 绑定到底层代理工厂中！
        proxyFactory.setTargetSource(targetSource);
        return (CalculationEngine) proxyFactory.getProxy();
    }
}

package com.yali.trade.engine;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.aop.target.HotSwappableTargetSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Slf4j
@Service
@RequiredArgsConstructor
public class EngineSwitchService {
    private final HotSwappableTargetSource targetSource;
    @Qualifier("localRuleEngine")
    private final CalculationEngine localRuleEngine;
    @Qualifier("aiDrivenEngine")
    private final CalculationEngine aiDrivenEngine;
    /**
     * 应急逃生通道：一键原子热切换！
     */
    public void emergencyFallbackToLocal() {
        log.warn("🚨 触发应急指令：正在将全局算价引擎原子热替换为本地规则引擎！");
        // 核心方法：swap() 在内部通过 volatile 原语实现无锁原子引用替换！
        Object oldTarget = targetSource.swap(localRuleEngine);
        log.info("热替换成功生效！旧目标实例: {}, 新目标实例: {}", 
                oldTarget.getClass().getSimpleName(), localRuleEngine.getClass().getSimpleName());
    }
    public void restoreToAiEngine() {
        log.info("恢复 AI 驱动算价引擎...");
        targetSource.swap(aiDrivenEngine);
    }
}