动态代理机制
- 1. JDK 动态代理
- 2. CGLIB 动态代理
SpringBoot AOP 自动配置
AnnotationAwareAspectJAutoProxyCreator
代理创建过程
- 1. createProxy
- 2. createAopProxy
  - 2.1 JdkDynamicAopProxy
  - 2.2 CglibAopProxy

动态代理机制

Spring AOP 使用动态代理技术在运行期织入增强的代码，它使用了两种代理机制：一种是基于 JDK 的动态代理技术；另一种是基于 CGLib 的动态代理。之所以需要两种代理机制，很大程度上是因为 JDK 本身只提供接口的代理，而不支持类的代理。在 Spring Boot 中可通过如下配置指定代理方式：

# 为true采用CGLib动态代理，为false采用JDK动态代理
spring.aop.proxy-target-class=false

1. JDK 动态代理

JDK 动态代理允许开发者在运行期创建接口的代理实例，底层通过反射实现，主要涉及 java.lang.reflect 包中的两个类：Proxy 和 InvocationHandler。其中，InvocationHandler 是一个接口，可以通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态地将横切逻辑和业务逻辑编织在一起。而 Proxy 利用 InvocationHandler 动态创建一个符合某一接口的实例，生成目标类的代理对象。

public interface InvocationHandler {
    /**
     * proxy：最终生成的代理实例，一般不会用到
     * method：被代理目标实例的某个具体方法
     * args：被代理实例某个具体方法的入参，在方法反射调用时使用
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

JDK 动态代理使用示例：

public static void main(String[] args) {
    // 原始接口的实现类
    Bird eagle = new Eagle("老鹰");
    // 通过Proxy创建一个符合接口的代理实例
    Bird proxy = (Bird) Proxy.newProxyInstance(
        ClassLoader.getSystemClassLoader(),
        new Class[]{Bird.class},
        new BirdProxy(eagle));
    // 通过代理类去执行getName业务方法
    System.out.println(proxy.getName());
}
public class BirdProxy implements InvocationHandler {
    private final Bird bird;
    public BirdProxy(Bird bird) {
        this.bird = bird;
    }
    // 通过持有原实现类，在调用原实现类的逻辑前后可注入增强逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Get Bird Name");
        return method.invoke(bird, args);
    }
}

在使用 JDK 动态代理时，对于 InvocationHandler 的创建是最为核心的。在自定义的 InvocationHandler 中需要重写构造函数，将代理的对象传入，还需要重写 invoke 方法，此方法中实现了 AOP 增强的所有逻辑。

2. CGLIB 动态代理

使用 JDK 动态代理有一个限制，即它只能为接口创建代理实例。对于没有通过接口定义业务方法的类，我们可以通过 CGLib 动态创建代理实例。CGLib 采用动态字节码注入技术，可以为一个类创建子类，在子类中采用方法拦截的技术拦截所有父类方法的调用并顺势织入横切逻辑。但要注意，CGLib 不能对目标类中的 final 或 private 方法进行代理。CGLib 动态代理使用示例：

public class CglibProxy implements MethodInterceptor {
    // CGLib增强类
    private Enhancer enhancer = new Enhancer();
    public Object getProxy(Class clazz) {
        // 设置需要创建子类的类
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        // 通过字节码技术动态创建子类实例
        return enhancer.create();
    }
    // 拦截父类所有方法的调用
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before work......");
        // 通过代理类调用父类中的方法
        Object result = methodProxy.invokeSuper(o, objects);
        System.out.println("after work......");
        return result;
    }
    public static void main(String[] args) {
        CglibProxy proxy = new CglibProxy();
        // 通过动态生成子类的方式创建代理类
        Eagle eagle = (Eagle) proxy.getProxy(Eagle.class);
        eagle.getName();
    }
}

JDK 在创建代理对象时的性能高于 CGLib，但生成的代理对象的运行性能却比 CGLib 的低。如果是 singleton 的代理，则推荐使用 CGLib 动态代理。

SpringBoot AOP 自动配置

在 Spring Boot 的自动配置中有如下配置：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration

当引入 spring-boot-starter-aop 依赖后，AopAutoConfiguration 自动配置的创建条件就满足了。在它的自动配置逻辑中，其核心是引入了 @EnableAspectJAutoProxy 注解，其内容如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    /**
     * 动态代理方式采用CGLIB还是JDK，默认采用JDK动态代理，可通过spring.aop.proxy-target-class参数控制
     */
    boolean proxyTargetClass() default false;
  /**
   * 有时候目标对象内部的自我调用将无法实施切面中的增强
   * 当开启该属性后，内部方法调用可通过AopContext.currentProxy()获取当前代理类然后执行方法调用
   */
    boolean exposeProxy() default false;
}

