Spring系列之AOP分析之对目标对象的拦截过程(七)-阿里云开发者社区

开发者社区> 木叶_之荣> 正文

Spring系列之AOP分析之对目标对象的拦截过程(七)

简介:
+关注继续查看

我们在上一篇文章中简单的说了一下SpringAOP使用JDK动态代理生成目标对象的过程,我们在这一篇文章中说一下SpringAOP对生成的动态代理对象的方法的拦截过程(即SpringAOP拦截过程),这个分析的过程可能会比较长。
在上一篇文章中我们说的使用JDK创建动态代理对象是用的JdkDynamicAopProxy这个类,这个类同时实现了InvocationHandler这个接口,实现了它的invoke方法,熟悉JDK动态代理的同学都知道,当我们调用动态代理对象的方法的时候,会进入到生成代理对象时所传入的InvocationHandler实现类的invoke方法中,在这里也就是指JdkDynamicAopProxy的invoke方法,我们进入到这个invoke方法中看一下:

    @Override
    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 {
            //接口中没有定义 equals方法(这个方法定义形式和Object中保持一致 ),并且调用的方法是equals方法(即Object中定义的equals方法) 
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                //调用 JdkDynamicAopProxy 中写的equals方法
                return equals(args[0]);
            }else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                //和上面的分析一样
                return hashCode();
            }else if (method.getDeclaringClass() == DecoratingProxy.class) {
                //没用过 留作以后再说
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }else if (!this.advised.opaque && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) {
              //如果 方法所在的类是接口 并且是Advised的子类,则直接调用下面的方法,这个方法在下面分析 
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;
            //是否对外暴露代理对象
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                //把之前创建的代理对象放到线程上下文中
                //oldProxy为之前线程上下文中的对象
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
            //从TargetSource中获取目标对象
            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }
            //从Advised中根据方法名和目标类获取 AOP拦截器执行链 重点要分析的内容
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
            //如果这个执行链为空的话
            if (chain.isEmpty()) {
                //直接进行方法调用
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                //如果AOP拦截器执行链不为空  说明有AOP通知存在
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                //开始调用
                retVal = invocation.proceed();
            }
            //方法的返回值类型
            Class<?> returnType = method.getReturnType();
            if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                //return this
                retVal = proxy;
            }
            //返回值类型错误
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            //如果目标对象不为空  且目标对象是可变的 如prototype类型
            //通常我们的目标对象都是单例的  即targetSource.isStatic为true
            if (target != null && !targetSource.isStatic()) {
                //释放目标对象
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                //线程上下文复位
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

在上面的方法中大致了说明了一下整个代理对象方法调用的执行过程,像equals和hashcode方法的调用,Advised子类的调用。重点就是在连接点处执行不同的通知类型的调用,即获取AOP拦截执行链的调用。下面我们要分析的就是这个过程:
this.advised.getInterceptorsAndDynamicInterceptionAdvice。
我们这里的advised是一个AdvisedSupport类型的实例,它可能是ProxyFactory的实例也可能是AspectJProxyFactory实例。我们进入到getInterceptorsAndDynamicInterceptionAdvice这个方法中去看一下:

    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
        //创建一个method的缓存对象 在MethodCacheKey中实现了equals和hashcode方法同时还实现了compareTo方法
        MethodCacheKey cacheKey = new MethodCacheKey(method);
        List<Object> cached = this.methodCache.get(cacheKey);
        //先从缓存中获取 如果缓存中获取不到 则再调用方法获取,获取之后放入到缓存中
        if (cached == null) {
            //调用的是advisorChainFactory的getInterceptorsAndDynamicInterceptionAdvice方法
            cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                    this, method, targetClass);
            this.methodCache.put(cacheKey, cached);
        }
        return cached;
    }

