【Spring源码】AOP部分源码解读

在之前的文章【设计模式】动态代理模式和【设计模式】策略模式中都讲到了AOP中有用到，今天就带领大家读读部分源码。

    话不多说，我们直接先来看类图，之后再逐步分析：

    首先根据类图中的入口，直接来看类ProxyFactoryBean，可以看到类ProxyFactoryBean实现了FactoryBean接口，实现这个接口的方法，我们就直接去看他的getObject方法(关于这点不太清楚的同学可以看楼主之前的博客：BeanFactory和FactoryBean详解)：

public Object getObject() throws BeansException {
    initializeAdvisorChain();
    if (isSingleton()) {
        return getSingletonInstance();
    }
    else {
        return newPrototypeInstance();
    }
}

    可以看到方法很简单，就是区分获取单例和原型的类，其中其他代码省略了，这两个方法最终返回的都是如下方法结果：

getProxy(createAopProxy())

    下面就来看createAopProxy方法：

protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    //此处调用AopProxyFactory的createAopProxy方法
    return getAopProxyFactory().createAopProxy(this);
}

    这里的AopProxyFactory其实就是一个简单工厂模式，根据入参返回不同的对象类，其核心方法：

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);
    }
}

    代码很简单，就是根据不同才config获取不同的Proxy实现类。下面来看看AopProxy的三个实现类。

    CglibAopProxy类：

public Object getProxy(ClassLoader classLoader) {
    try {
        Class<?> rootClass = this.advised.getTargetClass();
        Class<?> proxySuperClass = rootClass;
        ........省略部分代码

        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));

        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 ex) {
    。。。省略
    catch (IllegalArgumentException ex) {
    。。。省略   
    }
    catch (Throwable ex) {
    。。。省略
    }
}

    读者可以看到这就是一个很典型的采用Cglib的动态代理，这里就不多说了，接下来看类JdkDynamicAopProxy：

public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

    这里就更不用多说了，不太清除的同学可以去看看引言里的动态代理模式那篇文章，至于ObjenesisCglibAopProxy这里就不多说了，它就是在CglibAopProxy的功能上加入了初始化代理类时不调用其构造器的功能，这个大家可以自行搜索下Objenesis接口，很简单。

    最后来看上面未说的getProxy方法：

protected Object getProxy(AopProxy aopProxy) {
    return aopProxy.getProxy(this.proxyClassLoader);
}

    这就很简单啦，就是根据传入的不同的AopProxy实现类来通过不同的方式获取代理对象，就是一个简单的接口调用。

---

欢迎关注个人博客：blog.scarlettbai.com