jdk动态代理的情况下 前后置advice的调用过程分析 part1

这次要分析的是JdkDynamicAopProxy 中的invoke方法 因为AOP中 在target方法调用的前后 以及 异常时 调用各种advice的逻辑都在这个方法里

所以主要分析这个方法.

这个方法主要分两个步骤

1.获取到Interceptor链

2.执行方法调用

其中获取到Interceptor链是通过从advisor里面获取到advice的引用 用MethodInterceptor的实现类包装起来,存放在一个数组里

前置通知 用的是MethodBeforeAdviceInterceptor类   后置通知用的是AfterReturningAdviceInterceptor类

 

执行方法调用则是调用了org.springframework.aop.framework.ReflectiveMethodInvocation 里面的proceed方法

递归的去处理每一个Interceptor  很巧妙的实现了前置advice在target方法之前执行   后置advice在target方法之后执行

---

下面就来分析一下这个过程 我可能有删减一些代码 

我们的分析从JdkDynamicAopProxy 类的invoke方法方法开始

 

至于advice对象和advisor对象以及pointcut对象的生成 是Ioc的内容  具体这些对象的引用又是如何设置到AdvisedSupport类对象里面去的

下次再做分析 这些都不是很核心的逻辑

---

org.springframework.aop.framework.JdkDynamicAopProxy 是AopProxy的一个实现类

用于获取AOP代理后的对象

invoke方法 就是代理后执行的方法

/**
     * Implementation of <code>InvocationHandler.invoke</code>.
     * <p>Callers will see exactly the exception thrown by the target,
     * unless a hook method throws an exception.
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;
  
        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;
  
        try {
            Object retVal;
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
  
            // May be null. 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();
            }
  
            //获取Interceptor链 这是比较核心的一步
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  
            // Check whether we have any advice. If we don't, we can fallback on direct
            // reflective invocation of the target, and avoid creating a MethodInvocation.
            if (chain.isEmpty()) {
                // We can skip creating a MethodInvocation: just invoke the target directly
                // Note that the final invoker must be an InvokerInterceptor so we know it does
                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
            }
            else {
                  
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                //执行Interceptor链 这里是一个递归的过程
                retVal = invocation.proceed(); 
            }
            return retVal;
        }
    }

 主要分析标黄的两行代码

1.获取Interceptor chain  用于在方法执行之前 或者之后执行

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

 

?

2.方法调用 

retVal = invocation.proceed();

 

 

---

先看获取Interceptor chain

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

进入到org.springframework.aop.framework.AdvisedSupport类中  这个类AOP的一个根配置管理类 存储了AOP创建代理对象和执行interceptors所需的各种属性

比如 

interfaces  创建代理对象所要实现的接口,

targetSource  持有真实对象引用的一个包装类 也是创建代理对象要用到的,

methodCache 一个list 存放了每个方法对应的interceptor链,

advisors 所有的advisor的一个集合

等等...

 

 首先进入getInterceptorsAndDynamicInterceptionAdvice方法

 

 

/**
     * Determine a list of {@link org.aopalliance.intercept.MethodInterceptor} objects
     * for the given method, based on this configuration.
     * @param method the proxied method
     * @param targetClass the target class
     * @return List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
     */
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {
        根据方法对象 生成cachekey  然后在缓存methodCache里面获取 如果能够获取到当前执行的这个方法对于的advisor chain 那么直接返回
        MethodCacheKey cacheKey = new MethodCacheKey(method);
        List<Object> cached = this.methodCache.get(cacheKey);
        if (cached == null) {
            如果获取不到 那么就要重新创建
            cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                    this, method, targetClass);
            this.methodCache.put(cacheKey, cached);
        }
        return cached;
    }

 

 下面进入到org.springframework.aop.framework.DefaultAdvisorChainFactory

这是一个工厂类 专门生成advice chain 

 

这里传进来的config参数 就是上面讲到的 AdvisedSupport实例 
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
            Advised config, Method method, Class targetClass) {
  
        // This is somewhat tricky... we have to process introductions first,
        // but we need to preserve order in the ultimate list.
        创建一个list 长度就和AdvisedSupport实例 里面存储的advisors集合长度一样
        List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
        boolean hasIntroductions = hasMatchingIntroductions(config, targetClass);
  
        //获取一个AdvisorAdapterRegistry 实例 用于后面把advice包装成Interceptor用的
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        //开始遍历
        for (Advisor advisor : config.getAdvisors()) {
        在beans.xml里面配置的advisor 是DefaultPointcutAdvisor类型 也就是PointcutAdvisor的子类 所以这里是符合的
            if (advisor instanceof PointcutAdvisor) {
                // Add it conditionally.
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
                    开始把advisor的集合 转换成MethodInterceptor的数组 这里就用到AdvisorAdapterRegistry 了
具体转换的过程 后面会写到
                    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                    开始做pointcut的方法名称匹配 用的是正则表达式
                    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 (MethodInterceptor interceptor : interceptors) {
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                            }
                        }
                        else {
                            判断成功 但是mm.isRuntime()是false  这个isRuntime的含义还有待研究  然后 把每个method对于的interceptors添加到一个总的集合
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
            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;
    }

 可以看到 返回的4个interceptor对象的集合

 

 

 两个前置 两个后置 因为我在xml里是这样配置的

 

   <bean id="studentProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

            < property  name = "proxyInterfaces" >
                < value >com.test.aop.IStudent</ value >
            </ property >
            < property  name = "target" >
                < ref  bean = "targetStudent" />
            </ property >
            < property  name = "interceptorNames" >
                < list >
                    < value >ReadingAdvisorBefore</ value >
                    < value >ReadingAdvisorBefore</ value >
                    < value >ReadingAdvisorAfter</ value >
                    < value >ReadingAdvisorAfter</ value >
                </ list >
            </ property >
        </ bean >

 

 另外 这个过程中有一个advisor转换成Interceptor数组的过程  是这样的

 

 

public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
        List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
        Advice advice = advisor.getAdvice();
        if (advice instanceof MethodInterceptor) {
            interceptors.add((MethodInterceptor) advice);
        }
        for (AdvisorAdapter adapter : this.adapters) {
            if (adapter.supportsAdvice(advice)) {
                interceptors.add(adapter.getInterceptor(advisor));
            }
        }
        if (interceptors.isEmpty()) {
            throw new UnknownAdviceTypeException(advisor.getAdvice());
        }
        return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
    }

 

/**
 * Adapter to enable {@link org.springframework.aop.MethodBeforeAdvice}
 * to be used in the Spring AOP framework.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 */
class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {
  
    public boolean supportsAdvice(Advice advice) {
        return (advice instanceof MethodBeforeAdvice);
    }
  
    public MethodInterceptor getInterceptor(Advisor advisor) {
        获取出advisor里面持有的advice对象 
        MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
        然后用MethodBeforeAdviceInterceptor这个类包装起来
        return new MethodBeforeAdviceInterceptor(advice);
    }
  
}

 

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
  
    private MethodBeforeAdvice advice;
 
    /**
     * Create a new MethodBeforeAdviceInterceptor for the given advice.
     * @param advice the MethodBeforeAdvice to wrap
     */
    MethodBeforeAdviceInterceptor的构造方法很简单 就是把advice的引用传进来即可    
    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }
    这里就是后面调用前置后置通知的关键了 this.advice.before()调用了前置通知  
    mi.proceed(); 则重新回到proceed方法 开始执行下一个Interceptor  是递归的
    public Object invoke(MethodInvocation mi) throws Throwable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
        return mi.proceed();
    }
  
}

 好了至此就已经获取到 Interceptor chain  可以开始做调用了