Spring AOP(二) 原理

        Spring AOP所使用的到的原理就是采取一种代理模式，spring AOP中提供了两种方式产生代理对象：jdk动态代理和CGLIB代理。这两者的优势和局限性在这里不做讨论。

一、代理对象的生成

        Spring AOP模块中，一个主要的部分就是代理对象的生成，从中Spring AOP(一) 基本概念和例子我们可以知道，可以通过配置和调用Spring的ProxyFactoryBean来完成这个任务。当然Spring AOP中提供了多种方式来生成代理对象。下面给出主要的继承关系（并非全部继承关系）

•  ProxyConfig：可以看成是一个数据基类，这个数据基类为ProxyFactoryBean这样的子类提供了配置属性。
• AdvisedSupport：封装了AOP对通知和通知器的相关操作，这些操作对于不同的AOP的代理对象的生成都是一样的，对于具体的AOP代理对象的创建，AdvisedSupport把它交给它的子类们去完成。
• ProxyCreatorSupport：可以看作是其子类创建AOP代理对象的一个辅助类。
• AspectJProxyFactory、ProxyFactory、ProxyFactoryBean：分别是具体AOP代理对象生成的类。对于需要使用AspectJ的AOP应用，AspectJProxyFactory起到了集成Spring和AspectJ的作用；对于使用Spring AOP的应用，ProxyFactoryBean和ProxyFactory都提供了AOP功能的封装，不同在于ProxyFactoryBean提供了IoC容器声明式配置，而ProxyFactory需要编程式的使用Spring AOP的功能。
• AbstractSingletonProxyFactoryBean：抽象类，用于只生成单例的代理工厂bean。
• TransactionProxyFactoryBean：简化的声明式事务处理的代理工厂bean。

        具体的AOP代理对象的生成，可以根据不同需要，采取上述的一些实现类去生成，在这里我们以ProxyFactoryBean作为例子来具体看看Spring AOP代理对象的生成。ProxyFactoryBean继承了FactoryBean，它是一个工厂bean，我们知道工厂bean实例化的时候回调用到getObject()方法

 

public Object getObject() throws BeansException {
               //初始化Advisor链
        initializeAdvisorChain();
        if (isSingleton()) {
                      //单例
            return getSingletonInstance();
        }
        else {
            if (this.targetName == null) {
                logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
                        "Enable prototype proxies by setting the 'targetName' property.");
            }
                      //非单例
            return newPrototypeInstance();
        }
    }

 1. 初始化advisor链

 

        initializeAdvisorChain()所做的工作很简单，就是将ProxyFactoryBean配置中的interceptorNames列表加入到advisors列表中（其中的advice将会自动封装成advisor）。

 

private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
        if (this.advisorChainInitialized) {
            return;
        }
        if (!ObjectUtils.isEmpty(this.interceptorNames)) {
            if (this.beanFactory == null) {
                throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
                        "- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
            }
 
            // Globals can't be last unless we specified a targetSource using the property...
            if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
                    this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
                throw new AopConfigException("Target required after globals");
            }
 
            // 这里是添加Advisor链的调用，是通过interceptorNames属性进行配置的
            for (int i = 0; i < this.interceptorNames.length; i++) {
                String name = this.interceptorNames[i];
                if (logger.isTraceEnabled()) {
                    logger.trace("Configuring advisor or advice '" + name + "'");
                }
 
                if (name.endsWith(GLOBAL_SUFFIX)) {
                    if (!(this.beanFactory instanceof ListableBeanFactory)) {
                        throw new AopConfigException(
                                "Can only use global advisors or interceptors with a ListableBeanFactory");
                    }
                    addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
                            name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
                }
 
                else {
                    Object advice = null;
                                        //singletion类型bean
                    if (this.singleton || this.beanFactory.isSingleton(this.interceptorNames[i])) {
                        // Add the real Advisor/Advice to the chain.
                        advice = this.beanFactory.getBean(this.interceptorNames[i]);
                    }
                    else {
                        //对prototype类型的bean的处理
                        advice = new PrototypePlaceholderAdvisor(this.interceptorNames[i]);
                    }
                                       //将advisor加入到advisor链中，其中advice会被封装成advisor后添加
                    addAdvisorOnChainCreation(advice, this.interceptorNames[i]);
                }
            }
        }
 
        this.advisorChainInitialized = true;
    }

 具体的过程会调用到

 

 

