专栏首页Java后端技术栈cwnaitSpring Aop之Jdk代理实现原理详解

Spring Aop之Jdk代理实现原理详解

Jdk代理,也称为动态代理,其代理目标对象的方式是生成一个与目标对象实现同一个接口的类,该类的构造函数中会传入一个InvocationHandler类型的对象。因为InvocationHandler对象是用户自定义的织入了切面逻辑的类,因而在需要使用目标对象的地方,只需要将生成的代理类的对象传入即可。又因为生成的代理类与目标类都实现了同一接口,因而从语法上其是没有任何问题的。另一方面,在传入代理类对象之后,代理类通过调用构造函数传入的InvocationHandler.invoke()方法,从而动态的调用目标类的方法,最终利用这种方式织入了代理逻辑。

在讲解Spring Aop如何实现动态代理之前,建议读者先去阅读本人上一篇文章Spring Aop之Cglib实现原理详解,因为Cglib代理和Jdk代理织入切面逻辑的方式是类似的,只是生成代理类的方式不一样,并且本文中部分方法的实现原理在上一篇文章中已经进行了详细的讲解,这里就不再赘述。

1. 代理对象的构造

前面我们讲到,Spring Aop使用AopProxy.getProxy()方法获取代理对象的,而JdkDynamicAopProxy则已经实现了该接口,因而我们可以直接阅读其getProxy()方法的源码:

public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " 
            + this.advised.getTargetSource());
    }
    // 完善代理对象需要实现的接口,主要是会默认增加三个需要实现的接口:SpringProxy,
    // Advised和DecoratingProxy。这三个接口的作用主要如下:
    // SpringProxy:该接口没有任何方法,主要用于标识当前对象是Spring生成的代理对象;
    // Advised:用于封装生成代理对象所需要的所有信息;
    // DecoratingProxy:其有一个getDecoratedClass()方法,用于返回当前代理对象的目标对象的Class类型
    Class<?>[] proxiedInterfaces = AopProxyUtils
        .completeProxiedInterfaces(this.advised, true);
    // 找到接口中是否包含有equals()和hashCode()方法,并进行标识
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    // 使用动态代理生成代理对象
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

上述方法逻辑其实比较简单,主要就是首先获取生成代理对象所需要实现的所有接口;然后判断接口中是否包含有equals()和hashCode()方法,因为这将用于判断生成的代理类是使用用于定义的equals()和hashCode()方法还是使用自动生成的方法;最后就是通过动态代理生成代理对象,这里需要注意的是JdkDynamicAopProxy不仅实现了AopProxy接口还实现了InvocationHandler接口,因而这里生成代理对象的时候传入的InvocationHandler对象是this。

2. 切面逻辑的织入

