spring-AOP注解源码分析

1.前言

在刚学java的时候看到编译器里显示的黄黄的字体还不知道那是注解，注解的名称也是后面才知道的，反正感觉它的逼格很高。后面为了提高自己的代码质量，也学会了注解的编写，不过一直没有去看到底是怎么实现的，这回总算弥补上年轻时代的缺憾了。

2.代理实例化的流程

2.1 ProxyFactory 代理工厂

代理工厂类继承于ProxyCreatorSupport
涉及的源码部分如下，很简单没什么好分析的，但是出于流程上，为了不断档，还是拿出来晒一晒：

public Object getProxy(@Nullable ClassLoader classLoader) {
    return createAopProxy().getProxy(classLoader);
}

2.2 ProxyCreatorSupport 代理创建支持类

这个方法加了一个同步锁，说明创建aop代理的时候是串型执行的

protected final synchronized AopProxy createAopProxy() {
    //创建代理的时候注册到AdvisedSupportListener监听器中
    if (!this.active) {
        activate();
    }
    //创建代理
    return getAopProxyFactory().createAopProxy(this);
}

2.3 DefaultAopProxyFactory aop代理工厂

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    //判断代理是否需要执行优化
    //判断是否直接代理目标类
    //判断是否没有代理接口或者代理的仅仅是的子类SpringProxy
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: " +
                    "Either an interface or a target is required for proxy creation.");
        }
        //判断目标类是不是接口类或Proxy的子类，或者在proxyClassCache中，这个缓存是一个弱引用缓存，内部信息在一段时间没用被使用就会清理掉
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        //到了这里才使用cglib的代理，感觉上似乎很不乐意使用cglib一样
        return new ObjenesisCglibAopProxy(config);
    } else {
        return new JdkDynamicAopProxy(config);
    }
}

2.4 JdkDynamicAopProxy jdk动态aop代理

public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    //获取代理接口数组
    Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    //寻找是否包含了equals和hashcode的接口
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    //实例化代理类
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

2.5 ObjenesisCglibAopProxy cglib动态aop代理

public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
    }

    try {
        Class rootClass = this.advised.getTargetClass();
        Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

        Class proxySuperClass = rootClass;
        if (ClassUtils.isCglibProxyClass(rootClass)) {
            proxySuperClass = rootClass.getSuperclass();
            Class[] additionalInterfaces = rootClass.getInterfaces();
            for (Class additionalInterface : additionalInterfaces) {
                this.advised.addInterface(additionalInterface);
            }
        }

        //检验类.
        validateClassIfNecessary(proxySuperClass, classLoader);

        // 创建 CGLIB的Enhancer
        // Enhancer允许为非接口类型创建一个Java代理
        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 ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
        //获取回调，设置aop的拦截链，cglib拦截是通过实现MethodInterceptor接口，在getCallBack里面会有。
        Callback[] callbacks = getCallbacks(rootClass);
        Class[] types = new Class[callbacks.length];
        for (int x = 0; x < types.length; x++) {
            types[x] = callbacks[x].getClass();
        }
        // 设置拦截器过滤器
        enhancer.setCallbackFilter(new ProxyCallbackFilter(
                this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
        enhancer.setCallbackTypes(types);

        // 生成代理类，并创建代理实例.
        return createProxyClassAndInstance(enhancer, callbacks);
    } catch (CodeGenerationException | IllegalArgumentException ex) {
        throw new AopConfigException("Could not generate CGLIB subclass of class [" +
                this.advised.getTargetClass() + "]: " +
                "Common causes of this problem include using a final class or a non-visible class",
                ex);
    } catch (Throwable ex) {
        // TargetSource.getTarget() failed
        throw new AopConfigException("Unexpected AOP exception", ex);
    }
}


private Callback[] getCallbacks(Class rootClass) throws Exception {
    //略略略略
    //DynamicAdvisedInterceptor这个内部类实现了我们在寻找的MethodInterceptor接口
    Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
    //略略略略
}

从上面两个实例化的过程中可以看到，接口类的代理会优先使用jdk的代理，jdk代理通过Proxy这个类来实例化，而cglib的代理是通过EnHancer来创建代理的

3 aop最终实现原理

3.1 JdkDynamicAopProxy的invoke

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) {
            // Make invocation available if necessary.
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
        // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
        target = targetSource.getTarget();
        Class targetClass = (target != null ? target.getClass() : null);
        //获取拦截链
        List