详解设计模式之代理模式

开发 前端
这次要跟大家分享的是设计模式中三大类创建型中的代理模式,代理模式在业务场景上我们可能不会经常用到,但是面试官却会经常问一个问题?

[[407965]]

设计模式已经跟大家分享很多了常见的模式了,感兴趣的小伙伴可以再回顾一下,巩固一下理解。

这次要跟大家分享的是设计模式中三大类创建型中的代理模式,代理模式在业务场景上我们可能不会经常用到,但是面试官却会经常问一个问题?

请你跟我讲讲Spring里面AOP的代理模式?jdk的代理模式和cglib的代理模式又啥区别?

清楚和不清楚的同学都可以接着向下看,一定会有收获。

言归正传,接下来开始一步一步分析一下代理模式。

定义以及目的

首先代理模式可以分为多种类型

  • 远程代理:就是将工作委托给远程对象(不同的服务器,或者不同的进程)来完成。常见的是用在web Service中。还有就是我们的RPC调用也可以理解为一种远程代理。
  • 保护代理:该模式主要进行安全/权限检查。(接触很少)
  • 缓存代理:这个很好理解,就是通过存储来加速调用,比如Sping中的@Cacheable方法,缓存特定的参数获取到的结果,当下次相同参数调用该方法,直接从缓存中返回数据。
  • 虚拟代理:这种代理主要是为方法增加功能,比如记录一些性能指标等,或进行延迟初始化

上面只是我们作为了解的概念,接下来再看看代理模式有哪些部分构成。

  • Subject(共同接口):客户端使用的现有接口
  • RealSubject(真实对象):真实对象的类
  • ProxySubject(代理对象):代理类

从图中可以看出其实整个接口还是很简单,就是一个真实对象以及代理对象。

  • 目的:提供一个实际代理对象,以便更好的控制实际对象。以上定义来自《设计模式之美》

代码举例实现

为了方便理解,还是举一个例子,不知道大家在读初中或者高中是否经历过传小纸条的过程,假如现在同学A 对同学C有一些话想聊(比如放学相约一起打游戏)但是因为现在是上课时间,又不能大声说,同学A和同学C之间坐了一个同学B,所以现在同学A只能是先找到同学B把纸条给它,让他转告同学C,但是去玩还是不是不去玩,那还是只能真正的同学C自己才能决定。

所以代理模式可以理解为 同学B是同学的C的代理,同学A要找同学C,只能找到同学B,通过同学B转达同学C,同时将同学的C的执行结果反馈给同学A。

