Java代理模式

例

小张是一个普普统统的码农，天天勤勤恳恳地码代码。某天中午小张刚要去吃饭，一个电话打到了他的手机上。“是XX公司的小张吗？我是YY公司的王AA”。“哦，是王总啊，有什么事情吗？”。沟经过后，小张弄明白了,原来客户有个需求，恰好负责这方面开发的是小张，客户就直接找到了他。不太小张却没有答应客户的请求，而是让客户找产品经理小李沟通。

是小张着急去吃面而甩锅吗？并非，只是为了使故事能够套到代理模式上。咱们先看一下代理模式的定义： * 为其余对象提供一种代理，以控制对这个对象的访问。(Provide a surrogate or placeholder for another object to control access to it)

对照定义，码农小张能够映射为其余对象，产品经理小李为小张的代理。咱们经过JAVA代码，表述上面事例。

静态代理

1.抽象角色

基于面向对象的思想，首先定义一个码农接口,它有一个实现用户需求的方法。

1 2 3 4 5

//定义一个码农接口,他能够实现用户需求 public interface ICoder {     public void imlDemands(String demandName); }

2.真实角色

咱们假设小牛是JAVA程序员，定义一个JAVA码农类，他经过JAA语言实现需求。

1 2 3 4 5 6 7 8 9 10 11 12 13