//advisorAdapterRegistry实例是DefaultAdvisorAdapterRegistry对象
this.advisorAdapterRegistry.wrap(next);

         DefaultAdvisorAdapterRegistry对象用于注册AdviceAdapter对象，每一种AdviceAdapter用于判断advice是不是属于该AdviceAdapter所对应的advice以及用于将advice转换成相应的拦截器。Spring中一种advice都有相应与之对应的AdviceAdapter和拦截器对应。

 

 

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
    private final List adapters = new ArrayList(3);
    //注册已知的AdviceAdapter，每一种advice对应一种AdviceAdapter，Spring AOP默认提供了下面三种AdviceAdapter
    public DefaultAdvisorAdapterRegistry() {
        registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
        registerAdvisorAdapter(new AfterReturningAdviceAdapter());
        registerAdvisorAdapter(new ThrowsAdviceAdapter());
    }
 
        //这里就是将advice封装成advisor
    public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
        //如果已经是advisor对象了，就直接返回
                if (adviceObject instanceof Advisor) {
            return (Advisor) adviceObject;
        }
        if (!(adviceObject instanceof Advice)) {
            throw new UnknownAdviceTypeException(adviceObject);
        }
        Advice advice = (Advice) adviceObject;
                //如果这个advice已经是一个拦截器了，
        if (advice instanceof MethodInterceptor) {
            // So well-known it doesn't even need an adapter.
            return new DefaultPointcutAdvisor(advice);
        }
        for (int i = 0; i < this.adapters.size(); i++) {
            // Check that it is supported.
            AdvisorAdapter adapter = (AdvisorAdapter) this.adapters.get(i);
            if (adapter.supportsAdvice(advice)) {
                return new DefaultPointcutAdvisor(advice);
            }
        }
        throw new UnknownAdviceTypeException(advice);
    }
 
    public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
        List interceptors = new ArrayList(3);
        Advice advice = advisor.getAdvice();
        if (advice instanceof MethodInterceptor) {
            interceptors.add(advice);
        }
               //通过adapter将advice封装成对应的拦截器
        for (int i = 0; i < this.adapters.size(); i++) {
            AdvisorAdapter adapter = (AdvisorAdapter) this.adapters.get(i);
            if (adapter.supportsAdvice(advice)) {
                interceptors.add(adapter.getInterceptor(advisor));
            }
        }
        if (interceptors.isEmpty()) {
            throw new UnknownAdviceTypeException(advisor.getAdvice());
        }
        return (MethodInterceptor[]) interceptors.toArray(new MethodInterceptor[interceptors.size()]);
    }
 
    public void registerAdvisorAdapter(AdvisorAdapter adapter) {
        this.adapters.add(adapter);
    }
 
}

        现在我们就以MethodBeforeAdvice为例子来看看advice对应的Adapter以及Interceptor长的什么样子

 

 

//MethodBeforeAdvice对应的MethodBeforeAdviceAdapter
class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
        //判断是不是MethodBeforeAdvice
    public boolean supportsAdvice(Advice advice) {
        return (advice instanceof MethodBeforeAdvice);
    }
        //将MethodBeforeAdvice封装成MethodBeforeAdviceInterceptor
    public MethodInterceptor getInterceptor(Advisor advisor) {
        MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
        return new MethodBeforeAdviceInterceptor(advice);
    }
 
}
 
//MethodBeforeAdvice对应的MethodBeforeAdviceInterceptor
public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
    private MethodBeforeAdvice advice;
        //通过MethodBeforeAdvice封装成拦截器
    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }
       //拦截器主要的调用逻辑，MethodBeforeAdviceInterceptor的逻辑很简单，就是在调用方法之前，先调用MethodBeforeAdvice的before方法
    public Object invoke(MethodInvocation mi) throws Throwable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
        return mi.proceed();
    }
}

         上面我们已经讲了初始化advisor链的过程中，只是简单的将advisor加入到advisor链中，其中如果传进去的是一个advice，则通过DefaultAdvisorAdapterRegistry这个一个默认实现将advice封装成advisor然后加入到advisor链中（DefaultAdvisorAdapterRegistry通过注册在对象里面的AdviceAdapter来判断是否是支持的advice类型）。我们都知道Spring AOP使用到了代理以及拦截器技术，上面我也讲了Advice、AdviceAdaptor以及AdviceInterceptor之间的关系，代理对象中只是将advice封装成了advisor，这么做的好处是什么呢？等整个AOP过程分析完之后，再做讨论。

 

 

2.代理对象生成

        代理对象的生成就是通过AopProxy取得的，在Spring AOP中提供了两种方式的AopProxy：jdk的AopProxy和CGLIB的AopProxy，分别为JdkDynamicAopProxy和Cglib2AopProxy。具体采用哪种方式的AopProxy呢？

        首先，我们在看看上面ProxyFactoryBean中提供的getObject()方法，取得实例的两种情况：Singleton和Prototype。不管哪种方式，我们看到，取得AopProxy的方式都是通过调用到AopProxyFactory接口的默认实现类DefaultAopProxyFactory中的createAopProxy方法

 

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        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.");
            }
            if (targetClass.isInterface()) {
                return new JdkDynamicAopProxy(config);
            }
            if (!cglibAvailable) {
                throw new AopConfigException(
                        "Cannot proxy target class because CGLIB2 is not available. " +
                        "Add CGLIB to the class path or specify proxy interfaces.");
            }
            return CglibProxyFactory.createCglibProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

         从上面代码我们可以很清楚的看到Spring AOP才用两种方式生成代理的条件，默认采取jdk动态代理，如果这个类没有接口或者在config中配置了满足上述条件的属性，那么就走cglib的方式，当然如果目标类本身就是接口，那么也走jdk动态代理（其中的原因是cglib采取的继承的方式）。

 

        接下来，通过AopProxy取得代理对象的过程就是jdk以及cglib如何生成代理对象的过程了，在这里我们不做讨论。

 