说完了例子还是具体看看代码的实现吧

  1. public interface Subject { 
  2.    // 共同的接口 
  3.     void doSomething(); 

定义一个共同的接口(即大家要做的事请:放学一起打游戏)

  1. public class RealSubject implements Subject { 
  2.    // 真实对象 
  3.     @Override 
  4.     public void doSomething() { 
  5.         System.out.println("放学去打游戏"); 
  6.     } 

构建一个真实对象,即例子中的同学C

  1. public class ProxySubject implements Subject { 
  2.  
  3.     private RealSubject realSubject; 
  4.  
  5.     public ProxySubject(RealSubject realSubject) { 
  6.         this.realSubject = realSubject; 
  7.     } 
  8.  
  9.     public ProxySubject() throws ClassNotFoundException, IllegalAccessException, InstantiationException { 
  10.         this.realSubject = (RealSubject) this.getClass().getClassLoader().loadClass("com.ao.bing.demo.proxyPattern.RealSubject").newInstance(); 
  11.     } 
  12.  
  13.     @Override 
  14.     public void doSomething() { 
  15.         realSubject.doSomething(); 
  16.     } 
  17.  
  18.  
  19.     public static void main(String[] args) { 
  20.  
  21.         try { 
  22.             // 第一种方式 
  23.             new ProxySubject().doSomething(); 
  24.             // 打印结果: 放学去打游戏 
  25.         } catch (Exception e) { 
  26.             // 异常情况,代理失败, 
  27.             // 传纸条的被老师抓了。或者同学C不在座位上了 等异常情况 
  28.         } 
  29.  
  30.         // 第二种方式 
  31.         new ProxySubject(new RealSubject()).doSomething(); 
  32.         // 打印结果: 放学去打游戏 
  33.     } 

构建代理对象,即同学B,那么可以看到同学A并没有真实接触到同学C,通过同学B对同学C的代理就能知道同学C放学能不能跟他一起去打游戏

在Main方法里面,有两种方式来调用真实对象

  • 第一种:采用类加载器形式,去加载实列对象,这样我们就不同关心到底什么时候需要真实的实列化对象
  • 第二种:通过传值的形式,把实列化对象传过来。(理解为装饰器模式了)

这里大家要区别一下,代理模式是提供完全相同的接口,而装饰器模式是为了增强接口。

静态代理、动态代理和cglib代理分析

静态代理

在上面的举的列子实现其实就是静态代理,大家可以看到整体也比较简单。但是它的缺点也很明显

静态代理需要为每一个对象都创建一个代理类,增加了维护成本以及开发成本,那么为了解决这个问题,动态代理就出来了,不要再固定为每一个需要代理的类而创建一个代理类

动态代理

动态代理合理的避免了静态代理的那种方式,不用事先为要代理的类而构建好代理类。而是在运行时通过反射机制创建。

在写动态代理事需要理解两个东西:Proxy 可以理解为就是调度器,InvocationHandler 增强服务接口可以理解为代理器。所以我个人理解动态代理其实就是一种行为的监听。

具体的代码实现举一个例子:螳螂捕蝉,通过通过螳螂监听到蝉的动作。方便后面讲到多级代理模式。

  1. public interface BaseService { 
  2.     void mainService(); 
  3.  
  4. public class Cicada implements BaseService { 
  5.     @Override 
  6.     public void mainService() { 
  7.         System.out.println("主要业务,以蝉为例,当蝉出现业务调用时,螳螂监听到"); 
  8.     } 

创建共同接口,以及真实对象蝉

  1. public class PrayingMantis implements InvocationHandler { 
  2.  
  3.     private BaseService baseService; 
  4.  
  5.   // 这里采用的是构建传参数,可以用反射,举的第一个例子有样式代码 
  6.     public PrayingMantis(BaseService baseService) { 
  7.         this.baseService = baseService; 
  8.     } 
  9.  
  10.     // 螳螂主要业务,也就是监听对象 
  11.     @Override 
  12.     public Object invoke(Object listener, Method method, Object[] args) throws Throwable { 
  13.         method.invoke(baseService,args); 
  14.         secondaryMain(); 
  15.         return null
  16.     } 
  17.     // 这里理解增强业务,即我们可以在实现InvocationHandler里面添加其他的业务,比如日志等等。 
  18.     private void secondaryMain(){ 
  19.         System.out.println("螳螂捕蝉 - 次要业务"); 
  20.     } 

创建螳螂类,监听着蝉的类的动作

  1. public class BeanFactory { 
  2.  
  3.     public static BaseService newInstanc(Class classFile) { 
  4.         // 1. 创建蝉,真实类对象 
  5.         BaseService trueCicada = new Cicada(); 
  6.         // 2.创建代理类 螳螂 
  7.         InvocationHandler prayingMantis = new PrayingMantis(trueCicada); 
  8.         // 3.向Jvm索要代理对象 其实就是监听的对象, 
  9.         Class classArray[] = {BaseService.class}; 
  10.         BaseService baseService = (BaseService) Proxy.newProxyInstance(classFile.getClassLoader(), classArray, prayingMantis); 
  11.         return baseService; 
  12.     } 
  13.    
  14.    // 测试Demo 
  15.     public static void main(String[] args) { 
  16.         BaseService baseService  = newInstanc(Cicada.class); 
  17.         baseService.mainService(); 
  18.         // 测试结果 :主要业务 
  19.         //           螳螂捕蝉 - 次要业务 
  20.     } 

通过结果可以看出当蝉主要业务发生调用时,螳螂能监听到蝉的业务并且能处理其他业务逻辑,这也就是Spring里面AOP为什么能处理日志切面等。

代理的本质:

  • 我认为其实就是一种行为的监听,对代理对象($proxy InvocationHandler)的一种监听行为。

代理模式组成:

  • 接口:声明需要被监听行为
  • 代理实现类(InvocationHandler):次要业务,次要业务和主要业务绑定执行
  • 代理对象(监听对象)
  • Cglib动态代理

cglib动态代理

其实和jdk的动态代理是很相似的,都是要去实现代理器接口完成。

具体代码如下:

  1. public class PrayingMantis implements MethodInterceptor { 
  2.  
  3.     private Cicada cicada;// 代理对象 
  4.  
  5.     public Cicada getInstance(Cicada cicada) { 
  6.         this.cicada = cicada; 
  7.         Enhancer enhancer = new Enhancer(); 
  8.         enhancer.setSuperclass(this.cicada.getClass()); 
  9.         enhancer.setCallback(this); 
  10.         return (Cicada) enhancer.create(); 
  11.     } 
  12.  
  13.     @Override 
  14.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
  15.         Object object = methodProxy.invokeSuper(o, objects); 
  16.         secondaryMain(); 
  17.         return object; 
  18.     } 
  19.  
  20.     private void secondaryMain() { 
  21.         System.out.println("螳螂捕蝉 - 次要业务"); 
  22.     } 
  23.  
  24.     public static void main(String[] args) { 
  25.         PrayingMantis prayingMantis = new PrayingMantis(); 
  26.         Cicada instance = prayingMantis.getInstance(new Cicada()); 
  27.         instance.mainService(); 
  28.         // 结果:主要业务 
  29.         //      螳螂捕蝉 - 次要业务 
  30.     } 

因为蝉类都是一样的所以我就不单独这里再贴出来。

细心的同学已经发现,Cglib 无需通过接口来实现,它是通过实现子类的方式来完成调用的。

  • Enhancer 对象把代理对象设置为被代理类的子类来实现动态代理的。因为是采用继承方式,所以代理类不能加final修饰,否则会报错。
  • final类:类不能被继承,内部的方法和变量都变成final类型

JDK和Cglib的区别:

  • jdk动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理
  • cglib动态代理是利用ASM开源包,对被代理对象类的class文件加载进来,通过修改其字节码生成子类来处理
  • ASM: 一个 Java 字节码操控框架。它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件,也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .class 文件里,这些类文件拥有足够的元数据来解析类中的所有元素:类名称、方法、属性以及 Java 字节码(指令)。ASM 从类文件中读入信息后,能够改变类行为,分析类信息,甚至能够根据用户要求生成新类。 -- 以上ASM解释来自简书

多级动态代理

看完上面的动态代理,不知道大家有没有想法,实现一个多级动态代理。

还是以螳螂捕蝉为例子,再加上一个黄雀在后,实现多级动态代理模式。

  1. public class Cardinal implements InvocationHandler { 
  2.   // 监听代理代理对象 
  3.     private Object proxyOne; 
  4.  
  5.     public Cardinal(Object proxyOne) { 
  6.         this.proxyOne = proxyOne; 
  7.     } 
  8.  
  9.     // 螳螂主要业务,也就是监听对象 
  10.     @Override 
  11.     public Object invoke(Object proxy, Method method, Object[] args) throws            Throwable { 
  12.         method.invoke(proxyOne, args); 
  13.         secondaryMain(); 
  14.         return null
  15.     } 
  16.     private void secondaryMain() { 
  17.         System.out.println("黄雀吃螳螂 - 次要业务"); 
  18.     } 

创建一个黄雀代理对象,那作为他的真实对象就变成螳螂了,当螳螂对象发生调用时,黄雀就能坚挺到,同时作出对应业务逻辑

  1. public class BeanFactory { 
  2.  
  3.     public static BaseService newInstanc(Class classFile) { 
  4.         // 1. 创建蝉,真实类对象 
  5.         BaseService trueCicada = new Cicada(); 
  6.  
  7.         // 2.创建代理类 螳螂 
  8.         InvocationHandler prayingMantis = new PrayingMantis(trueCicada); 
  9.  
  10.         // 3.向Jvm索要代理对象 其实就是坚挺的对象 
  11.         Class classArray[] = {BaseService.class}; 
  12.         BaseService baseService = (BaseService) Proxy.newProxyInstance(classFile.getClassLoader(), classArray, prayingMantis); 
  13.  
  14.         // 4.创建代理实现类 黄雀 二级代理 
  15.         InvocationHandler cardinal = new Cardinal(baseService); 
  16.         BaseService secondBaseService = (BaseService) Proxy.newProxyInstance(classFile.getClassLoader(), classArray, cardinal); 
  17.          
  18.        // 假设要实现三级,四级代理,则在黄雀类上再加一层代理即可实现。 
  19.        // 省略其他的更多级代理对象 
  20.         return secondBaseService; 
  21.     } 
  22.    
  23.      // 测试demo 
  24.       public static void main(String[] args) { 
  25.         BaseService baseService  = BeanFactory.newInstanc(Cicada.class); 
  26.         baseService.mainService(); 
  27.         // 结果:主要业务 
  28.         //      螳螂捕蝉 - 次要业务 
  29.         //      黄雀吃螳螂 - 次要业务 
  30.     } 

根据这个代码基本就实现多级代理过程。螳螂监听着蝉类的动作,黄雀监听着螳螂类的动作。

同样的如果要实现三级代理,四级代理也就不是什么难事了,在每一层的上面再加一个代理对象就可以了。

  • 动态代理本质还是可以理解为将“次要业务”与“主要业务”解耦合,让开发者能更加专注于主要业务,提升开发效率,以及维护成本。

总结

代理模式在业务代码上我个人认为是比较少见的,特别是动态代理基本上是没有见过。但是代理模式也是我们必须要理解的一种模式,因为学习好代理模式有助于我们去读一些源码,排查一些更深层次的问题,或者面对一些业务场景问题,也能有一个很大的提升,设计模式本身也就是为了解决问题而创建出来的。

理解完动态代理现在对我们来说AOP的实现原理也就不言而喻了。

详细的设计模式到这里就结束了,后面针对一些不常见设计模式我还是会给大家做一个总结吧。

我是敖丙,你知道的越多,你不知道的越多,我们下期见!!!

 

责任编辑:姜华 来源: 三太子敖丙
相关推荐

2012-01-13 15:59:07

2012-02-29 09:41:14

JavaScript

2010-03-25 08:52:30

PHP设计模式代理模式

2022-09-07 08:25:08

代理模式设计模式代码

2011-04-06 11:41:25

Java动态代理

2024-04-16 00:07:36

设计模式代理模式替身

2020-08-21 07:23:50

工厂模式设计

2022-11-30 17:05:33

代码程序场景

2024-02-26 11:52:38

代理模式设计

2021-06-16 08:56:06

模版方法模式设计模式行为型设计模式

2021-12-24 07:50:45

责任链模式设计

2015-09-08 13:39:10

JavaScript设计模式

2023-09-04 13:14:00

装饰器设计模式

2021-06-09 08:53:34

设计模式策略模式工厂模式

2021-06-22 15:27:13

设计模式迭代器模式Java

2021-09-16 06:44:05

组合模式设计

2023-12-13 13:28:16

装饰器模式Python设计模式

2010-04-13 08:54:28

PHP设计模式命令模式

2022-03-25 11:01:28

Golang装饰模式Go 语言

2021-12-01 07:38:27

设计模式规格模式Specificati
点赞
收藏

51CTO技术栈公众号