实现一个增强版的JDK动态代理V2.0

最新推荐文章于 2022-11-09 10:51:41 发布
最新推荐文章于 2022-11-09 10:51:41 发布
阅读量287 收藏 1
点赞数 1
分类专栏： Java 基础 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18515155/article/details/118031761
版权
Java 同时被 2 个专栏收录
34 篇文章 3 订阅
订阅专栏
基础
22 篇文章 0 订阅
订阅专栏

文章目录

之前有个文章实现了一个简单的增强版JDK动态代理：实现一个增强版的JDK动态代理V1.0。

但是当时只是实现了方法前增强和方法返回后增强的效果，至少还有如下两个不足：

1）前、后增强是通过写死执行增强的位置来实现；

2）没有实现环绕增强；

分析之前实现的不足

1）前、后增强是通过写死执行增强的位置来实现

先来回顾一下之前实现的代码

public Object proceed(JoinPointInfo joinPointInfo) throws Exception {
      	//1）方法执行前增强
        before(joinPointInfo);
  			// 判断目标方法是否已经执行过了
        if (!isTargetMethodExecuted) {
          	//执行目标方法
            Object o = joinPointInfo.getMethod().invoke(joinPointInfo.getTarget(),joinPointInfo.getArgs());
            isTargetMethodExecuted = true;
            joinPointInfo.setReturnValue(o);
        }
      	//2）方法返回后增强
        afterReturn(joinPointInfo);
        return joinPointInfo.getReturnValue();
    }

可以看到上面1）、2）两处，是通过固定其执行的位置，让before拦截器在真正的方法执行前执行，让afterReturn拦截器在真正的方法执行后执行。

这样做相当于是写死了一个模版，不优雅并且后期不容易扩展（甚至都不能满足环绕增强的需求）

2）没有实现环绕增强

最常用的环绕增强功能没有实现，且在当前的设计下很难实现，必须重新思考多层拦截增强的本质进行重新设计。

优化改进

在参考了Spring AOP解决方案以后，会发现：

  • 不同类型拦截器的增强就是方法调用，栈帧入栈和出栈的一个过程；

  • 而相同类型多个拦截器的增强就是责任链模式的调用。

1、首先将MethodInterceptor抽象为一个接口：

/**
     * 执行增强
     * @param chain
     * @param joinPointInfo
     * @return
     * @throws Exception
     */
    Object proceed(InterceptorChain chain, JoinPointInfo joinPointInfo) throws Exception;
    /**
     * 用户自定义增强逻辑
     * @param joinPointInfo
     */
    void proceed(JoinPointInfo joinPointInfo) throws Exception;

    /**
     * 获取连接点类型
     * @return
     */
    JoinPointEnum getJoinPoint();

    /**
     * 获取顺序编号，可以重写该方法修改默认排序
     * @return
     */
    default int getOrder() {return 1;}

2、分别针对方法执行前增强、方法返回后增强实现基于MethodInterceptor的抽象类：

/**
 * @author xujian
 * 2021-05-26 10:11
 **/
public abstract class AbstractBeforeMethodInterceptor implements MethodInterceptor {
    /**
     * 执行增强
     * @param chain
     * @param joinPointInfo
     * @return
     * @throws Exception
     */
    @Override
    public final Object proceed(InterceptorChain chain, JoinPointInfo joinPointInfo) throws Exception {
        proceed(joinPointInfo);
        return chain.proceed(joinPointInfo);
    }
	
	/**
     * 获取连接点类型
     *
     * @return
     */
    @Override
    public final JoinPointEnum getJoinPoint() {
        return JoinPointEnum.BEFORE;
    }
}

/**
 * @author xujian
 * 2021-05-26 10:11
 **/
public abstract class AbstractAfterReturnMethodInterceptor implements MethodInterceptor {
    /**
     * 执行增强
     * @param chain
     * @param joinPointInfo
     * @return
     * @throws Exception
     */
    @Override
    public final Object proceed(InterceptorChain chain, JoinPointInfo joinPointInfo) throws Exception {
        Object o = chain.proceed(joinPointInfo);
        proceed(joinPointInfo);
        return o;
    }
	
	/**
     * 获取连接点类型
     *
     * @return
     */
    @Override
    public final JoinPointEnum getJoinPoint() {
        return JoinPointEnum.AFTER_RETURN;
    }
}

