文档章节

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

爱宝贝丶
 爱宝贝丶
发布于 2018/08/26 14:33
字数 1742
阅读 572
收藏 18

       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是一样的,因而这里并没有对其细节进行过多描述。

© 著作权归作者所有

爱宝贝丶

爱宝贝丶

粉丝 332
博文 135
码字总数 452888
作品 0
武汉
程序员
私信 提问
Spring AOP 创建代理的源码解析

相关文章 Spring AOP 注解方式源码解析 Spring AOP 功能使用详解 Spring 的 getBean 方法源码解析 Spring bean 创建过程源码解 Spring 中 bean 注册的源码解析 前言 在上篇文章 Spring AOP 注...

TSMYK
01/01
149
0
Spring AOP 功能使用详解

相关文章 Spring 中 bean 注册的源码解析 Spring bean 创建过程源码解析 Spring 的 getBean 方法源码解析 前言 AOP 既熟悉又陌生,了解过 Spring 人的都知道 AOP 的概念,即面向切面编程,可...

TSMYK
2018/12/25
284
2
Spring AOP是什么?你都拿它做什么?

原文出处:我叫刘半仙 为什么会有面向切面编程(AOP)?我们知道Java是一个面向对象(OOP)的语言,但它有一些弊端,比如当我们需要为多个不具有继承关系的对象引入一个公共行为,例如日志、...

我叫刘半仙
01/12
0
0
spring基础知识---AOP动态代理原理

Spring Boot实践——Spring AOP实现之动态代理 Spring AOP 介绍   AOP的介绍可以查看 Spring Boot实践——AOP实现   与AspectJ的静态代理不同,Spring AOP使用的动态代理,所谓的动态代理...

spinachgit
02/21
177
0
Spring应用学习——AOP

AOP 1. AOP:即面向切面编程,采用横向抽取机制,取代了传统的继承体系的重复代码问题,如下图所示,性能监控、日志记录等代码围绕业务逻辑代码,而这部分代码是一个高度重复的代码,也就是在...

江左煤郎
2018/11/18
37
0

没有更多内容

加载失败,请刷新页面

加载更多

Centos7 安装zabbix-agent

rpm -i https://repo.zabbix.com/zabbix/4.2/rhel/6/x86_64/zabbix-release-4.2-2.el6.noarch.rpm 可以到https://repo.zabbix.com/zabbix找到对应的版本 yum install zabbix-agent -y 出现E......

abowu
昨天
8
0
文本编辑器GNU nano 4.4 发布

GNU nano 4.4 "Hagelslag" 更新日志: 启动时,光标可以放在第一个或最后一个出现位置 字符串前面带有+/string 或 +?string的字符串。 发生自动硬包装时((--breaklonglines),任何前导引号...

linuxCool
昨天
7
0
你知道字节序吗

字节序 最近在调一个自定义报文的接口时,本来以为挺简单的,发现踩了好几个坑,其中一个比较“刻骨铭心”的问题就是数据的字节序问题。 背景 自定义报文,调用接口,服务端报文解析失败 iO...

杭城小刘
昨天
3
0
设计模式之依赖倒置原则

方法

东风破2019
昨天
6
0
关于如何通过模拟器完成模拟步数提升傻瓜式解决方案(囧)

因为对Android开发不太了解,也没去问朋友所以误打误撞找到的一个提升步数的解决方案,当然只是针对某安APP运动RUN的解决方式吧。 对Android不太了解,所以找了很多的解决方案来看看能不能破...

华山猛男
昨天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部