spring aop实现原理

     Java是面向对象的编程语言，整个程序的执行是方法纵向的调用完成，Aop是面向切面的编程思想，是对面向对象的一个补充。Aop面向切面的思想是针对方法进行编程，依赖动态代理来实现对方法执行的前后注入业务逻辑。简而言之，spring aop是面向切面的编程思想，辅佐以动态代理的实现来完成。
    下面以ProxyFactoryBean的getObject为切入点，来分析spring aop的实现原理。

获取通知器链

     从ProxyFactoryBean的getObject方法中可以看到，initializeAdvisorChain初始化通知器链，这个是通过读取interceptorNames的配置属性获取的，然后把获取到的所有通知器添加到通知器链中，这里是按配置的顺序进行添加的。最后是把所有通知器链保存到advisors属性中。

public Object getObject() throws BeansException {
        //从ProxyFactoryBean的配置中获取所有的advisor信息
        initializeAdvisorChain();
        if (isSingleton()) {
            //获取代理对象
            return getSingletonInstance();
        }

        // ...
}


private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
        if (!ObjectUtils.isEmpty(this.interceptorNames)) {
            // ...

            for (String name : this.interceptorNames) {
                if (name.endsWith(GLOBAL_SUFFIX)) {
                    addGlobalAdvisors((ListableBeanFactory) this.beanFactory,
                            name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
                }
                else {
                    Object advice;
                    if (this.singleton || this.beanFactory.isSingleton(name)) {
                        //这里从spring ioc容器中获取通知bean
                        advice = this.beanFactory.getBean(name);
                    }
                    else {
                        advice = new PrototypePlaceholderAdvisor(name);
                    }
                    //把获取到的通知添加到通知器链中，这里是按序添加的
                    addAdvisorOnChainCreation(advice);
                }
            }
        }

        this.advisorChainInitialized = true;
}

代理对象的生成

     aop代理对象的生成是委托给AopProxy来进行代理对象的生成。

private synchronized Object getSingletonInstance() {
        if (this.singletonInstance == null) {
            //生成一个aop代理对象
            this.singletonInstance = getProxy(createAopProxy());
        }
        return this.singletonInstance;
}

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        //配置了isProxyTargetClass属性或者没有实现接口就使用ObjenesisCglibAopProxy去生成代理对象，否则就使用JdkDynamicAopProxy生成代理对象
        if (!NativeDetector.inNativeImage() &&
                (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.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }
}

     这里可以看到，spring把代理对象的生成是交给了AopProxy接口，通过AopProxy来解耦了代理对象的生成。在配置了isOptimize或isProxyTargetClass的时候，并且目标对象不是实现接口的形式，就采用ObjenesisCglibAopProxy来生成代理对象，否则就使用JdkDynamicAopProxy去生成代理对象。对于代理对象这里是动态代理设计模式的使用，对于动态代理对象这里不进行解释，以JdkDynamicAopProxy为例来看看代理对象的生成过程。

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
        }
        return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
    }
}

     在代理模式中，Proxy生成代理对象的时候，需要传入类加载器、目标对象实现的接口和触发器。代理对象生成后，对目标对象所有的方法调用都会交给InvocationHandler进行处理，都会触发InvovationHandler接口invoke方法的调用。JdkDynamicAopProxy实现了InvocationHandler接口，所以这里在生成代理对象的时候，把自己作为InvocationHandler参数传进去了。

     以上是为实现spring aop进行的基础处理和铺垫：

• 读取配置的通知器到advisors通知器链中
• 代理对象的生成

     接下来看看在实际方法调用的过程中，aop是怎么对运行的方法进行拦截处理的。对目标方法的调用最终都会转交给InvocationHandler的invoke方法的处理，以这个为入口进行分析。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        try {
            // ...

            //获取通知器链
            List