其中又通过 @Import 注解引入了 AspectJAutoProxyRegistrar 类，它是 ImportBeanDefinitionRegistrar 接口的实现类，最终其执行的核心逻辑如下：

# 这里的cls为AnnotationAwareAspectJAutoProxyCreator
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);

可以看到，最终会向容器中注册一个 Bean 定义，类型为 AnnotationAwareAspectJAutoProxyCreator，这个 Bean 就用来处理当前 Spring 上下文中所有 AspectJ 注解方法的类。

AnnotationAwareAspectJAutoProxyCreator

首先，看下这个类的层次结构：

在类的层级中，我们看到它实现了 BeanPostProcessor 接口，而实现 BeanPostProcessor 后，当 Spring 加载这个 Bean 时会在实例化后调用其 postProcessAfterInitialization 方法，而我们对于 AOP 逻辑的分析也由此开始。这个方法的具体实现在其父类 AbstractAutoProxyCreator 中，具体代码如下：

@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 如果这个bean需要被代理，则要进行封装
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 如果已经处理过
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    // 无须增强
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    // 给定的bean类是否代表一个基础设施类，基础设施类不应被代理
    // 或者配置了指定bean不需要自动代理
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
    // 如果存在增强方法则创建代理类
    // 对标记为@Aspect注解的类进行增强器的提取
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    // 如果获取到了需要注入的增强逻辑则要针对增强创建代理
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 创建代理
        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;
}

代理创建过程

1. createProxy

// specificInterceptors为需要增强的逻辑
// targetSource用来保存原对象
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                             @Nullable Object[] specificInterceptors, TargetSource targetSource) {
    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }
    ProxyFactory proxyFactory = new ProxyFactory();
    // 获取当前类中相关属性
    proxyFactory.copyFrom(this);
    // 决定对于给定的bean是否应该使用targetClass而不是它的接口代理
    // 需要检查proxyTargeClass设置以及preserveTargetClass属性
    if (!proxyFactory.isProxyTargetClass()) {
        if (shouldProxyTargetClass(beanClass, beanName)) {
            // 直接对目标类进行代理
            proxyFactory.setProxyTargetClass(true);
        } else {
            // 添加代理接口
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    // 加入增强器
    proxyFactory.addAdvisors(advisors);
    // 设置要代理的类
    proxyFactory.setTargetSource(targetSource);
    // 定制代理
    customizeProxyFactory(proxyFactory);
    // 用来控制代理工厂被配置之后，是否还允许修改，默认为false，即在代理被配置后，不允许修改代理的配置
    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
    // 获取代理类，在这一步会进行代理类的创建
    return proxyFactory.getProxy(getProxyClassLoader());
}

对于代理类的创建及处理，Spring 委托给 ProxyFactorγ 去处理，而在此函数中主要是对 ProxyFactory 的初始化操作，进而对真正的创建代理做准备，这些初始化操作包括如下内容：

获取当前类中的属性。
添加代理接口。
封装 Advisor 并加入到 ProxyFactory 中。
设置要代理的类。
在 Spring 中还为子类提供定制函数 customizeProxyFactory，子类可对 ProxyFactory 做进一步封装
进行获取代理操作。

ProxyFactory 内部是使用 JDK 或 CGLib 动态代理技术将增强应用到目标类中的。Spring 定义了 AopProxy 接口，并提供了两个实现类：CglibAopProxy、JdkDynamicAopProxy。前者使用 CGLib 动态代理技术创建代理，而后者使用 JDK 动态代理技术创建代理。在 Spring 4.0 版本还提供了 ObjenesisCglibAopProxy 实现类，它是 CglibAopProxy 的扩展，可以避免在创建代理类时调用构造函数。

此外，ProxyFactory 有几个常用的可配置属性：

target：代理的目标对象
proxyInterfaces：代理所要实现的接口，可以是多个接口。
interceptorNames：需要织入目标对象的 Bean 列表，采用 Bean 名称指定。这些 Bean 必须是实现了 MethodInterceptor 或 Advisor 的 Bean，配置中的顺序对应调用的顺序。
singleton：返回的代理是否是单实例，默认为单实例。
optimize：当设置为 true 时，强制使用 CGLib 动态代理。

2. createAopProxy

protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    // 创建代理
    return getAopProxyFactory().createAopProxy(this);
}
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        return new ObjenesisCglibAopProxy(config);
    } else {
        return new JdkDynamicAopProxy(config);
    }
}

