[关闭]
@pastqing 2016-04-25T12:22:41.000000Z 字数 13918 阅读 5532

java设计模式——代理模式

java 设计模式

一、代理模式定义

Wiki上是这样描述代理模式的：所谓代理者是指一个类可以作为其他东西的接口。代理者可以作任何东西的接口, 例如网络连接， 存储器中的大对象，文件或者其他无法复制的资源。

著名的代理模式的例子就是引用计数(reference counting): 当需要一个复杂对象的多份副本时， 代理模式可以结合享元模式以减少存储器的用量。典型做法是创建一个复杂对象以及多个代理者， 每个代理者会引用到原本的对象。而作用在代理者的运算会转送到原本对象。一旦所有的代理者都不存在时， 复杂对象会被移除。

二、静态代理

所谓静态代理， 就是在编译阶段就生成代理类来完成对代理对象的一系列操作。下面是代理模式的结构类图：

1、代理模式的参与者

代理模式的角色分四种：

2、代理模式的实现思路

3、静态代理的实例

下面以一个延迟加载的例子来说明一下静态代理。我们在启动某个服务系统时， 加载某一个类时可能会耗费很长时间。为了获取更好的性能， 在启动系统的时候， 我们往往不去初始化这个复杂的类， 取而代之的是去初始化其代理类。这样将耗费资源多的方法使用代理进行分离， 可以加快系统的启动速度， 减少用户等待的时间。

  1. public interface Subject {
  2.     public void sayHello();
  3.     public void sayGoodBye();
  4. }
  1. public class RealSubject implements Subject {
  2.     public void sayHello() {
  3.         System.out.println("Hello World");
  4.     }
  5.     public void sayGoodBye() {
  6.         System.out.println("GoodBye World");
  7.     }
  8. }
  1. public class StaticProxy implements Subject {
  2.     Private RealSubject realSubject = null;
  3.     public StaticProxy() {}
  4.     public void sayHello() {
  5.         //用到时候才加载， 懒加载
  6.         if(realSubject == null) {
  7.             realSubject = new RealSubject();
  8.         }
  9.         realSubject.sayHello();
  10.     }
  11.     //sayGoodbye方法同理
  12.     ...
  13. }
  1. public class Client {
  2.     public static void main(String [] args) {
  3.         StaticProxy sp = new StaticProxy();
  4.         sp.sayHello();
  5.         sp.sayGoodBye();
  6.     }
  7. }

以上就是静态代理的一个简单测试例子。感觉可能没有实际用途。然而并非如此。使用代理我们还可以将目标对象的方法进行改造， 比如数据库连接池中创建了一系列连接， 为了保证不频繁的打开连接，这些连接是几乎不会关闭的。然而我们编程总有习惯去将打开的Connection去close。 这样我们就可以利用代理模式来重新代理Connection接口中的close方法， 改变为回收到数据库连接池中而不是真正的执行Connection#close方法。其他的例子还有很多， 具体需要自己体会。

三、动态代理

动态代理是指在运行时动态生成代理类。即，代理类的字节码将在运行时生成并载入当前代理的 ClassLoader。与静态处理类相比，动态类有诸多好处。

生成动态代理的方法有很多： JDK中自带动态代理， CGlib, javassist等。这些方法各有优缺点。本文主要探究JDK中的动态代理的使用和源码分析。

下面用一个实例讲解一下JDK中动态代理的用法：

  1. public class dynamicProxy implements InvocationHandler {
  2.     private RealSubject = null;
  3.     public Object invoke(Object proxy, Method method, Object[] args){
  4.         if(RealSubject == null) {
  5.             RealSubject = new RealSubject();
  6.         }
  7.         method.invoke(RealSubject, args);
  8.         return RealSubject;
  9.     }
  10. }

客户端代码实例

  1. public class Client {
  2.     public static void main(Strings[] args) {
  3.         Subject subject = (Subject)Proxy.newInstance(ClassLoader.getSystemLoader(), RealSubject.class.getInterfaces(), new DynamicProxy());
  4.         Subject.sayHello();
  5.         Subject.sayGoodBye();
  6.     }
  7. }

从上面的代码可以看出， 要利用JDK中的动态代理。利用静态方法Proxy.newInstance(ClassLoader, Interfaces[], InvokeHandler)可以创建一个动态代理类。 newInstance方法有三个参数， 分别表示类加载器， 一个希望该代理类实现的接口列表， 以及实现InvokeHandler接口的实例。 动态代理将每个方法的执行过程则交给了Invoke方法处理。