protected Object getProxy(AopProxy aopProxy) {
            //通过jdk或者cglib类型的AopProxy取得代理对象
        return aopProxy.getProxy(this.proxyClassLoader);
    }

 

 二、代理方法的调用

        JdkDynamicAopProxy生成代理对象的时候，会将this作为参数传入，这里的this指的是InvocationHandler类型的参数，因为JdkDynamicAopProxy实现了InvocationHandler接口，重写了invoke方法

 

Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

        根据jdk动态代理的知识，我们可以知道，代理方法在被调用的时候会调用到JdkDynamicAopProxy中的invoke方法。cglib也会以类似的形式调用到相应拦截器中的intercept方法，在这里我们以JdkDynamicAopProxy为例子来详细看看Spring AOP代理方法调用的过程。

 

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation = null;
        Object oldProxy = null;
        boolean setProxyContext = false;
 
        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;
 
        try {
                        //如果是equals方法、hashCode方法，并且没有定义equals、hashCode方法，就直接调用目标类中的
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                return (equals(args[0]) ? Boolean.TRUE : Boolean.FALSE);
            }
            if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                return new Integer(hashCode());
            }
                        //通过反射调用
            if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }
 
            Object retVal = null;
 
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
 
            // May be <code>null</code>. Get as late as possible to minimize the time we "own" the target,
            // in case it comes from a pool.
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }
 
            //取得方法对应的拦截器（在这里会调用到DefaultAdvisorChainFactory的getInterceptorsAndDynamicInterceptionAdvice方法，这个方法中会生成拦截器）
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
 
                //如果这个方法的拦截器链为空，那么直接以反射的方式调用目标对象的该方法
            if (chain.isEmpty()) {
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
            }
            else {
                //创建一个method invocation
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                //执行
                retVal = invocation.proceed();
            }
 
            if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
 
                retVal = proxy;
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                // Must have come from TargetSource.
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

 

 在代理方法调用的过程中，会根据advisor获得该方法的所有拦截器，上述取得拦截器链的方法会最总调用到DefaultAdvisorChainFactory中的getInterceptorsAndDynamicInterceptionAdvice方法。

public List getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class targetClass) {
        List interceptorList = new ArrayList(config.getAdvisors().length);
               //判断是否存在有Introduction
        boolean hasIntroductions = hasMatchingIntroductions(config, targetClass);
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        Advisor[] advisors = config.getAdvisors();
        for (int i = 0; i < advisors.length; i++) {
            Advisor advisor = advisors[i];
                       //生成方法的拦截器，Pointcut类型处理方式
            if (advisor instanceof PointcutAdvisor) {
                // Add it conditionally.
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
                    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) {
                        if (mm.isRuntime()) {
                            // Creating a new object instance in the getInterceptors() method
                            // isn't a problem as we normally cache created chains.
                            for (int j = 0; j < interceptors.length; j++) {
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptors[j], mm));
                            }
                        }
                        else {
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
                         //生成方法拦截器，Introduction的处理方式
            else if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) {
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
            else {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }
        return interceptorList;
    }
 
        private static boolean hasMatchingIntroductions(Advised config, Class targetClass) {
        for (int i = 0; i < config.getAdvisors().length; i++) {
            Advisor advisor = config.getAdvisors()[i];
            if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (ia.getClassFilter().matches(targetClass)) {
                    return true;
                }
            }
        }
        return false;
    }

 拦截器的运行

public Object proceed() throws Throwable {
        //拦截器调用完毕之后调用target方法
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }
 
        Object interceptorOrInterceptionAdvice =
            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

         上面会调用到拦截器的invoke方法，然后通过查看各种拦截器的invoke方法，我们可以看到拦截器链中的拦截器会被执行到，并且各个拦截器中的advice方法能保持预期的顺序执行到。

//MethodBeforeAdviceInterceptor
//调用接下来的拦截器之前先调用before方法
public Object invoke(MethodInvocation mi) throws Throwable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
        return mi.proceed();
    }
//AfterReturningAdviceInterceptor
//调用剩下的拦截器之后再调用after方法
public Object invoke(MethodInvocation mi) throws Throwable {
        Object retVal = mi.proceed();
        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
        return retVal;
    }
//ThrowsAdviceInterceptor
//调用方法发生异常时执行到，注意：捕获之后接着往上抛出去
public Object invoke(MethodInvocation mi) throws Throwable {    public Object invoke(MethodInvocation mi) throws Throwable {
        try {
            return mi.proceed();
        }
        catch (Throwable ex) {
            Method handlerMethod = getExceptionHandler(ex);
            if (handlerMethod != null) {
                invokeHandlerMethod(mi, ex, handlerMethod);
            }
            throw ex;
        }
    }
 try {
 return mi.proceed();
 }
 catch (Throwable ex) {
 Method handlerMethod = getExceptionHandler(ex);
 if (handlerMethod != null) {
 invokeHandlerMethod(mi, ex, handlerMethod);
 }
 throw ex;
 }
 }

         这样 我们看到Spring AOP的整个流程。