devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

设计模式--代理模式

作者：我家小花儿 | 2024-02-25 02:58:42

赞

踩

设计模式--代理模式

代理模式（Proxy Pattern）是指为其他对象提供一种代理，以控制对这个对象的访问，属于结构型模式。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。代理模式分为静态代理和动态代理。

使用代理模式的主要目的是：保护目标对象；增强目标对象。

代理模式的通用写法

  1. interface ISubject{
  2.     void resquest();
  3. }
  4.  
  5. class RealSubject implements ISubject{
  6.  
  7.     @Override
  8.     public void resquest() {
  9.         System.out.println("real service is called.");
  10.     }
  11. }
  12.  
  13. class Proxy implements ISubject{
  14.     private ISubject subject;
  15.  
  16.     public Proxy(ISubject subject){
  17.         this.subject = subject;
  18.     }
  19.  
  20.     @Override
  21.     public void resquest() {
  22.         before();
  23.         subject.resquest();
  24.         after();
  25.     }
  26.  
  27.     public void before(){
  28.         System.out.println("called before request().");
  29.     }
  30.  
  31.     public void after(){
  32.         System.out.println("called after request().");
  33.     }
  34. }
  35.  
  36. public class Test {
  37.     public static void main(String[] args) {
  38.         Proxy proxy = new Proxy(new RealSubject());
  39.         proxy.resquest();
  40.     }
  41. }

由静态代理到动态代理

在Java生态中，目前最普遍使用的是JDK自带的代理和Cglib提供的类库。

首先，采用JDK的动态代理优化上述代码：

  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  3. import java.lang.reflect.Proxy;
  4.  
  5. interface ISubject{
  6.     void resquest();
  7. }
  8.  
  9.  
  10. class RealSubject implements ISubject{
  11.  
  12.     @Override
  13.     public void resquest() {
  14.         System.out.println("real service is called.");
  15.     }
  16. }
  17.  
  18. /**
  19.  * JDK动态代理
  20.  */
  21. class ProxyJDK implements InvocationHandler {
  22.     private ISubject subject;
  23.  
  24.     public ISubject getInstance(ISubject subject){
  25.         this.subject = subject;
  26.         Class<?> clazz = subject.getClass();
  27.         return (ISubject) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
  28.     }
  29.  
  30.  
  31.     public void before(){
  32.         System.out.println("called before request().");
  33.     }
  34.  
  35.     public void after(){
  36.         System.out.println("called after request().");
  37.     }
  38.  
  39.     @Override
  40.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  41.         before();
  42.         Object result = method.invoke(this.subject, args);
  43.         after();
  44.         return result;
  45.     }
  46. }
  47.  
  48. public class Test {
  49.     public static void main(String[] args) {
  50.         ISubject instance = new ProxyJDK().getInstance(new RealSubject());
  51.         instance.resquest();
  52.     }
  53. }

手动实现JDK动态代理：