JDK动态代理要求， 被代理的必须是个接口， 单纯的类则不行。JDK动态代理所生成的代理类都会继承Proxy类，同时代理类会实现所有你传入的接口列表。因此可以强制类型转换成接口类型。 下面是Proxy的结构图。
class proxy.png-157.1kB
可以看出Proxy全是静态方法， 因此如果代理类没有实现任何接口， 那么他就是Proxy类型， 没有实例方法。

当然加入你要是非要代理一个没有实现某个接口的类， 同时该类的方法与其他接口定义的方法相同， 利用反射也是可以轻松实现的。

  1. public class DynamicProxy implements InvokeHandler {
  2.     //你想代理的类
  3.     private TargetClass targetClass = null;
  4.     //初始化该类
  5.     public DynamicProxy(TargetClass targetClass) {
  6.         this.targetClass = targetClass;
  7.     }
  8.     public Object invoke(Object proxy, Method method, Object[] args) {
  9.         //利用反射获取你想代理的类的方法
  10.         Method myMethod = targetClass.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());
  11.         myMethod.setAccessible(true);
  12.         return myMethod.invoke(targetClass, args);
  13.     }
  14. }

四、JDK动态代理源码分析（JDK7）

看了上面的例子， 我们只是简单会用动态代理。但是对于代理类是如何创建出来的， 是谁调用Invoke方法等还云里雾里。下面通过分析

1、代理对象是如何创建出来的？

首先看Proxy.newInstance方法的源码：

  1. public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
  2.     }
  3.     //获取接口信息
  4.     final Class<?>[] intfs = interfaces.clone();
  5.     final SecurityManager sm = System.getSecurityManager();
  6.     if (sm != null) {
  7.         checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  8.     }
  9.     //生成代理类
  10.     Class<?> cl = getProxyClass0(loader, intfs);
  12.     // ...OK我们先看前半截
  14.     }

从源码看出代理类的生成是依靠getProxyClass0这个方法， 接下来看getProxyClass0源码：

  1. private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
  2.     //接口列表数目不能超过0xFFFF
  3.     if (interfaces.length > 65535) {
  4.         throw new IllegalArgumentException("interface limit exceeded");
  5.     }
  6.     //注意这里, 下面详细解释  
  7.         return proxyClassCache.get(loader, interfaces);
  8.     }

对proxyClassCache.get的解释是： 如果实现接口列表的代理类已经存在，那么直接从cache中拿。如果不存在， 则通过ProxyClassFactory生成一个。
在看proxyClassCache.get源码之前，先简单了解一下proxyClassCache：

  1.  private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
  2.         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

proxyClassCache是一个WeakCache类型的缓存， 它的构造函数有两个参数， 其中一个就是用于生成代理类的ProxyClassFactory， 下面是proxyClassCache.get的源码：

  1. final class WeakCache<K, P, V> {
  2.     ...
  3.     public V get(K key, P parameter) {}
  4. }

