正文

深入理解［代理模式］原理与技术(代码片段)

pypua  pypua  2023-01-19  731

关键词：

本文原创投稿文作者：像风一样

如何理解代理模式？

思考抽象问题最好的办法就是具体化！

比如我们需要为一个业务方法在执行前后记录日志，为了达到解耦的目的，我们可以再新建一个类并定义一个新的业务方法，该方法既可以调用原业务方法，又可以在调用前后进行日志处理，例如：

CarProxy.class

public void move() 
   System.out.println("日志开始记录....");
   new Car().move();
   System.out.println("日志记录完成....");

代理模式的应用很多，比如Spring容器的延迟加载，AOP增强处理等。

一、静态代理

静态代理是由程序员创建或工具生成代理类的源码，再编译代理类。

所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

一句话，自己手写代理类就是静态代理。

基于继承的静态代理

目标对象：定义一个普通方法

public class Car 
   public void move() 
       System.out.println("1.汽车开始跑步");
       System.out.println("2.汽车跑到了终点");

代理对象：主要作用是继承目标对象，进行增强处理，并使用关键字super调用父类方法。

public class CarProxy extends Car 

   @Override
   public void move() 
       System.out.println("日志开始记录....");
       super.move();
       System.out.println("日志记录完成....");

测试方法：实际上是调用代理对象的move()方法。

public static void main(String[] args) 
   Car car = new CarProxy();
   car.move();

基于接口的静态代理

共同接口：定义一个普通的接口方法

public interface Moveable 
   void move();

目标对象：实现该接口方法。

public class Car implements Moveable 

   @Override
   public void move() 
       System.out.println("汽车行驶中....");

代理对象：调用目标对象的方法，并在调用前后进行增强处理。

public class CarProxy implements Moveable
   private Moveable move;

   @Override
   public void move() 
       if(move==null)
           move = new Car();
       
       System.out.println("开始记录日志：");
       move.move();
       System.out.println("记录日志结束！");

测试方法：实际上是调用代理对象的move()方法。

public static void main(String[] args) throws Exception 
    Moveable m =new CarProxy();
    m.move();

静态代理的优缺点

优点：

业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理模式的共有优点。

缺点：

1）代理对象的一个接口只服务于一种类型的对象，如果要代理的类型很多，势必要为每一种类型的方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

比如Car类的move()方法需要记录日志，如果还有汽车，火车，自行车类的move()方法也需要记录日志，我们都要一个个的去为它们生成代理类，太麻烦了。

2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。显而易见，增加了代码维护的复杂度。

二、动态代理

动态代理是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成。

简单来说，动态代理就是交给程序去自动生成代理类。

1、JDK的动态代理

JDK动态代理实现步骤：

创建被代理的类以及实现的接口；
创建一个实现接口InvocationHandler的类，它必须实现invoke方法；
调用Proxy的newProxyInstance静态方法，创建一个代理类。
通过代理对象调用目标方法。

代码示例

共同接口

public interface Moveable 
   String move();

目标对象：正常实现接口方法

public class Car implements Moveable 

   @Override
   public String move() 
       return "汽车行驶中";

对目标对象的增强处理：

public class LogHandler implements InvocationHandler
   private Object target;

   public LogHandler(Object object)
       super();
       this.target =  object;
   

   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
       //增强处理
       Object o = method.invoke(target,args);
       //增强处理
       return o;

实现InvocationHandler接口步骤：

定义含参构造方法，该参数为要代理的实例对象，目的是用于执行method.invoke()方法（也就是执行目标方法）
实现接口的invoke()方法，该方法用于对目标方法的增强处理，比如记录日志等。该方法的返回值就是代理对象执行目标方法的返回值。

具体参数：

proxy 动态生成的代理对象
method 目标方法的实例
args 目标方法的参数

测试方法：

public static void main(String[] args) 
   Moveable move =  (Moveable) Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), new LogHandler(new Car()));

   System.out.println("代理对象:"+move.getClass().getName());
   System.out.println("执行方法:"+move.move());

通过调用Proxy.newProxyInstance方法生成代理对象，具体参数有：

loader 目标类的类加载器
interfaces 目标类实现的接口
InvocationHandler 调用处理程序的实现对象

打印结果

代理对象:com.sun.proxy.$Proxy0
执行方法:汽车行驶中