上面的方法的调用过程是先从缓存中获取,缓存中获取不到的话,再交给AdvisorChainFactory,通过调用AdvisorChainFactory中的getInterceptorsAndDynamicInterceptionAdvice方法来获取拦截器执行链,放入到缓存中。AdvisorChainFactory在SpringAOP中只有一个默认的实现类:DefaultAdvisorChainFactory,所以我们去这个DefaultAdvisorChainFactory类中看一下这个方法的内容。

    //在这个方法中传入了三个实例,一个是Advised的实例 一个是目标方法 一个是目标类可能为null
    //想想我们在前面的文章中说过的,在Advised中都有什么内容
    @Override
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
            Advised config, Method method, Class<?> targetClass) {
        //创建一个初始大小为 之前获取到的 通知个数的 集合
        List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
        //如果目标类为null的话,则从方法签名中获取目标类
        Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
        //判断目标类是否存在引介增强 通常为false
        boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
        //这里用了一个单例模式 获取DefaultAdvisorAdapterRegistry实例
        //在Spring中把每一个功能都分的很细,每个功能都会有相应的类去处理 符合单一职责原则的地方很多 这也是值得我们借鉴的一个地方
        //AdvisorAdapterRegistry这个类的主要作用是将Advice适配为Advisor 将Advisor适配为对应的MethodInterceptor 我们在下面说明
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        //循环 目标方法匹配的 通知
        for (Advisor advisor : config.getAdvisors()) {
            //如果是PointcutAdvisor类型的实例  我们大多数的Advisor都是PointcutAdvisor类型的
            if (advisor instanceof PointcutAdvisor) {
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                //如果提前进行过 切点的匹配了  或者当前的Advisor适用于目标类
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    //将Advisor适配为MethodInterceptor
                    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    //检测Advisor是否适用于此目标方法
                    if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
                        //MethodMatcher中的切点分为两种 一个是静态的 一种是动态的
                        //如果isRuntime返回true 则是动态的切入点 每次方法的调用都要去进行匹配
                        //而静态切入点则回缓存之前的匹配结果值 
                        if (mm.isRuntime()) {
                            //动态切入点 则会创建一个InterceptorAndDynamicMethodMatcher对象
                            //这个对象包含MethodInterceptor和MethodMatcher 的实例
                            for (MethodInterceptor interceptor : interceptors) {
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                            }
                        }
                        else {
                            //添加到列表中
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
            //如果是引介增强
            else if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                    //将Advisor转换为Interceptor
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
            //以上两种都不是
            else {
                //将Advisor转换为Interceptor
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }
        return interceptorList;
    }

在上面这个方法中主要干了这几件事:
1、循环目标方法的所有Advisor
2、判断Advisor的类型
如果是PointcutAdvisor的类型,则判断此Advisor是否适用于此目标方法
如果是IntroductionAdvisor引介增强类型,则判断此Advisor是否适用于此目标方法
如果以上都不是,则直接转换为Interceptor类型。
在上面的三个步骤中都干了这样的一件事,将Advisor转换为Interceptor类型。这里用到了一个很重要的一个类:DefaultAdvisorAdapterRegistry。从类名我们可以看出这是一个Advisor的适配器注册类。它的源码如下:

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {
    //初始化了一个size为3的集合 因为下面就添加了三个AdvisorAdapter
    private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);
    /**
     * Create a new DefaultAdvisorAdapterRegistry, registering well-known adapters.
     */
    public DefaultAdvisorAdapterRegistry() {
        //在SpringAOP中只默认提供了这三种通知类型的适配器
        //为什么没有其他通知类型的呢?参考AbstractAspectJAdvice下面的几个通知类型
        //前置通知适配器
        registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
        //后置返回通知适配器
        registerAdvisorAdapter(new AfterReturningAdviceAdapter());
        //后置异常通知适配器
        registerAdvisorAdapter(new ThrowsAdviceAdapter());
    }
    //这个方法的作用主要是将Advice转换为Advisor的
    @Override
    public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
        //如果传入的实例是Advisor 则直接返回
        if (adviceObject instanceof Advisor) {
            return (Advisor) adviceObject;
        }
        //如果传入的实例不是 Advice类型 则直接抛出异常
        if (!(adviceObject instanceof Advice)) {
            throw new UnknownAdviceTypeException(adviceObject);
        }
        Advice advice = (Advice) adviceObject;
        //如果这个Advice是MethodInterceptor类型的实例,则直接包装为DefaultPointcutAdvisor
        //DefaultPointcutAdvisor中的Pointcut为Pointcut.TRUE matches始终返回true
        if (advice instanceof MethodInterceptor) {
            return new DefaultPointcutAdvisor(advice);
        }
        //如果不是Advisor的实例 也不是MethodInterceptor类型的实例
        //看看是不是 上面的那种通知类型适配器所支持的类型
        for (AdvisorAdapter adapter : this.adapters) {
            // Check that it is supported.
            if (adapter.supportsAdvice(advice)) {
                return new DefaultPointcutAdvisor(advice);
            }
        }
        throw new UnknownAdviceTypeException(advice);
    }
    //这个方法是将 Advisor转换为 MethodInterceptor
    @Override
    public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
        List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
        //从Advisor中获取 Advice
        Advice advice = advisor.getAdvice();
        if (advice instanceof MethodInterceptor) {
            interceptors.add((MethodInterceptor) advice);
        }
        for (AdvisorAdapter adapter : this.adapters) {
            if (adapter.supportsAdvice(advice)) {
                //转换为对应的 MethodInterceptor类型
                //AfterReturningAdviceInterceptor MethodBeforeAdviceInterceptor  ThrowsAdviceInterceptor
                interceptors.add(adapter.getInterceptor(advisor));
            }
        }
        if (interceptors.isEmpty()) {
            throw new UnknownAdviceTypeException(advisor.getAdvice());
        }
        return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
    }
    //新增的 Advisor适配器
    @Override
    public void registerAdvisorAdapter(AdvisorAdapter adapter) {
        this.adapters.add(adapter);
    }
}