这里K表示key， P表示parameters, V表示value

  1. public V get(K key, P parameter) {
  2.     //java7 NullObject判断方法， 如果parameter为空则抛出带有指定消息的异常。 如果不为空则返回。
  3.     Objects.requireNonNull(parameter);
  5.     //清理持有弱引用的WeakHashMap这种数据结构，一般用于缓存
  6.     expungeStaleEntries();
  8.     //从队列中获取cacheKey
  9.     Object cacheKey = CacheKey.valueOf(key, refQueue);
  11.     //利用懒加载的方式填充Supplier， Concurrent是一种线程安全的map
  12.     ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
  13.     if (valuesMap == null) {
  14.         ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
  15.             if (oldValuesMap != null) {
  16.                 valuesMap = oldValuesMap;
  17.             }
  18.         }
  20.         // create subKey and retrieve the possible Supplier<V> stored by that
  21.         // subKey from valuesMap
  22.     Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
  23.     Supplier<V> supplier = valuesMap.get(subKey);
  24.     Factory factory = null;
  26.     while (true) {
  27.         if (supplier != null) {
  28.         // 从supplier中获取Value，这个Value可能是一个工厂或者Cache的实
  29.         //下面这三句代码是核心代码， 返回实现InvokeHandler的类并包含了所需要的信息。
  30.         V value = supplier.get();
  31.             if (value != null) {
  32.                 return value;
  33.             }
  34.         }
  35.         // else no supplier in cache
  36.         // or a supplier that returned null (could be a cleared CacheValue
  37.         // or a Factory that wasn't successful in installing the CacheValue)
  38.         //下面这个过程就是填充supplier的过程
  39.         if(factory == null) {
  40.             //创建一个factory
  41.         }
  42.         if(supplier == null) {
  43.             //填充supplier
  44.         }else {
  45.             //填充supplier
  46.         }
  48.     }

while循环的作用就是不停的获取实现InvokeHandler的类， 这个类可以是从缓存中拿到，也可是是从proxyFactoryClass生成的。
Factory是一个实现了Supplier<V>接口的内部类。这个类覆盖了get方法， 在get方法中调用了类型为proxyFactoryClass的实例方法apply。这个方法才是真正创建代理类的方法。下面看ProxyFactoryClass#apply方法的源码：

  1. public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
  2.     Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
  3.     for (Class<?> intf : interfaces) {
  5.         /*  Verify that the class loader resolves the name of this interface to the same Class object.*/
  6.     Class<?> interfaceClass = null;
  7.         try {
  8.             //加载每一个接口运行时的信息
  9.             interfaceClass = Class.forName(intf.getName(), false, loader);
  10.         } catch (ClassNotFoundException e) {
  12.         }
  14.     //如果使用你自己的classload加载的class与你传入的class不相等，抛出异常
  15.     if (interfaceClass != intf) {
  16.         throw new IllegalArgumentException(
  17.         intf + " is not visible from class loader");
  18.     }
  20.     //如果传入不是一个接口类型
  21.         if (!interfaceClass.isInterface()) {
  22.             throw new IllegalArgumentException(
  23.                 interfaceClass.getName() + " is not an interface");
  24.         }
  26.      //验证接口是否重复
  27.         if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
  28.             throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());
  29.         }
  30.     }
  32.     String proxyPkg = null;     // package to define proxy class in
  34.     /*  Record the package of a non-public proxy interface so that the proxy class will be defined in the same package.  
  35.     * Verify that all non-public proxy interfaces are in the same package.
  36.     */
  37.     //这一段是看你传入的接口中有没有不是public的接口，如果有，这些接口必须全部在一个包里定义的，否则抛异常 
  38.     for (Class<?> intf : interfaces) {
  39.         int flags = intf.getModifiers();
  40.         if (!Modifier.isPublic(flags)) {
  41.             String name = intf.getName();
  42.             int n = name.lastIndexOf('.');
  43.             String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
  44.             if (proxyPkg == null) {
  45.                 proxyPkg = pkg;
  46.             } else if (!pkg.equals(proxyPkg)) {
  47.                 throw new IllegalArgumentException(
  48.                     "non-public interfaces from different packages");
  49.             }
  50.         }
  51.     }
  52.     if (proxyPkg == null) {
  53.         // if no non-public proxy interfaces, use com.sun.proxy package
  54.         proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
  55.     }
  57.     /*
  58.     * Choose a name for the proxy class to generate.
  59.     */
  60.     long num = nextUniqueNumber.getAndIncrement();
  61.     //生成随机代理类的类名， $Proxy + num
  62.     String proxyName = proxyPkg + proxyClassNamePrefix + num;
  64.     /*
  65.     * 生成代理类的class文件， 返回字节流
  66.     */
  67.     byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
  68.     try {
  69.         return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
  70.     } catch (ClassFormatError e) {
  71.                 //结束
  72.                 throw new IllegalArgumentException(e.toString());
  73.             }
  74.         }
  75.     }