值得一提的是，JDK动态代理针对每个代理对象都会有一个关联的调用处理程序，即实现InvocationHandler接口。当在代理对象上调用目标方法时，将对方法调用进行编码并将其分配给其实现 InvocationHandler 接口的 invoke 方法。

特点

JDK的动态代理只能代理实现了接口的类，没有实现接口的类不能实现动态代理。

2、cglib的动态代理

引用cglib的依赖包

<dependency>
   <groupId>cglib</groupId>
   <artifactId>cglib-nodep</artifactId>
   <version>2.2</version>
</dependency>

为了方便思考它的原理，我把执行步骤按顺序写下

public static void main(String[] args) 
       Enhancer enhancer = new Enhancer();
       //设置父类，被代理类（这里是Car.class）
       enhancer.setSuperclass(Car.class);
       //设置回调函数
       enhancer.setCallback(new MethodInterceptor() 
           @Override
           public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable 
               //增强处理...
               Object o= proxy.invokeSuper(obj, args);//代理类调用父类的方法
               //增强处理...
               return o;
           
       );
       //创建代理类并使用回调（用父类Car去引用）
       Car car = (Car) enhancer.create();
       //执行目标方法
       System.out.println(car.move());

方法拦截器

实现MethodInterceptor接口的intercept方法后，所有生成的代理方法都调用这个方法。

intercept方法的具体参数有：

obj 目标类的实例
method 目标方法实例（通过反射获取的目标方法实例）
args 目标方法的参数
proxy 代理类的实例

该方法的返回值就是目标方法的返回值。

特点

cglib的动态代理是针对类来实现代理。
对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用。
因为是通过继承实现，final类无法使用。

三、手写JDK动态代理源码

从上面可以看到JDK动态代理的核心代码在于Proxy.newProxyInstance方法。

Moveable m = (Moveable)Proxy.newProxyInstance(Car.class,new InvocationHandler());

实现原理

声明一段源码，源码动态产生动态代理
源码产生java文件，对java文件进行编译
得到编译生成后的class文件
把class文件load到内存之中，产生代理类对象返回即可。

下面附我手写的代码！

生产代理对象类，核心类！难点，思路都在这里~

public class Proxy 

   /**
    * 生产代理对象
    * @param clazz
    * @param h
    * @return
    * @throws Exception
    */
   public static Object newProxyInstance(Class clazz,InvocationHandler h) throws Exception
       //代理类类名
       String cname = clazz.getName().substring(clazz.getName().lastIndexOf(".")+1) + "$Proxy0";
       //手写代理类源码
       StringBuilder source = getSource(clazz, h, cname);
       //产生代理类的java文件
       String filename = Thread.currentThread().getContextClassLoader().getResource("").getPath()
               + clazz.getPackage().getName().replaceAll("\.", "/") +"/"+cname+".java";
       System.out.println(filename);
       //把源码写入到文件中
       File file = new File(filename);
       FileUtil.writeStringToFile(file, source.toString());
       //编译
       //拿到编译器
       JavaCompiler complier = ToolProvider.getSystemJavaCompiler();
       //文件管理者
       StandardJavaFileManager fileMgr =
               complier.getStandardFileManager(null, null, null);
       //获取文件
       Iterable units = fileMgr.getJavaFileObjects(filename);
       //编译任务
       CompilationTask t = complier.getTask(null, fileMgr, null, null, null, units);
       //进行编译
       t.call();
       fileMgr.close();
       //load 到内存
       ClassLoader cl = ClassLoader.getSystemClassLoader();
       Class<?> c = cl.loadClass(clazz.getPackage().getName() + "."+cname);
       //获取构造函数Constructor
       Constructor<?> ctr = c.getConstructor(h.getClass());
       return ctr.newInstance(h);
   

   /**
    * 手写代理类源码
    * @param clazz
    * @param h
    * @param cname
    * @return
    */
   private static StringBuilder getSource(Class clazz, InvocationHandler h, String cname) 
       //调用处理接口
       String handler = h.getClass().getName();
       //换行符号
       String line = "