方法环绕增强不需要实现对应的抽象类，增强逻辑完全由使用者实现，参考Spring AOP Aspect。

3、修改InterceptorChain执行增强的逻辑：

/**
 * 拦截器链
 * @author xujian
 * 2021-05-26 10:09
 **/
public class InterceptorChain {
    /**
     * 拦截器列表
     */
    private List<MethodInterceptor> methodInterceptors = new ArrayList<>();
    private int currentInterceptorIndex = -1;

    public InterceptorChain(List<MethodInterceptor> interceptors) {
        //根据增强时机（连接点）分组
        Map<String, List<MethodInterceptor>> interceptorMap =
                interceptors.stream().collect(groupingBy(m -> m.getJoinPoint().getName()));
        //方法执行前增强的拦截器
        List<MethodInterceptor> beforeInterceptors = interceptorMap.get(JoinPointEnum.BEFORE.getName());
        //按照order排序
        beforeInterceptors.sort(Comparator.comparingInt(MethodInterceptor::getOrder));
        //方法返回后增强的拦截器
        List<MethodInterceptor> afterReturnInterceptors = interceptorMap.get(JoinPointEnum.AFTER_RETURN.getName());
        //按照order排序
        afterReturnInterceptors.sort(Comparator.comparingInt(MethodInterceptor::getOrder));
        //方法环绕增强的拦截器
        List<MethodInterceptor> aroundInterceptors = interceptorMap.get(JoinPointEnum.AROUND.getName());
        //按照order排序
        aroundInterceptors.sort(Comparator.comparingInt(MethodInterceptor::getOrder));
        //按照around->before->afterReturn的顺序添加到methodInterceptors
        methodInterceptors.addAll(aroundInterceptors);
        methodInterceptors.addAll(beforeInterceptors);
        methodInterceptors.addAll(afterReturnInterceptors);
    }

    /**
     * 执行方法
     * @param joinPointInfo
     * @return
     * @throws Exception
     */
    public Object proceed(JoinPointInfo joinPointInfo) throws Exception {
        if (currentInterceptorIndex == methodInterceptors.size() - 1) {
            //执行目标方法
            return joinPointInfo.getMethod().invoke(joinPointInfo.getTarget(),joinPointInfo.getArgs());
        }
        MethodInterceptor methodInterceptor = methodInterceptors.get(++currentInterceptorIndex);
        return methodInterceptor.proceed(this,joinPointInfo);
    }
}

可以和旧版做个对比：

/**
 * 拦截器链
 * @author xujian
 * 2021-05-26 10:09
 **/
public class InterceptorChain {
    /**
     * 方法执行前拦截器列表
     */
    private List<MethodInterceptor> beforeInterceptors;
    /**
     * 方法正常返回后拦截器列表
     */
    private List<MethodInterceptor> afterReturnInterceptors;
  
    private int currentBeforeInterceptorIndex = -1;
    private int currentAfterReturnInterceptorIndex = -1;
  	/**
     * 是否已经执行过目标方法
     */
    private boolean isTargetMethodExecuted;

    public InterceptorChain(List<MethodInterceptor> interceptors) {
        //根据增强时机（连接点）分组
        Map<String, List<MethodInterceptor>> interceptorMap =
                interceptors.stream().collect(groupingBy(m -> m.getJoinPoint().getName()));
        //方法执行前增强的拦截器
        beforeInterceptors = interceptorMap.get(JoinPointEnum.BEFORE.getName());
        //按照order排序
        beforeInterceptors.sort(Comparator.comparingInt(MethodInterceptor::getOrder));
        //方法返回后增强的拦截器
        afterReturnInterceptors = interceptorMap.get(JoinPointEnum.AFTER_RETURN.getName());
        //按照order排序
        afterReturnInterceptors.sort(Comparator.comparingInt(MethodInterceptor::getOrder));
    }

  	/**
     * 执行方法
     * @param joinPointInfo
     * @return
     * @throws Exception
     */
    public Object proceed(JoinPointInfo joinPointInfo) throws Exception {
      	//方法执行前增强
        before(joinPointInfo);
        if (!isTargetMethodExecuted) {
          	//执行目标方法
            Object o = joinPointInfo.getMethod().invoke(joinPointInfo.getTarget(),joinPointInfo.getArgs());
            isTargetMethodExecuted = true;
            joinPointInfo.setReturnValue(o);
        }
      	//方法返回后增强
        afterReturn(joinPointInfo);
        return joinPointInfo.getReturnValue();
    }