由于JdkDynamicAopProxy已经实现了InvocationHandler接口,因而代理逻辑的织入就是在JdkDynamicAopProxy.invoke()方法中,这里我们直接阅读器源码:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource;
    Object target = null;

    try {
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            // 如果当前方法是equals()方法,并且接口中并未定义该方法,就使用自动生成的equals()方法
            return equals(args[0]);
        } else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            // 如果当前方法是hashCode()方法,并且接口中并未定义该方法,就使用自动生成的hashCode()方法
            return hashCode();
        } else if (method.getDeclaringClass() == DecoratingProxy.class) {
            // 如果当前方法是Spring织入的DecoratingProxy接口中的方法,则返回目标对象的Class类型
            return AopProxyUtils.ultimateTargetClass(this.advised);
        } else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                 method.getDeclaringClass().isAssignableFrom(Advised.class)) {
            // 如果当前方法是Spring织入的Advised接口中的方法,
            // 则使用反射调用当前advised对象中的相关方法
            return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
        }

        Object retVal;
        if (this.advised.exposeProxy) {
            // 如果设置了需要暴露代理对象,则将当前对象设置到AopContext中
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }

        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);

        // 获取当前方法需要织入的切面逻辑的调用链
        List<Object> chain = this.advised
            .getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

        if (chain.isEmpty()) {
            // 如果切面逻辑的调用链为空,则对方法参数进行类型转换处理,
            // 并且通过反射直接调用目标对象的方法
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
        } else {
            // 获取目标对象的调用链逻辑,并且对该链进行调用
            invocation = new ReflectiveMethodInvocation(proxy,
                target, method, args, targetClass, chain);
            retVal = invocation.proceed();
        }

        Class<?> returnType = method.getReturnType();
        if (retVal != null && retVal == target &&
            returnType != Object.class && returnType.isInstance(proxy) &&
            !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
            // 判断返回值如果为目标对象,并且当前方法的返回值类型是当前代理对象的类型,那么就将
            // 当前代理对象返回。这里的逻辑的实际意思简单的说就是,如果返回值是目标对象,那么
            // 就将当前代理对象返回
            retVal = proxy;
        } else if (retVal == null && returnType != Void.TYPE
                   && returnType.isPrimitive()) {
            // 如果返回值满足其为空,不是Void类型,并且是基本数据类型,那么就抛出异常,
            // 因为基本数据类型的返回值必然不为空
            throw new AopInvocationException("Null return value from advice does not " 
                + " match primitive return type for: " + method);
        }
        return retVal;
    } finally {
        if (target != null && !targetSource.isStatic()) {
            // 如果TargetSource不是静态的,则调用其releaseTarget()方法将生成的目标对象释放
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            // 处理AopContext中保存的当前代理对象
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}

可以看到,在进行代理逻辑的织入的时候,首先会进行如下判断:①当前方法是否为equals()或hashCode()方法,如果是,并且接口中并未要求子类实现这些方法,那么就会调用自动生成的方法;②当前方法是否为Spring织入的DecoratingProxy接口中的方法,如果是,则将目标对象的Class类型返回;③判断目标方法是否为Spring织入的Advised中的方法,如果是,则调用当前advised对象中相应的方法。然后就会获取当前方法需要织入的代理逻辑的调用链。接着就会将目标对象和调用链逻辑封装为ReflectiveMethodInvocation,并进行调用。最后对调用的返回值进行一些基本判断,并且返回。

3. 小结

本文首先对Jdk代理进行了简单的介绍,然后介绍了Spring Aop是如何调用将Jdk代理的Proxy引入并且生成代理对象的,最后对调用链的生成,以及切面逻辑的织入方式进行了讲解。关于调用链的生成以及切面逻辑的织入,由于使用的方式和Cglib是一样的,因而这里并没有对其细节进行过多描述。

原文:https://my.oschina.net/zhangxufeng/blog/1934124

本文分享自微信公众号 - Java后端技术栈(t-j20120622),作者:lawt

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-07-13

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 浅谈几种设计模式--代理模式

    代理模式(Proxy Pattern),为其他对象提供一个代理,并由代理对象控制原有对象的引用;也称为委托模式。

    用户4143945
  • Spring AOP 的实现机制

    AOP(Aspect Orient Programming),一般称为面向切面编程,作为面向对象的一种补充,用于处理系统中分布于各个模块的横切关注点,比如事务管...

    用户4143945
  • 代理模式实现方式及优缺点对比

    代理模式最典型的应用就是AOP,本文结合主要讲解了代理模式的几种实现方式:静态代理和动态代理,这里动态代理又可以分为jdk代理和Cglib代理,另外,本文也对这...

    用户4143945
  • 代理模式

    代理模式:为其他对象提供一种代理以控制对这个对象的访问。 解释:举例来说,你想在美国买iphone6,但是你没有到美国去,恰巧你有一朋友到美国出差,于是你让...

    刘晓杰
  • Go语言实战笔记(十九)| Go Writer 和 Reader

    Go Writer 和 Reader接口的设计遵循了Unix的输入和输出,一个程序的输出可以是另外一个程序的输入。他们的功能单一并且纯粹,这样就可以非常容易的编...

    飞雪无情
  • 图论 Warshall 和Floyd 矩阵传递闭包

    我们来说下有向图,一般的有向图也是图,图可以分为稠密图,稀疏图,那么从意思上,稠密图就是点的边比较多,稀疏图就是边比较少的图。为什么稠密图放在矩阵比较省空间,因...

    林德熙
  • JupyterLab——更具生产力的Jupyter环境

    Jupyter源于Ipython Notebook,是使用Python(也有R、Julia、Node等其他语言的内核)进行代码演示、数据分析、可视化、教学的很好...

    ★忆先★
  • Vim "小知识点"

    在一个选项后面加上 ? 来查看当前的选项值, 比如, :set undodir? .

    用户1558438
  • 03.WebService_CXF

    03.WebService_CXF 一、什么是CXF? Apache CXF = Celtix + Xfire,开始叫 Apache CeltiXfi...

    奋斗蒙
  • 干货 | 从入门到放弃:21种机器学习算法详解,附多种下载方式

    关键字全网搜索最新排名 【机器学习算法】:排名第一 【机器学习】:排名第二 【Python】:排名第三 【算法】:排名第四 下面是各模型在博客中的详细解说,为方...

    昱良

扫码关注云+社区

领取腾讯云代金券