";
       String space = " ";
       //代理类源码
       StringBuilder source = new StringBuilder();
       //包声明
       source.append("package" + space + clazz.getPackage().getName() + ";").append(line);
       //获取类的名称
       source.append(Modifier.toString(clazz.getModifiers()) + space + "class" + space + cname + space);
       //继承接口
       source.append("implements" + space);
       Class[] interfaces = clazz.getInterfaces();
       for (int i = 0; i < interfaces.length; i++) 
           source.append(interfaces[i].getName());
           if (i != interfaces.length - 1) 
               source.append(",");
           
       
       source.append("").append(line);
       //声明变量
       source.append("private " + handler + " h;").append(line);
       //构造方法
       source.append("public " + cname + "(" + handler + " h)").append(line);
       source.append("this.h=h;").append(line).append("").append(line);
       //实现所有方法
       Method[] methods = clazz.getDeclaredMethods();
       for (Method method : methods) 
           //获取方法返回类型
           Class returnType = method.getReturnType();
           //获取方法上的所有注释
           Annotation[] annotations = method.getDeclaredAnnotations();
           for (Annotation annotation : annotations) 
               //打印注释类型
               source.append("@" + annotation.annotationType().getName()).append(line);
           
           //打印方法声明
           source.append(Modifier.toString(method.getModifiers()) + " " + returnType.getName() + " " + method.getName() + "(");
           //获取方法的所有参数
           Parameter[] parameters = method.getParameters();
           //参数字符串
           StringBuilder args = new StringBuilder();
           for (int i = 0; i < parameters.length; i++) 
               //参数的类型，形参（全是arg123..）
               source.append(parameters[i].getType().getName() + " " + parameters[i].getName());
               args.append(parameters[i].getName());
               if (i != parameters.length - 1) 
                   source.append(",");
                   args.append(",");
               
           
           source.append(")").append(line);
           //方法逻辑
           source.append("Object obj=null; 
 try ").append(line);
           source.append("Class[] args = new Class[]" + args + ";").append(line);
           source.append(Method.class.getName()+" method = " + clazz.getName() + ".class.getMethod("" + method.getName() + "",args);").append(line);
           source.append("obj = h.invoke(this,method,args);").append(line);
           source.append(" catch (Exception e) 
" + "e.printStackTrace();
" + "catch (Throwable throwable) 
" +
                   "throwable.printStackTrace();
" + "").append(line);
           //方法结束
           source.append("return (obj!=null)?("+returnType.getName()+")obj:null;
").append(line);
       
       //类结束
       source.append("");
       return source;

单元测试

public static void main(String[] args) throws Exception 
       Moveable m = (Moveable) Proxy.newProxyInstance(Car.class, new TimeHandler(new Car()));
       String s = m.move();
       System.out.println(s);

测试结果

/D:/IDEA/workSpace/myJdkProxy/target/classes/cn/zyzpp/client/Car$Proxy0.java
开始记录时间
汽车行驶中….
耗时：481毫秒！
success

深入理解［master-worker模式］原理与技术(代码片段)

Master-Worker模式是常用的并行模式之一。它的核心思想是，系统由两类进程协作工作：Master进程和Worker进程。Master进程负责接收和分配任务，Worker进程负责处理子任务。当各个Worker进程将子任务处理完成后，将结果返回给Master进... 查看详情

深入理解设计模式-代理模式（静态代理动态代理jdk和cglib）(代码片段)

文章目录一、定义二、使用场景三、代码样例1.类图2.静态代理3.JDK动态代理4.Cglib动态代理四、优缺点五、拓展延伸1.jdk和cglib动态代理类反编译2.jdk和cglib动态代理区别结尾一、定义所谓代理模式是指客户端并不直接调用实际的对... 查看详情

06设计模式-代理模式(代码片段)

1.5.深入分析代理模式1.5.1.深度分析代理模式【上】时长：46min学习目标：　　》代理模式的应用场景及实现原理　　》区分静态代理与动态代理　　》cglib和jdkProxy实现动态代理的区别　　》手写实现定义的动态代理　　》springAo... 查看详情

深入理解wkwebview（基础篇）——wkwebview加载生命周期与代理方法剖析(代码片段)

...题的思考与探索。在本篇文章中，我们将在上一篇《深入理解WKWebView& 查看详情

深入理解java中23种设计模式(代码片段)

设计模式介绍设计模式(DesignPatterns):一套被反复使用,多数人知晓,经过分类编目,代码设计的总结使用设计模式是为了可重用代码,让代码更容易理解,保证代码可靠性项目中合理运用设计模式可以完美的解决很多问题,每种模式都有... 查看详情

深入理解aqs(代码片段)

文章目录深入理解AQSAQS概念特点AOS自定义实现锁ReentrantLock原理非公平锁实现原理加锁解锁原理竞争失败原理RenntrantLock可重入的原理可打断原理可打断模式公平锁实现原理非公平锁实现公平锁实现读写锁ReentrantReadWriteLock注意事项... 查看详情

06设计模式-代理模式(代码片段)

jdk动态代理深入理解分析并手写简易jdk动态代理（上）(代码片段)

...df6f20f/博客真的是好几个月没更了，2019新年第一篇，继续深入动态代理，前两篇简单分析了动态代理的实现原理之后，这次继续深入了解具体的实现方式，并手写一套简易的动态代理已加强理解；本博客关于Java动态代理相关内... 查看详情

《python爬虫技术：深入理解原理技术与开发》已经出版，欢迎关注

好消息，《Python爬虫技术：深入理解原理、技术与开发》已经出版！！！JetBrains官大中华区市场部经理赵磊作序！超过300个实战案例，10万行源代码，22个综合实战项目，海量学习资料！购买... 查看详情

深入浅出，对于代理模式的理解（代理模式与外观模式的区别）

从名字入手，理解为我们生活中的代理商角色即可。场景一：我饿了，去饭店点菜，我不需要关心菜是怎么做出来的，只要最后能吃到就好（外观模式）场景二：我是个外地人，连饭店都不知道... 查看详情

深入浅出，对于代理模式的理解（代理模式与外观模式的区别）

reactnative深入理解native与rn通信原理(代码片段)

在使用ReactNative开发应用程序的时候，有时候需要使用 JavaScript中默认不可用的IOS或Android的原生API。也许你想复用一些现有的OC、Swift、Java或C++库，而不必在JavaScript中重新实现它，或者为图像处理之类的... 查看详情

分布式搜索引擎elasticsearch---elasticsearch进阶使用深入理解搜索技术集群架构原理(代码片段)

ElasticSearchElasticSearchterm查询match查询Elasticsearch架构原理Master节点DataNode节点分片（Shard）副本指定分片、副本数量Elasticsearch重要工作流程Elasticsearch文档写入原理Elasticsearch检索原理Elasticsearch准实时索引实现手工控制搜索结... 查看详情

深入理解mybatis原理与技术

目录第1章Mybatis简介1.1传统的JDBC编程1.2ORM模型1.4MyBatis1.5什么时候用MyBatis第2章MyBatis入门2.2MyBatis构成2.3SqlSession的作用2.4映射器2.4.1使用XML配置方式2.4.2使用注解的方式2.4.3MyBatis映射原理2.5生命周期2.5.1SqlSessionFactoryBuilder2.5.2SqlSession... 查看详情

深入理解动态代理(代码片段)

...f0c;独钓寒江雪——唐·柳宗元《江雪》首发于我的公众号深入理解动态代理一、概述最近在阅读retrofit源码时,有个关键的所在就是动态代理，细细回想了一下动态代理,发现之前有些细节还没有理解到位，本篇博文将重新... 查看详情

深入理解python虚拟机：调试器实现原理与源码分析(代码片段)

...理，通过了解一个语言的调试器的实现原理我们可以更加深入的理解整个语言的运行机制，可以帮助我们更好的理解程序的执行。深入理解python虚拟机：调试器实现原理与源码分析调试器是一个编程语言非常重要的部分，调试器... 查看详情

深入理解volatile可见性原理与mesi缓存一致性协议(代码片段)

volatile作用——可见性大家都应该知道volatile的主要作用有两点：1、保证变量的内存可见性；2、禁止指令重排序，今天我们重点来谈谈可见性。首先，在理解volatile可见性前，先来看一看一个多线... 查看详情

动态代理的基本理解与基本使用(代码片段)

...中的代理又分为静态代理与动态代理。静态代理：简单地理解，就是有一个类文件来描述。动态代理：在内存中形成代理类。动态代理的实现步骤（1）代理对象和真实对象实现相同的接口。示例：//接口packagecom.chichung.proxy;p... 查看详情