所以this.advised.getInterceptorsAndDynamicInterceptionAdvice这个方法获取的是目标方法的AOP拦截器执行链。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Spring AOP 源码分析——创建代理对象
1.简介 与筛选合适的通知器相比,创建代理对象的过程则要简单不少,本文所分析的源码不过100行,相对比较简单。在接下里的章节中,我将会首先向大家介绍一些背景知识,然后再去分析源码。
996 0
SpringBoot-13-插曲之Node文件重命名+自动生成json对象
遇到的问题:图片太多,使用起来挺麻烦 [1]有很多图片放服务器里,怎么能更好的管理,更方便拿到图片呢? [2]想用json 以一个对象数组的形式保存这些图片:以[{img:"图片名"},{img:"图片名"}....]形式 [3]虽说想法是很好,但不可能一条一条自己写吧,好歹咱也是21世纪敲代码的人。
829 0
spring mvc 传递对象 二
springController: [java] view plaincopy @Controller   @RequestMapping("/user")   public UserController extends BaseController{       @RequestMapping("/addUser")
1079 0
UML面向对象分析与建模-【6】状态图
一、概述 在一般的面向对象技术中,状态图又称为状态迁移图。描述了一个特定对象的所有可能状态以及由于各种事件的发生而引起的状态之间的迁移。大多数面向对象技术都使用状态图来描述一个对象在其生命周期中的行为。
652 0
Spring cloud Feign不支持对象传参解决办法[完美解决]
Spring cloud Feign不支持对象传参解决办法[完美解决] spring cloud 使用 Feign 进行服务调用时,不支持对象参数。 通常解决方法是,要么把对象每一个参数平行展开,并使用 @RequestParam 标识出每一个参数,要么用 @RequestBody 将请求改为 body 传参,虽然这样解决了问题,但是这样限制了传参方式,并且使代码变得很繁重。
1719 0
晚绑定场景下对象属性赋值和取值可以不需要Pro“.NET技术”pertyInfo
  在《一句代码实现批量数据绑定》中,我通过界面控件ID与作为数据源的实体属性名之间的映射实现了批量数据绑定。由于里面频繁涉及对属性的反射——通过反射从实体对象中获取某个属性值;通过反射为控件的某个属性赋值,所以这不是一种高效的操作方式。
625 0
关于 OpenGL 中平移矩阵变换与实体对象坐标平移的关系分析结论
关于 OpenGL 中平移矩阵变换与实体对象坐标平移的关系分析结论 太阳火神的美丽人生 (http://blog.csdn.net/opengl_es) 本文遵循“署名-非商业用途-保持一致”创作公用协议 转载请保留此句:太阳火神的美丽人生 -  本博客专注于 敏捷开发及移动和物联设备研究:iOS、Android、Html5、Arduino、pcDuino,否则,出自本博客的文章拒绝转载或再转载,谢谢合作。
643 0
UML面向对象分析与建模-【5】交互图
一、概述 交互图是用来表达系统的各个对象之间如何交互,如何合作完成某个行为的动态模型工具,它与用例图、状态图、活动图等共同构成了系统的行为视图。 交互图主要用于对用例图中的控制流进行建模,它包括序列图和协作图,其中,序列图按时间次序描述系统中各对象如何通过消息交互,协作图从空间上描述收发消息的对象的结构关系。
832 0
基于对象存储 OSS 的智能数据分析处理框架和功能
今年参加了 2019 全球闪存峰会(Flash Memory World),分享了“基于云存储的智能数据分析处理架构”,重点介绍在对象存储 OSS 之上的数据处理功能,现整理相关内容和大家探讨。
2129 0
153
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载