Spring 是如何选取创建代理的方式呢？从 if 中的判断条件可以看到有 3个方面影响着 Spring 的判断。

optimize：用来控制通过 CGLIB 创建的代理是否使用激进的优化策略。除非完全了解 AOP 代理如何处理优化，否则不推荐用户使用这个设置。该属性仅用于 CGLIB 代理，对于 JDK 动态代理（默认）无效。

proxyTargetClass：这个属性为 true 时，目标类本身被代理而不是目标类的接口。如果这个属性值被设为 true，CGLIB 代理将被创建，可通过 spring.aop.proxy-target-class 属性进行设置。

hasNoUserSuppliedProxyInterfaces：是否存在代理接口。

因此，总结下来就是：如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理实现 AOP。如果目标对象实现了接口，可以强制使用 CGLIB 实现 AOP。如果目标对象没有实现接口，必须采用 CGLIB 库，Spring 会自动在 JDK 动态代理和 CGLIB 之间转换。

2.1 JdkDynamicAopProxy

查看 JdkDynamicAopProxy 的 getProxy 方法：

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

JdkDynamicAopProxy 实现了 lnvocationHandler 接口，在重写的 invoke 方法中实现了 AOP 的核心逻辑：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    TargetSource targetSource = this.advised.targetSource;
    Object target = null;
    try {
        ......
        Object retVal;
        // 有时候目标对象内部的自我调用将无法实施切面中的增强，需要通过此属性暴露代理类
        if (this.advised.exposeProxy) {
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);
        // 获取当前方法的拦截器链
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        // 如果没有发现任何拦截器那么直接调用切点方法
        if (chain.isEmpty()) {
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
        } else {
            // 将拦截器封装在ReflectiveMethodInvocation，以便使用其proceed进行拦截器链的调用
            MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
            // 执行拦截器链
            retVal = invocation.proceed();
        }
        // 返回结果
        Class<?> returnType = method.getReturnType();
        if (retVal != null && retVal == target && returnType != Object.class && returnType.isInstance(proxy) &&
            !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            retVal = proxy;
        }
        return retVal;
    }
}

上面的函数中最主要的工作就是创建了一个拦截器链，并使用 ReflectiveMethodInvocation 类进行了拦截器链的封装，而在 ReflectiveMethodInvocation 类的 proceed 方法中实现了拦截器的逐一调用，下面分析在 proceed 方法中是如何实现前置增强在目标方法前调用，后置增强在目标方法后调用的逻辑。