JDK 动态代理采用字节码重组，重新生成对象来替代原始对象，以达到动态代理的目的。JDK 动态代理生成对象的步骤如下:（JDK代理通过反射调用）

  • 获取被代理对象的引用，并且获取它的所有接口，反射获取；
  • JDK 动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口；
  • 动态生成 Java 代码，新加的业务逻辑方法由一定的逻辑代码调用（在代码中体现）；
  • 编译新生成的 Java 代码.class 文件；
  • 重新加载到 JVM 中运行。
  1. /**
  2.  * 自己实现JDK动态代理
  3.  */
  4. interface GPInvocationHandler{
  5.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
  6. }
  7.  
  8. /**
  9.  * 用来生成源码的工具类
  10.  */
  11. class GPProxy{
  12.     public static final String ln = "\r\n";
  13.  
  14.     public static Object newProxyInstance(GPClassLoader classLoader, Class<?>[] interfaces, GPInvocationHandler h){
  15.         try{
  16.             //动态生成源代码.java文件
  17.             String src = generateSrc(interfaces);
  18.  
  19.             //2、Java文件输出磁盘
  20.             String filePath = URLDecoder.decode(GPProxy.class.getResource("").getPath(), "UTF-8");
  21.             System.out.println("GpProxy filePath: "+filePath);
  22.             File f = new File(filePath + "$Proxy0.java");
  23.             System.out.println("GpProxy File: "+f);
  24.             FileWriter fw = new FileWriter(f);
  25.             fw.write(src);
  26.             fw.flush();
  27.             fw.close();
  28.  
  29.             //3、把生成的.java文件编译成.class文件
  30.             JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  31.             StandardJavaFileManager manage = compiler.getStandardFileManager(null, null, null);
  32.             Iterable iterable = manage.getJavaFileObjects(f);
  33.  
  34.             JavaCompiler.CompilationTask task = compiler.getTask(null, manage, null, null, null, iterable);
  35.             task.call();
  36.             manage.close();
  37.  
  38.             //4、编译生成的.class文件加载到JVM中来
  39.             Class proxyClass = classLoader.findClass("$Proxy0", interfaces);
  40.             Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);
  41.             System.out.println("GpProxy Constructor: "+c );
  42.             f.delete();
  43.  
  44.             //5、返回字节码重组以后的新的代理对象
  45.             return c.newInstance(h);
  46.         }catch (Exception e){
  47.             e.printStackTrace();
  48.         }
  49.         return null;
  50.     }
  51.  
  52.     private static String generateSrc(Class<?>[] interfaces){
  53.         StringBuffer sb = new StringBuffer();
  54.         sb.append("import java.lang.reflect.*;" + ln);
  55.         sb.append("class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
  56.         sb.append("GPInvocationHandler h;" + ln);
  57.         sb.append("public $Proxy0(GPInvocationHandler h) { " + ln);
  58.         sb.append("this.h = h;");
  59.         sb.append("}" + ln);
  60.  
  61.         for (Method m : interfaces[0].getMethods()) {
  62.             Class<?>[] params = m.getParameterTypes();
  63.             StringBuffer paramNames = new StringBuffer();
  64.             StringBuffer paramValues = new StringBuffer();
  65.             StringBuffer paramClasses = new StringBuffer();
  66.  
  67.             for (int i = 0; i < params.length; i++) {
  68.                 Class clazz = params[i];
  69.                 String type = clazz.getName();
  70.                 String paramName = toLowerFirstCase(clazz.getSimpleName());
  71.                 paramNames.append(type + " " + paramName);
  72.                 paramValues.append(paramName);
  73.                 paramClasses.append(clazz.getName() + ".class");
  74.                 if (i > 0 && i < params.length - 1) {
  75.                     paramNames.append(",");
  76.                     paramValues.append(",");
  77.                     paramClasses.append(",");
  78.                 }
  79.  
  80.             }
  81.             System.out.println("paramNames: "+paramNames);
  82.             System.out.println("paramValues: "+paramValues);
  83.             System.out.println("paramClasses: "+paramClasses);
  84.  
  85.             sb.append("public " + m.getReturnType().getName() + " " + m.getName()
  86.                     + "(" + paramNames.toString() + ") {" + ln);
  87.             sb.append("try{" + ln);
  88.             sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\""
  89.                     + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
  90.             sb.append((hasReturnValue(m.getReturnType()) ? "return " : "")
  91.                     + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})", m.getReturnType())
  92.                     + ";" + ln);
  93.             sb.append("}catch(Error _ex) { }");
  94.             sb.append("catch(Throwable e){" + ln);
  95.             sb.append("throw new UndeclaredThrowableException(e);" + ln);
  96.             sb.append("}");
  97.             sb.append(getReturnEmptyCode(m.getReturnType()));
  98.             sb.append("}");
  99.         }
  100.         sb.append("}" + ln);
  101.         return sb.toString();
  102.     }
  103.  
  104.     private static Map<Class,Class> mappings = new HashMap<>();
  105.     static{
  106.         mappings.put(int.class,Integer.class);
  107.     }
  108.  
  109.     private static String getReturnEmptyCode(Class<?> returnClass) {
  110.         if (mappings.containsKey(returnClass)) {
  111.             return "return 0;";
  112.         } else if (returnClass == void.class) {
  113.             return "";
  114.         } else {
  115.             return "return null;";
  116.         }
  117.     }
  118.  
  119.     private static String getCaseCode(String code, Class<?> returnClass) {
  120.         if (mappings.containsKey(returnClass)) {
  121.             return "((" + mappings.get(returnClass).getName() + ")" + code + ")."
  122.                     + returnClass.getSimpleName() + "Values()";
  123.         }
  124.         System.out.println("code: "+code);
  125.         return code;
  126.     }
  127.  
  128.     private static boolean hasReturnValue(Class<?> clazz) {
  129.         return clazz != void.class;
  130.     }
  131.  
  132.     private static String toLowerFirstCase(String src) {
  133.         char[] chars = src.toCharArray();
  134.         chars[0] += 32;
  135.         return String.valueOf(chars);
  136.     }
  137.  
  138. }
  139.  
  140.  
  141. class GPClassLoader extends ClassLoader{
  142.     private File classPathFile;
  143.     public GPClassLoader(){
  144.         String classPath = GPClassLoader.class.getResource("").getPath();
  145.         this.classPathFile = new File(classPath);
  146.     }
  147.  
  148.     protected Class<?> findClass(String name, Class<?>[] interfaces)throws ClassNotFoundException {
  149.         String className;
  150.         if(StringUtils.isNotBlank(GPClassLoader.class.getPackage().getName())){
  151.             className = GPClassLoader.class.getPackage().getName() + "." + name;
  152.         }else{
  153.             className = name;
  154.         }
  155.         if(classPathFile != null){
  156.             File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
  157.             if(classFile.exists()){
  158.                 FileInputStream in = null;
  159.                 ByteArrayOutputStream out = null;
  160.                 try{
  161.                     in = new FileInputStream(classFile);
  162.                     out = new ByteArrayOutputStream();
  163.                     byte[] buff = new byte[1024];
  164.                     int len;
  165.                     while((len=in.read(buff)) != -1){
  166.                         out.write(buff,0,len);
  167.                     }
  168.                     return defineClass(className,out.toByteArray(),0,out.size());
  169.                 }catch (Exception e){
  170.                     e.printStackTrace();
  171.                 }finally {
  172.                     if(null != in){
  173.                         try {
  174.                             in.close();
  175.                         } catch (IOException e) {
  176.                             e.printStackTrace();
  177.                         }
  178.                     }
  179.  
  180.                     if(null != out){
  181.                         try {
  182.                             out.close();
  183.                         } catch (IOException e) {
  184.                             e.printStackTrace();
  185.                         }
  186.                     }
  187.                 }
  188.             }
  189.         }
  190.  
  191.         return null;
  192.     }
  193. }
  194.  
  195. /**
  196.  * JDK动态代理
  197.  */
  198. class ProxyJDK2 implements GPInvocationHandler {
  199.     private ISubject subject;
  200.  
  201.     public ISubject getInstance(ISubject subject){
  202.         this.subject = subject;
  203.         Class<?> clazz = subject.getClass();
  204.         return (ISubject) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
  205.     }
  206.  
  207.  
  208.     public void before(){
  209.         System.out.println("called before request().");
  210.     }
  211.  
  212.     public void after(){
  213.         System.out.println("called after request().");
  214.     }
  215.  
  216.     @Override
  217.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  218.         before();
  219.         Object result = method.invoke(this.subject, args);
  220.         after();
  221.         return result;
  222.     }
  223. }
  224.  
  225. public class Test {
  226.     public static void main(String[] args) {
  227. //        ISubject instance = new ProxyJDK().getInstance(new RealSubject());
  228. //        System.out.println(instance.getClass());
  229. //        instance.resquest();
  230.  
  231.         ISubject instance2 = new ProxyJDK2().getInstance(new RealSubject());
  232.         System.out.println(instance2.getClass());
  233.         instance2.resquest();
  234.     }
  235. }