    public void before(JoinPointInfo joinPointInfo) throws Exception {
        if (currentBeforeInterceptorIndex == beforeInterceptors.size() - 1) {
            return;
        }
        MethodInterceptor methodInterceptor = beforeInterceptors.get(++currentBeforeInterceptorIndex);
        methodInterceptor.proceed(this,joinPointInfo);
    }

    public void afterReturn(JoinPointInfo joinPointInfo) throws Exception {
        if (currentAfterReturnInterceptorIndex == afterReturnInterceptors.size() - 1) {
            return;
        }
        MethodInterceptor methodInterceptor = afterReturnInterceptors.get(++currentAfterReturnInterceptorIndex);
        methodInterceptor.proceed(this,joinPointInfo);
    }
}

可以发现新版相比旧版proceed()方法明显优雅简洁了很多。

4、自定义拦截增强器

对之前的AfterAfterReturnMethodInterceptor、AfterReturnMethodInterceptor、BeforeBeforeMethodInterceptor、BeforeMethodInterceptor做修改如下：

/**
 * @author xujian
 * 2021-05-26 11:35
 **/
public class AfterAfterReturnMethodInterceptor extends AbstractAfterReturnMethodInterceptor {

    /**
     * 用户自定义增强逻辑
     *
     * @param joinPointInfo
     */
    @Override
    public void proceed(JoinPointInfo joinPointInfo) {
        System.out.println("----afterafter");
    }
}

/**
 * @author xujian
 * 2021-05-26 11:35
 **/
public class AfterReturnMethodInterceptor extends AbstractAfterReturnMethodInterceptor {


    /**
     * 用户自定义增强逻辑
     *
     * @param joinPointInfo
     */
    @Override
    public void proceed(JoinPointInfo joinPointInfo) {
        System.out.println("----after");
    }

    /**
     * 获取顺序编号，可以重写该方法修改默认排序
     *
     * @return
     */
    @Override
    public int getOrder() {
        return 2;
    }
}

/**
 * @author xujian
 * 2021-05-26 11:35
 **/
public class BeforeBeforeMethodInterceptor extends AbstractBeforeMethodInterceptor {


    /**
     * 用户自定义增强逻辑
     *
     * @param joinPointInfo
     */
    @Override
    public void proceed(JoinPointInfo joinPointInfo) {
        System.out.println("----beforebefore");
    }
}

/**
 * @author xujian
 * 2021-05-26 11:35
 **/
public class BeforeMethodInterceptor extends AbstractBeforeMethodInterceptor {

    /**
     * 用户自定义增强逻辑
     *
     * @param joinPointInfo
     */
    @Override
    public void proceed(JoinPointInfo joinPointInfo) {
        System.out.println("----before");
    }

    /**
     * 获取顺序编号，可以重写该方法修改默认排序
     *
     * @return
     */
    @Override
    public int getOrder() {
        return 2;
    }
}

除此之外，新增一个环绕拦截器，该拦截器直接实现MethodInterceptor接口：

/**
 * @author xujian
 * 2021-05-26 11:35
 **/
public class AroundMethodInterceptor implements MethodInterceptor {
    /**
     * 执行增强
     *
     * @param chain
     * @param joinPointInfo
     * @return
     * @throws Exception
     */
    @Override
    public Object proceed(InterceptorChain chain, JoinPointInfo joinPointInfo) throws Exception {
        System.out.println("----around-before");
        Object o = chain.proceed(joinPointInfo);
        System.out.println("----around-after");
        return o;
    }

    /**
     * 用户自定义增强逻辑
     *
     * @param joinPointInfo
     */
    @Override
    public void proceed(JoinPointInfo joinPointInfo) throws Exception {

    }

    /**
     * 获取连接点类型
     *
     * @return
     */
    @Override
    public JoinPointEnum getJoinPoint() {
        return JoinPointEnum.AROUND;
    }
}

5、修改测试方法

拦截器链除了之前的四个拦截器，本次再加上新增的AroundMethodInterceptor拦截器：

interceptors.add(new AroundMethodInterceptor());