public class JavaCoder implements ICoder{     private String name;        public JavaCoder(String name) {         super();         this.name = name;     }     @Override     public void imlDemands(String demandName) {         // TODO Auto-generated method stub         System.out.println(name+"实现了方法："+demandName+"in java");     }    }

3.代理角色

委屈一下产品经理，将其命名为码农代理类，同时让他实现ICoder接口。

1 2 3 4 5 6 7 8 9 10 11 12 13

public class CoderProxy implements ICoder{     private ICoder coder;     public CoderProxy(ICoder coder){         this.coder = coder;     }     @Override     public void implDemands(String demandName) {         coder.implDemands(demandName);     } }

上面一个接口，两个类，就实现了代理模式。Are you kidding me？这么简单？是的，就是这么简单。 咱们经过一个场景类，模拟用户找产品经理增长需求。

1 2 3 4 5 6 7 8 9 10 11

public class Customer {     public static void main(String args[]){         //定义一个java码农         ICoder coder = new JavaCoder("Niu");         //定义一个产品经理         ICoder proxy = new CoderProxy(coder);         //让产品经理实现一个需求         proxy.implDemands("Add user manageMent");     } }

运行程序，结果以下：

1	Niu implemented demand:Add user manageMent in JAVA!

产品经理充当了程序员的代理，客户把需求告诉产品经理，并不须要和程序员接触。看到这里，有些机智的程序员发现了问题。你看，产品经理就把客户的需求转达了一下，怪不得我看产品经理这么不爽。

产品经理固然不仅是转达用户需求，他还有不少事情能够作。好比，该项目决定不接受新增功能的需求了，对修CoderProxy类作一些修改：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class CoderProxy implements ICoder{     private ICoder coder;     public CoderProxy(ICoder coder){         this.coder = coder;     }     @Override     public void implDemands(String demandName) {         if(demandName.startsWith("Add")){             System.out.println("No longer receive 'Add' demand");             return;         }         coder.implDemands(demandName);     } }

这样，当客户再有增长功能的需求时，产品经理就直接回绝了，程序员无需再对这部分需求作过滤。

总结

咱们对上面的事例作一个简单的抽象：

代理模式包含以下角色：

• Subject:抽象主题角色。能够是接口，也能够是抽象类。
• RealSubject:真实主题角色。业务逻辑的具体执行者。
• ProxySubject:代理主题角色。内部含有RealSubject的引用,负责对真实角色的调用，并在真实主题角色处理先后作预处理和蔼后工做。

代理模式优势：

• 职责清晰 真实角色只需关注业务逻辑的实现，非业务逻辑部分，后期经过代理类完成便可。
• 高扩展性 无论真实角色如何变化，因为接口是固定的，代理类无需作任何改动。

动态代理

前面讲的主要是静态代理。那么什么是动态代理呢？

假设有这么一个需求，在方法执行前和执行完成后，打印系统时间。这很简单嘛，非业务逻辑，只要在代理类调用真实角色的方法前、后输出时间就能够了。像上例，只有一个implDemands方法，这样实现没有问题。但若是真实角色有10个方法，那么咱们要写10遍彻底相同的代码。有点追求的码农，确定会对这种方法感到很是不爽。有些机智的小伙伴可能想到了用AOP解决这个问题。很是正确。莫非AOP和动态代理有什么关系？没错！AOP用的偏偏是动态代理。

代理类在程序运行时建立的代理方式被称为动态代理。也就是说，代理类并不须要在Java代码中定义，而是在运行时动态生成的。相比于静态代理， 动态代理的优点在于能够很方便的对代理类的函数进行统一的处理，而不用修改每一个代理类的函数。对于上例打印时间的需求，经过使用动态代理，咱们能够作一个“统一指示”，对全部代理类的方法进行统一处理，而不用逐一修改每一个方法。下面咱们来具体介绍下如何使用动态代理方式实现咱们的需求。

与静态代理相比，抽象角色、真实角色都没有变化。变化的只有代理类。所以，抽象角色、真实角色，参考ICoder和JavaCodr。

在使用动态代理时，咱们须要定义一个位于代理类与委托类之间的中介类，也叫动态代理类，这个类被要求实现InvocationHandler接口：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class CoderDynamicProxy implements InvocationHandler{      //被代理的实例     private ICoder coder;     public CoderDynamicProxy(ICoder _coder){         this.coder = _coder;     }     //调用被代理的方法     @Override     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {         System.out.println(System.currentTimeMillis());         Object result = method.invoke(coder, args);         System.out.println(System.currentTimeMillis());         return result;     } }

当咱们调用代理类对象的方法时，这个“调用”会转送到中介类的invoke方法中，参数method标识了咱们具体调用的是代理类的哪一个方法，args为这个方法的参数。

咱们经过一个场景类，模拟用户找产品经理更改需求。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class DynamicClient {      public static void main(String args[]){             //要代理的真实对象             ICoder coder = new JavaCoder("Zhang");             //建立中介类实例             InvocationHandler  handler = new CoderDynamicProxy(coder);             //获取类加载器             ClassLoader cl = coder.getClass().getClassLoader();             //动态产生一个代理类   ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);             //经过代理类，执行doSomething方法；             proxy.implDemands("Modify user management");         } }

执行结果以下：

1 2 3

1521810491379 Niu implemented demand:Modify user management in JAVA! 1521810491380

经过上述代码，就实现了，在执行委托类的全部方法前、后打印时间。仍是那个熟悉的小牛，但咱们并无建立代理类，也没有时间ICoder接口。这就是动态代理。

总结

总结一下，一个典型的动态代理可分为如下四个步骤：

1. 建立抽象角色
2. 建立真实角色
3. 经过实现InvocationHandler接口建立中介类
4. 经过场景类，动态生成代理类

若是只是想用动态代理，看到这里就够了。但若是想知道为何经过proxy对象，就可以执行中介类的invoke方法，以及生成的proxy对象是什么样的，能够继续往下看。

源码分析(JDK7)

看到这里的小伙伴，都是有追求的程序员。上面的场景类中，经过

1 2	//动态产生一个代理类 ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);

动态产生了一个代理类。那么这个代理类是如何产生的呢？咱们经过代码一窥究竟。

Proxy类的newProxyInstance方法，主要业务逻辑以下：

1 2 3 4 5 6

//生成代理类class，并加载到jvm中 Class<?> cl = getProxyClass0(loader, interfaces); //获取代理类参数为InvocationHandler的构造函数 final Constructor<?> cons = cl.getConstructor(constructorParams); //生成代理类，并返回 return newInstance(cons, ih);

上面代码作了三件事：

• 根据传入的参数interfaces动态生成一个类，它实现interfaces中的接口，该例中即ICoder接口的implDemands方法。假设动态生成的类为$Proxy0。
• 经过传入的classloder,将刚生成的$Proxy0类加载到jvm中。
• 利用中介类，调用$Proxy0的$Proxy0(InvocationHandler)构造函数，建立$Proxy0类的实例，其InvocationHandler属性，为咱们建立的中介类。

上面的核心，就在于getProxyClass0方法：

1 2 3 4 5 6 7 8 9 10 11

private static Class<?> getProxyClass0(ClassLoader loader,                                            Class<?>... interfaces) {         if (interfaces.length > 65535) {             throw new IllegalArgumentException("interface limit exceeded");         }         // If the proxy class defined by the given loader implementing         // the given interfaces exists, this will simply return the cached copy;         // otherwise, it will create the proxy class via the ProxyClassFactory         return proxyClassCache.get(loader, interfaces);     }

在Proxy类中有个属性proxyClassCache，这是一个WeakCache类型的静态变量。它指示了类加载器和代理类之间的映射。因此proxyClassCache的get方法用于根据类加载器来获取Proxy类，若是已经存在则直接从cache中返回，若是没有则建立一个映射并更新cache表。

咱们跟一下代理类的建立流程：
调用Factory类的get方法，而它又调用了ProxyClassFactory类的apply方法，最终找到下面一行代码：

1 2	//Generate the specified proxy class. byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);

就是它，生成了代理类。

查看动态生成的代理类

经过上面的分析，咱们已经知道Proxy类动态建立代理类的流程。那建立出来的代理类究竟是什么样子的呢？咱们能够经过下面的代码，手动生成：

1 2 3 4 5 6 7 8 9 10 11

public class CodeUtil {        public static void main(String[] args) throws IOException {          byte[] classFile = ProxyGenerator.generateProxyClass("TestProxyGen", JavaCoder.class.getInterfaces());             File file = new File("D:/aaa/TestProxyGen.class");             FileOutputStream fos = new FileOutputStream(file);             fos.write(classFile);             fos.flush();             fos.close();           }  }

经过反编译工具查看生成的class文件:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; import model.proxy.ICoder; public final class TestProxyGen extends Proxy   implements ICoder {   private static Method m1;   private static Method m0;   private static Method m3;   private static Method m2;   public TestProxyGen(InvocationHandler paramInvocationHandler)     throws   {     super(paramInvocationHandler);   }   public final boolean equals(Object paramObject)     throws   {     try     {       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();     }     catch (RuntimeException localRuntimeException)     {       throw localRuntimeException;     }     catch (Throwable localThrowable)     {     }     throw new UndeclaredThrowableException(localThrowable);   }   public final int hashCode()     throws   {     try     {       return ((Integer)this.h.invoke(this, m0, null)).intValue();     }     catch (RuntimeException localRuntimeException)     {       throw localRuntimeException;     }     catch (Throwable localThrowable)     {     }     throw new UndeclaredThrowableException(localThrowable);   }   public final void implDemands(String paramString)     throws   {     try     {       this.h.invoke(this, m3, new Object[] { paramString });       return;     }     catch (RuntimeException localRuntimeException)     {       throw localRuntimeException;     }     catch (Throwable localThrowable)     {     }     throw new UndeclaredThrowableException(localThrowable);   }   public final String toString()     throws   {     try     {       return (String)this.h.invoke(this, m2, null);     }     catch (RuntimeException localRuntimeException)     {       throw localRuntimeException;     }     catch (Throwable localThrowable)     {     }     throw new UndeclaredThrowableException(localThrowable);   }   static   {     try     {       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);       m3 = Class.forName("model.proxy.ICoder").getMethod("implDemands", new Class[] { Class.forName("java.lang.String") });       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);       return;     }     catch (NoSuchMethodException localNoSuchMethodException)     {       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());     }     catch (ClassNotFoundException localClassNotFoundException)     {     }     throw new NoClassDefFoundError(localClassNotFoundException.getMessage());   } }

这样，咱们就理解，为何调用代理类的implDemands方法，回去执行中介类的invoke方法了。