注意：ISubject接口必须单独放一个文件里，不然会报错：class $Proxy0 cannot access its superinterface ISubject ($Proxy0 is in unnamed module of loader GPClassLoader @7d4793a8; ISubject is in unnamed module of loader 'app')，应该是保护域问题ProtectionDomain。反射机制的应用必须要求该类是public访问权限的。有朋友可能会说，可以调用setAccessible(true)方式来改变可见性，但这是一个概念混淆导致的错误。setAccessible(true)函数是反射机制用于改变类内属性访问权限的，而不是改变类本身的可见性。

CGLib动态代理

CGlib代理的目标对象不需要实现任何接口，它通过动态继承目标对象实现动态代理。

  1. /**
  2.  * CGLib创建动态代理
  3.  * 这是由于 JDK 8 中有关反射相关的功能自从 JDK 9 开始就已经被限制了，为了兼容原先的版本，需要在运行项目时添加 --add-opens java.base/java.lang=ALL-UNNAMED 选项来开启这种默认不被允许的行为。
  4.  */
  5.  
  6. class ProxyCGLib implements MethodInterceptor {
  7.     public Object getInstance(Class<?> clazz){
  8.         Enhancer enhancer = new Enhancer();
  9.         //要把设置为即将生成的新类的父类
  10.         enhancer.setSuperclass(clazz);
  11.         enhancer.setCallback(this);
  12.  
  13.         return enhancer.create();
  14.     }
  15.  
  16.     @Override
  17.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  18.         before();
  19.         Object obj = methodProxy.invokeSuper(o,objects);
  20.         after();
  21.         return obj;
  22.     }
  23.  
  24.     public void before(){
  25.         System.out.println("called before request().");
  26.     }
  27.  
  28.     public void after(){
  29.         System.out.println("called after request().");
  30.     }
  31. }
  32. public class Test {
  33.     public static void main(String[] args) {
  34.         ISubject instance = (ISubject) new ProxyCGLib().getInstance(RealSubject.class);
  35.         instance.resquest();
  36.     }
  37. }

CGLib和JDK动态代理对比

  • JDK动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象
  • JDK动态代理和CGLib代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLib代理使用ASM框架写Class字节码，CGLib代理实现更复杂，生成代理类比JDK动态代理效率低
  • JDK动态代理调用代理方法是通过反射机制调用的，CGLib代理是通过FastClass机制调用方法，CGLib效率更高。

代理模式的优缺点：

优点：

  • 代理模式能将代理对象与真实被调用目标对象分离
  • 在一定程度上降低了系统的耦合性，扩展性好
  • 可以起到保护目标对象的作用
  • 可以增强目标对象的功能

缺点：

  • 代理模式会造成系统设计中类的数量
  • 在客户端和目标对象中增加一个代理对象，会导致请求速度变慢
  • 增加了系统的复杂性。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/138064
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号