前文提到ProxyFactoryClass#apply是真正生成代理类的方法， 这其实是不准确的。源代码读到这里，我们会发现ProxyGenerator#generateProxyClass才是真正生成代理类的方法。根据Java class字节码组成（可以参见我的另一篇文章Java字节码学习笔记）来生成相应的Clss文件。具体ProxyGenerator#generateProxyClass源码如下:

  1.     private byte[] generateClassFile() {
  2.         /*
  3.          * Step 1: Assemble ProxyMethod objects for all methods to
  4.          * generate proxy dispatching code for.
  5.          */
  7.          //addProxyMethod方法，就是将方法都加入到一个列表中，并与对应的class对应起来  
  8.         //这里给Object对应了三个方法hashCode，toString和equals  
  10.         addProxyMethod(hashCodeMethod, Object.class);
  11.         addProxyMethod(equalsMethod, Object.class);
  12.         addProxyMethod(toStringMethod, Object.class);
  14.         //将接口列表中的接口与接口下的方法对应起来
  15.         for (int i = 0; i < interfaces.length; i++) {
  16.             Method[] methods = interfaces[i].getMethods();
  17.             for (int j = 0; j < methods.length; j++) {
  18.                 addProxyMethod(methods[j], interfaces[i]);
  19.             }
  20.         }
  22.         /*
  23.          * For each set of proxy methods with the same signature,
  24.          * verify that the methods' return types are compatible.
  25.          */
  26.         for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
  27.             checkReturnTypes(sigmethods);
  28.         }
  30.         /*
  31.          * Step 2: Assemble FieldInfo and MethodInfo structs for all of
  32.          * fields and methods in the class we are generating.
  33.          */
  35.          //方法中加入构造方法，这个构造方法只有一个，就是一个带有InvocationHandler接口的构造方法 
  36.          //这个才是真正给class文件，也就是代理类加入方法了，不过还没真正处理，只是先加进来等待循环，构造方法在class文件中的名称描述是<init>  
  38.     try {
  39.         methods.add(generateConstructor());
  40.         for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
  41.             for (ProxyMethod pm : sigmethods) {
  43.  //给每一个代理方法加一个Method类型的属性，数字10是class文件的标识符，代表这些属性都是private static的  
  44.                 fields.add(new FieldInfo(pm.methodFieldName,
  45.                     "Ljava/lang/reflect/Method;",
  46.                      ACC_PRIVATE | ACC_STATIC));
  48.                 //将每一个代理方法都加到代理类的方法中 
  49.                 methods.add(pm.generateMethod());
  50.             }
  51.         }
  53.     //加入一个静态初始化块，将每一个属性都初始化，这里静态代码块也叫类构造方法，其实就是名称为<clinit>的方法，所以加到方法列表  
  54.             methods.add(generateStaticInitializer());
  56.         } catch (IOException e) {
  57.             throw new InternalError("unexpected I/O Exception");
  58.         }
  60.     //方法和属性个数都不能超过65535，包括之前的接口个数也是这样，  
  61.     //这是因为在class文件中，这些个数都是用4位16进制表示的，所以最大值是2的16次方-1  
  62.         if (methods.size() > 65535) {
  63.             throw new IllegalArgumentException("method limit exceeded");
  64.         }
  65.         if (fields.size() > 65535) {
  66.             throw new IllegalArgumentException("field limit exceeded");
  67.         }
  69.     //接下来就是写class文件的过程， 包括魔数， 类名，常量池等一系列字节码的组成，就不一一细说了。需要的可以参考JVM虚拟机字节码的相关知识。
  71.         cp.getClass(dotToSlash(className));
  72.         cp.getClass(superclassName);
  73.         for (int i = 0; i < interfaces.length; i++) {
  74.             cp.getClass(dotToSlash(interfaces[i].getName()));
  75.         }
  76.         cp.setReadOnly();
  77.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  78.         DataOutputStream dout = new DataOutputStream(bout);
  79.         try {
  80.                                         // u4 magic;
  81.             dout.writeInt(0xCAFEBABE);
  82.                                         // u2 minor_version;
  83.             dout.writeShort(CLASSFILE_MINOR_VERSION);
  84.                                         // u2 major_version;
  85.             dout.writeShort(CLASSFILE_MAJOR_VERSION);
  87.             cp.write(dout);             // (write constant pool)
  89.                                         // u2 access_flags;
  90.             dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
  91.                                         // u2 this_class;
  92.             dout.writeShort(cp.getClass(dotToSlash(className)));
  93.                                         // u2 super_class;
  94.             dout.writeShort(cp.getClass(superclassName));
  96.                                         // u2 interfaces_count;
  97.             dout.writeShort(interfaces.length);
  98.                                         // u2 interfaces[interfaces_count];
  99.             for (int i = 0; i < interfaces.length; i++) {
  100.                 dout.writeShort(cp.getClass(
  101.                     dotToSlash(interfaces[i].getName())));
  102.             }
  104.                                         // u2 fields_count;
  105.             dout.writeShort(fields.size());
  106.                                         // field_info fields[fields_count];
  107.             for (FieldInfo f : fields) {
  108.                 f.write(dout);
  109.             }
  111.                                         // u2 methods_count;
  112.             dout.writeShort(methods.size());
  113.                                         // method_info methods[methods_count];
  114.             for (MethodInfo m : methods) {
  115.                 m.write(dout);
  116.             }
  118.                                          // u2 attributes_count;
  119.             dout.writeShort(0); // (no ClassFile attributes for proxy classes)
  121.         } catch (IOException e) {
  122.             throw new InternalError("unexpected I/O Exception");
  123.         }
  125.         return bout.toByteArray();
  126.     }