public Object proceed() throws Throwable {
    // 执行完所有增强后，执行原实现类目标方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }
     // 获取下一个要执行的拦截器
    Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        // 动态匹配
        InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
            return dm.interceptor.invoke(this);
        } else {
            // 不匹配则不执行当前拦截器，继续递归下一个
            return proceed();
        }
    } else {
        // 普通拦截器，直接调用拦截器
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

2.2 CglibAopProxy

查看 CglibAopProxy 的 getProxy 方法，该方法实现了 Enhancer 的创建及接口封装。

public Object getProxy(@Nullable ClassLoader classLoader) {
    try {
        Class<?> rootClass = this.advised.getTargetClass();
        Class<?> proxySuperClass = rootClass;
        ......
        // 验证 Class
        validateClassIfNecessary(proxySuperClass, classLoader);
        // 创建及配置CGLIB Enhancer
        Enhancer enhancer = createEnhancer();
        if (classLoader != null) {
            enhancer.setClassLoader(classLoader);
            if (classLoader instanceof SmartClassLoader && ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                enhancer.setUseCache(false);
            }
        }
        enhancer.setSuperclass(proxySuperClass);
        enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
        enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
        enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
        // 设置拦截器
        Callback[] callbacks = getCallbacks(rootClass);
        Class<?>[] types = new Class<?>[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        // 生成代理类，以及创建代理实例
        return createProxyClassAndInstance(enhancer, callbacks);
    }
    ......
}
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
    enhancer.setInterceptDuringConstruction(false);
    enhancer.setCallbacks(callbacks);
    return (this.constructorArgs != null && this.constructorArgTypes != null ?
            enhancer.create(this.constructorArgTypes, this.constructorArgs) :
            enhancer.create());
}

以上函数完整地阐述了一个创建 Spring 中的 Enhancer 的过程，其中最重要的是通过 getCallbacks 方法设置拦截器链。具体代码如下：

private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
    // 对于 expose-proxy 属性的处理
    boolean exposeProxy = this.advised.isExposeProxy();
    boolean isFrozen = this.advised.isFrozen();
    boolean isStatic = this.advised.getTargetSource().isStatic();
    // 将拦截器链封装在 DynamicAdvisedInterceptor 中
    Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
    ......
    Callback[] mainCallbacks = new Callback[] {
        // 将拦截器链加入 Callback 中
        aopInterceptor,
        targetInterceptor, new SerializableNoOp(), targetDispatcher, this.advisedDispatcher,
        new EqualsInterceptor(this.advised), new HashCodeInterceptor(this.advised)};
    Callback[] callbacks = mainCallbacks;
    ......
    return callbacks;
}

在 getCallbacks 中 Spring 考虑了很多情况，但是对于我们来说，只需要理解最常用的就可以了，比如将 advised 属性封装在 DynamicAdvisedInterceptor 并加入 callbacks 数组中，这么做的目的是什么呢？

我们知道 CGLIB 中对于方法的拦截是通过将自定义的拦截器（实现 Methodlnterceptor 接口）加入 Callback 中并在调用代理时直接激活拦截器中的 intercept 方法来实现的，那么在 getCallbacks 中正是实现了这样一个目的，DynamicAdvisedInterceptor 继承自 Methodlnterceptor，加入 Callback 中后，在再次调用代理时会直接调用 DynamicAdvisedInterceptor 中的 intercept 方法。因此，对于 CGLIB 方式实现的代理，其核心逻辑必然在 DynamicAdvisedInterceptor 中的 intercept 中。

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    Object target = null;
    TargetSource targetSource = this.advised.getTargetSource();
    try {
        if (this.advised.exposeProxy) {
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);
        // 获取拦截器链
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
            // 如果拦截器链为空则直接激活原方法
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = methodProxy.invoke(target, argsToUse);
        } else {
            // 进入拦截器链并通过process调用
            retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
        }
        retVal = processReturnType(proxy, target, method, retVal);
        return retVal;
    }
}

上述的实现与 JDK 方式实现代理中的 invoke 方法大同小异，都是首先构造链，然后封装此链进行串联调用，稍有些区别就是在 JDK 中直接构造 ReflectiveMethodlnvocation，而在 CGLIB 中使用 CglibMethodInvocation。CglibMethodInvocation 继承自 ReflectiveMethodlnvocation，但是其 proceed 方法并没有重写，还是一个递归调用逻辑。

Java

Spring AOP 实现原理