6、测试验证

对于before、afterReturn、around这三种拦截增强的执行结果预期要和Spring AOP Aspect一样：

1、先执行around#System.out.println("----around-before")；

2、再执行before#System.out.println("----before")；

3、再执行业务方法userService#print()；

4、再执行afterReturn#System.out.println("----after")；

5、最后再执行around#System.out.println("----around-after")；

由于多个相同类型的拦截器会根据order字段排序，所以真正期望的结果是：

1、先执行AroundMethodInterceptor#System.out.println("----around-before")；

2、再执行BeforeBeforeMethodInterceptor#System.out.println("----beforebefore")；

3、再执行BeforeMethodInterceptor#System.out.println("----before")；

4、再执行业务方法userService#print()；

5、再执行AfterAfterReturnMethodInterceptor#System.out.println("----afterafter")；

6、再执行AfterReturnMethodInterceptor#System.out.println("----after")；

7、最后再执行AroundMethodInterceptor#System.out.println("----around-after")；

实际测试结果如下：

在这里插入图片描述
和预期结果一致。

整个执行流程可以在参考一下下面的时序图：
在这里插入图片描述

相关代码请参考：https://gitee.com/xujian01/blogcode/tree/master/src/main/java/enhancejdkproxy

墨、鱼
关注
专栏目录
浅谈Spring中JDK动态代理和CGLIB动态代理
CharlesYooSky的博客
10-21 1730
浅谈Spring中JDK动态代理和CGLIB动态代理
Java基础加强_Eclipse、枚举、反射、注解、泛型、类加载器、动态代理
技术加工厂
03-12 2720
Eclipse MyEclipse是eclipse的一个插件，使得eclipse可以开发JavaEE项目 javaw.exe是启动java的图形界面所用的虚拟机 Java EE Java Enterprise IDE Integrated Development Environment 工程管理与快捷键设置 设置整个工作间编译器版本和运行时环境的版本 window-->Prefe
实现一个增强版的JDK动态代理V1.0
徐小陌的博客
05-27 390
文章目录背景现状目标方案定义拦截器定义拦截器链定义InvocationHandler定义增强的代理生成类测试总结 背景 看了Spring AOP JDK动态代理部分的源码，想尝试借鉴Spring的思想，实现一个“增强版”的JDK动态代理。 本博文以及相关代码仅作为练习使用，欢迎指正和交流探讨。 现状 UserService userService = new UserServiceImpl(); MyInvocationHandler myInvocationHandler = new MyInvoca
jdk 动态代理实现对目标对象的增强
dianxunma2886的博客
04-23 152
因为学习 spring框架的 AOP 所以，这里复习下动态代理，但是 spring 的底层动态代理实现是 cglib，jdk 这种呢可以引导新手入门 spring AOP 横向抽取机制 最典型的应用当属 log ，transaction 了，具体可以从配置文件的配置以及注解看出 首先基于 jdk 的动态代理需要借助于 jdk 中 reflect 包下(java.lang.r...
jdk动态代理强化篇
最新发布
m0_67486569的博客
11-09 113
jdk动态代理
JDK 动态代理/手写 AOP/Proxy 增强
在路上的博客
07-11 316
闲来无事，简单实现个 AOP 包装类，然而用处并不大，请酌情观看。 嗯 ~~？写的什么玩意？我还是用 AspectJ 吧。
这个疯子整理的十万字Java面试题汇总，终于拿下40W offer！（JDK源码+微服务合集+并发编程+性能优化合集+
m0_67401134的博客
07-23 2366
Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题,使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造,这使得我们可以在开发环境中安心的集成Spring框架,不必担心Spring是如何在后台进行工作的。Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。...
从0开始搭建一个微服务后端系统-基础入门篇
m0_37208669的博客
08-30 2820
前言 今天开始，我和大家一起，从0开始，基于Spring Cloud Alibaba，搭建一套基本的微服务架构的项目。 主要用到下面的知识内容 JDK8/IDEA/Maven Spring/SpringBoot/Spring Cloud Alibaba Dubbo/openfeign：服务间调用 这里之所以引入了两种调用方式，是为了方便根据接口的实际情况，选择合适的调用方式 Seata：分布式事务 MySQL Redis RabbitMQ/RocketMQ RBAC：这里，我不打算使用常见的 Spr
Java中高级面试题总览(一)
热门推荐
击水三千里的专栏
03-29 2万+
高频面试题深入剖析
一篇博客搞懂AOP相关原理
m0_61820867的博客
09-19 434
详细介绍了AOP的地产v原理和详细用法以及AspectJ AOP框架
jdk 各版本
08-15
1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 （32 64）
android studio2.0 jdk1.8
08-30
android studio2.0 （含sdk） jdk1.8
JDK动态代理-代码增强测试
Ara_Hu的博客
06-20 169
Java不破坏原有接口实现方法逻辑的前提下，实现对其方法的增强。
springAOP--JDK动态代理及链式增强逻辑
weixin_43470959的博客
05-03 246
1.ProxyFactory.getProxy()-获取到代理对象 public Object getProxy(ClassLoader classLoader) { return createAopProxy().getProxy(classLoader); } //通过该方法决定使用jdk动态代理还是cglib动态代理 //1.如果目标对象实现了接口，使用jdk //2.没有实现接口，使用cglib //3.如果实现了接口，可以通过设置属性proxy-target-class为true强制使用cg
动态代理实现方法增强
qq_42138058的博客
08-19 427
使用动态代理模式实现方法增强
聊聊JDK动态代理
阿呆的专栏
02-19 356
最近发现对JDK的动态代理以前看过的东西已经模糊了，发现了自己对这块的理解不够，而且没有记录笔记导致如今呵呵哒，所以今天重新梳理下这块 代理模式 使用代理模式创建的代理对象，可以控制对目标对象的访问，以及前置、后置处理，代理模式强调的是代表目标对象。装饰器模式而是针对对象的某个行为进行装饰，通过不同的装饰改变被装饰的行为，强调的是挂载，不断的向行为上挂载行为改变行为增强对象。 图片摘自Hea...
浅谈JDK动态代理
ZHUSHANGLIN的博客
01-31 1330
“动态代理”四个字一出来，估计很多初学者已经开始冒冷汗。它之所以给人感觉很难，有三点原因： 代码形式很诡异，让人搞不清调用逻辑 用到了反射，而很多初学者不了解反射 包含代理模式的思想，本身比较抽象 尽管动态代理看起来似乎有一定难度，但却必须拿下。因为Spring的事务控制依赖于AOP，AOP底层实现便是动态代理 + 责任链，环环相扣。所以说，搞编程的，拼到到最后还是看基本功，要么是语言基础、要么是计算机基础。 一个小需求：给原有方法添加日志打印 假设你刚进入一个项目组，项目中存在一个Calc
关于JDK动态代理（代码级别）
weixin_43958958的博客
07-14 143
代理 使用代理模式的作用： 功能增强：在你原有的功能上，增加了额外的功能。 控制访问：代理类不让你访问目标。例如商家不让用户访问厂家 实现代理的方式 静态代理：代理类是自己手工实现的， 自己创建一个java类表示代理类，同时所要的代理目标是确定的。 特点：实现简单；容易理解 缺点：目标类增加，代理类可能也要成倍增加；当接口中功能修改/增加，会影响众多实现类 动态代理：可以避免静态代理的缺点 在程序的执行过程中，使用jdk的反射机制，创建代理类对象，并动态指定要代理的目标类 也就是使用jdk的反射机制，创建对
AOP增强、JDK代理、cglib代理
PnJgHT的博客
07-07 273
aop除了代理增强之外还有其他的增强方式一：ajc增强，没有利用到spring容器，而是用了ajc编译器来增强方式二：agent类加载增强是jdk自带的代理功能，只能针对接口代理。产生代理需要用到jdk的Proxy中的newProxyInstance方法。参数1-类加载器：因为相比于正常编写的Java代码，代理对象的生成是没有源码的，是在运行期间直接生成字节码文件，所以就需要一个类加载器去加载这个字节码文件参数2-要实现的接口参数3-invocationHandler接口：代理类创建出来，也实现了接口，还要
Java动态代理：JDK与Cglib实现日志管理
为了使用JDK动态代理，我们需要创建一个实现了相同接口的代理类，代理类在调用实际方法之前和之后添加日志记录。 2. **Cglib动态代理**： Cglib库是另一个用于实现动态代理的技术，它通过继承目标类来创建代理对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值