经过层层调用， 一个代理类终于生成了。

2、是谁调用了Invoke?

我们模拟JDK自己生成一个代理类, 类名为TestProxyGen：

  1. public class TestGeneratorProxy {
  2.     public static void main(String[] args) throws IOException {
  4.         byte[] classFile = ProxyGenerator.generateProxyClass("TestProxyGen", Subject.class.getInterfaces());
  5.         File file = new File("/Users/yadoao/Desktop/TestProxyGen.class");
  6.         FileOutputStream fos = new FileOutputStream(file);  
  7.         fos.write(classFile);  
  8.         fos.flush();  
  9.         fos.close();  
  11.     }
  12. }

用JD-GUI反编译该class文件， 结果如下：

  1. import com.su.dynamicProxy.ISubject;
  2. import java.lang.reflect.InvocationHandler;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Proxy;
  5. import java.lang.reflect.UndeclaredThrowableException;
  7. public final class TestProxyGen extends Proxy
  8.   implements ISubject
  9. {
  10.   private static Method m3;
  11.   private static Method m1;
  12.   private static Method m0;
  13.   private static Method m4;
  14.   private static Method m2;
  16.   public TestProxyGen(InvocationHandler paramInvocationHandler)
  17.     throws 
  18.   {
  19.     super(paramInvocationHandler);
  20.   }
  22.   public final void sayHello()
  23.     throws 
  24.   {
  25.     try
  26.     {
  27.       this.h.invoke(this, m3, null);
  28.       return;
  29.     }
  30.     catch (Error|RuntimeException localError)
  31.     {
  32.       throw localError;
  33.     }
  34.     catch (Throwable localThrowable)
  35.     {
  36.       throw new UndeclaredThrowableException(localThrowable);
  37.     }
  38.   }
  40.   public final boolean equals(Object paramObject)
  41.     throws 
  42.   {
  43.     try
  44.     {
  45.       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
  46.     }
  47.     catch (Error|RuntimeException localError)
  48.     {
  49.       throw localError;
  50.     }
  51.     catch (Throwable localThrowable)
  52.     {
  53.       throw new UndeclaredThrowableException(localThrowable);
  54.     }
  55.   }
  57.   public final int hashCode()
  58.     throws 
  59.   {
  60.     try
  61.     {
  62.       return ((Integer)this.h.invoke(this, m0, null)).intValue();
  63.     }
  64.     catch (Error|RuntimeException localError)
  65.     {
  66.       throw localError;
  67.     }
  68.     catch (Throwable localThrowable)
  69.     {
  70.       throw new UndeclaredThrowableException(localThrowable);
  71.     }
  72.   }
  74.   public final void sayGoodBye()
  75.     throws 
  76.   {
  77.     try
  78.     {
  79.       this.h.invoke(this, m4, null);
  80.       return;
  81.     }
  82.     catch (Error|RuntimeException localError)
  83.     {
  84.       throw localError;
  85.     }
  86.     catch (Throwable localThrowable)
  87.     {
  88.       throw new UndeclaredThrowableException(localThrowable);
  89.     }
  90.   }
  92.   public final String toString()
  93.     throws 
  94.   {
  95.     try
  96.     {
  97.       return (String)this.h.invoke(this, m2, null);
  98.     }
  99.     catch (Error|RuntimeException localError)
  100.     {
  101.       throw localError;
  102.     }
  103.     catch (Throwable localThrowable)
  104.     {
  105.       throw new UndeclaredThrowableException(localThrowable);
  106.     }
  107.   }
  109.   static
  110.   {
  111.     try
  112.     {
  113.       m3 = Class.forName("com.su.dynamicProxy.ISubject").getMethod("sayHello", new Class[0]);
  114.       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
  115.       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
  116.       m4 = Class.forName("com.su.dynamicProxy.ISubject").getMethod("sayGoodBye", new Class[0]);
  117.       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
  118.       return;
  119.     }
  120.     catch (NoSuchMethodException localNoSuchMethodException)
  121.     {
  122.       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
  123.     }
  124.     catch (ClassNotFoundException localClassNotFoundException)
  125.     {
  126.       throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  127.     }
  128.   }
  129. }

就此代理模式分析到此结束。

参考文献

代理模式原理及实例讲解
代理模式学习

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注