Java 代理模式

    最近在读《Hadoop技术内幕》，读到 hadoop远程过程调用这一章时很吃力，原因是对java 动态代理、java Nio、java多线程理解的不是很透彻。因此先专门花点时间把这一部分恶补一下。

    Java 代理模式分为远程代理、虚拟代理和动态代理，下面分别将这几个代理模式。

    远程代理

    远程代理就好比“远程对象的本地代表”。何谓“远程对象”？这是一种对象，活在不同的Java虚拟机(JVM)堆中。客户端通过辅助对象，将请求转发到远程对象上。

在服务端，服务辅助对象从客户辅助对象中接收请求(透过Socket连接)，将调用的信息解包，然后调用真正服务对象上的真正方法。服务辅助对象从服务中得到返回值，将它打包，然后运回到客户辅助对象(通过Socket的输出流)，客户辅助对象对信息解包，最后将返回值交给客户对象。

远程代理依赖于Java RMI，RMI允许我们不必亲自写任何网络或I/O代码，客户程序调用远程方法就和在运行在客户自己的本地JVM上对象进行正常方法调用一样。 RMI也提供了所有运行时的基础设施，好让这一切正常工作，这包括查找服务(lookup service)，这个服务用来寻找和访问对象。用java rmi制作远程服务的步骤如下：

步骤一：

       制作远程接口，定义出可以让客户远程调用的方法。客户将用它作为服务的类类型。Stub和实际的服务都实现此接口。(MyService.java)

步骤二：

       制作远程实现。(MyServiceImpl.java)

步骤三：

       利用rmic 产生stub和skeleton。这就是客户和服务的辅助类。(rmic MyServiceImpl)

步骤四：

      启动RMI registry (rmiregistry)。 rmiregistry就像电话薄，客户可以从中查到代理的位置. (rmiregistry)

步骤五：

      开始远程服务。你必须让服务对象开始运行，你的服务实现类回去实例化一个服务的实例，并将这个服务注册到RMI registry。注册之后，这个服务就可以供客户调用了。(java MyServiceImp)

//MyService.javaimport java.rmi.*;public interface MyService extends Remote{public String sayHello() throws RemoteException;}

Remote 是一个“记号”接口，不具有方法。远程方法的变量和返回值，必须属于原语类型或可序列化类型。

import java.rmi.Naming;import java.rmi.RemoteException;import java.rmi.server.UnicastRemoteObject;public class MyServiceImpl extends UnicastRemoteObject implements MyService {protected MyServiceImpl() throws RemoteException {super();// TODO Auto-generated constructor stub}@Overridepublic String sayHello() throws RemoteException {return "Server says, 'Hey'";}public static void main(String[] args) {try{MyService service = new MyServiceImpl();Naming.rebind("RemoteHello", service);} catch(Exception e){e.printStackTrace();}}}

为了要成为远程服务对象，你的对象需要某些”远程的“功能。最简单的方式就是扩展java.rmi.server.UnicastRemoteObject，让超类帮你做这些工作。现在你已经有一个远程服务了，必须让它可以被远程客户调用。你要做的时将此服务实例化，然后放进RMI registry中，也就是代码中main方法主要工作。

写好了接口和实现类后用rmic工具生成sutb和skeleton(rmic MyRemoteImpl)。然后执行remiregistry，并启动服务。

import java.rmi.Naming;public class MyRemoteClient {public static void main(String[] args){new MyRemoteClient().go();}public void go() {try {MyService service = (MyService) Naming.lookup("rmi://127.0.0.1/RemoteHello");String s = service.sayHello();System.out.println(s);} catch (Exception e) {e.printStackTrace();}}}

客户端通过Naming.lookup查找相应的服务。

动态代理

 普通代理模式每一个代理类只能为一个接口服务，这样程序开发中必然会出现很多的代理，并且所有代理操作除了调用方法不一样外，其他操作（包括调用前、后，参数检查等）基本上都一样，这样肯定会重复写好多代码。为了避免这样的问题，提出动态代理模式。

普通代理模式代理类的class文件是事先编译好存在的，但动态代理模式的代理类程序员不需要编写，而是在程序运行的时候动态生成的，这里用到了java的反射机制。我们首先看一下动态代理模式怎么用。

import java.rmi.*;public interface MyService{public String sayHello();}

public class MyServiceImpl implements MyService {protected MyServiceImpl(){}@Overridepublic String sayHello() throws RemoteException {return "Server says, 'Hey'";}}

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class MyInvocationHandler implements InvocationHandler {private Object target;public MyInvocationHandler(Object target) {super();this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {// beforeSystem.out.println("--------before------");// methodObject result = method.invoke(target, args);// afterSystem.out.println("--------After-------");return result;}/* * 获取目标对象的代理 */public Object getProxy(){return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), this);}}

public class DynamicProxyTest {public static void main(String[] args) throws Exception {// TODO Auto-generated method stubMyServiceImpl serviceImpl = new MyServiceImpl();MyInvocationHandler mh = new MyInvocationHandler(serviceImpl);MyService service = (MyService) mh.getProxy();service.sayHello();}}

要了解 Java 动态代理的机制，首先需要了解以下相关的类或接口：

• java.lang.reflect.Proxy：这是 Java 动态代理机制的主类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器static InvocationHandler getInvocationHandler(Object proxy) // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象static Class getProxyClass(ClassLoader loader, Class[] interfaces) // 方法 3：该方法用于判断指定类对象是否是一个动态代理类static boolean isProxyClass(Class cl) // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例static Object newProxyInstance(ClassLoader loader, Class[] interfaces,     InvocationHandler h)

• java.lang.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行Object invoke(Object proxy, Method method, Object[] args)

每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象（参见 Proxy 静态方法 4 的第三个参数）。
java.lang.ClassLoader：这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。
每次生成动态代理类对象时都需要指定一个类装载器对象（参见 Proxy 静态方法 4 的第一个参数）

• 代理机制及其特点

首先让我们来了解一下如何使用 Java 动态代理。具体有如下四步骤：
1) 通过实现 InvocationHandler 接口创建自己的调用处理器；
2) 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
3) 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
4) 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); // 通过反射从生成的类对象获得构造函数对象Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); // 通过构造函数对象创建动态代理类实例Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,  new Class[] { Interface.class },  handler );

接下来让我们来了解一下 Java 动态代理机制的一些特点。
首先是动态生成的代理类本身的一些特点。1）包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；2）类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；3）类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象，而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。4）类继承关系：该类的继承关系如图：

由图可见，Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。
接下来让我们了解一下代理类实例的一些特点。每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行，此外，值得注意的是，代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。
接着来了解一下被代理的一组接口有哪些特点。首先，要注意不能有重复的接口，以避免动态代理类代码生成时的编译错误。其次，这些接口对于类装载器必须可见，否则类装载器将无法链接它们，将会导致类定义失败。再次，需被代理的所有非 public 的接口必须在同一个包中，否则代理类生成也会失败。最后，接口的数目不能超过 65535，这是 JVM 设定的限制。
最后再来了解一下异常处理方面的特点。从调用处理器接口声明的方法中可以看到理论上它能够抛出任何类型的异常，因为所有的异常都继承于 Throwable 接口，但事实是否如此呢？答案是否定的，原因是我们必须遵守一个继承原则：即子类覆盖父类或实现父接口的方法时，抛出的异常必须在原方法支持的异常列表之内。所以虽然调用处理器理论上讲能够，但实际上往往受限制，除非父接口中的方法支持抛 Throwable 异常。那么如果在 invoke 方法中的确产生了接口方法声明中不支持的异常，那将如何呢？放心，Java 动态代理类已经为我们设计好了解决方法：它将会抛出 UndeclaredThrowableException 异常。这个异常是一个 RuntimeException 类型，所以不会引起编译错误。通过该异常的 getCause 方法，还可以获得原来那个不受支持的异常对象，以便于错误诊断。

虚拟代理

虚拟代理作为创建开销大的对象的代表。虚拟代理经常直到我们真正需要一个对象的时候才创建它。当对象创建前或创建过程中时，由虚拟代理来扮演对象的替身。对象创建后，代理就会将请求直接委托给对象。

作为一个例子，我们考虑这样一个程序：有一个界面显示一个图片，因为图片加载过程需要时间，希望这段时间用一个"loading..."界面来代替。

class ImageProxy implements Icon{    ImageIcon imageIcon;    URL imageURL;    Thread retrievalThread;    boolean retrieving = false;    public ImageProxy(URL url) {imageURL = url;}    public int getIconWidth(){        if(imageIcon != null) {             return imageIcon.getIconWidth();          }        else {             return 800;          }     }    public int getIconHeight() {       if(imageIcon!=null) {            return imageIcon.getIconHeight();         }       else {           return 600;        }     }    public void paintIcon(final Component c, Graphics g,int x , int y) {        if(imageIcon != null) {             imageIcon.paintIcon(c,g,x,y);          }        else {            g.drawString("Loading the image, please wait...",x+300,y+300);            if(!retrieving) {                 retrieving = true;                 retrievalThread = new Thread(new Runnable(){                    public void run(){                         try{                             imageIcon = new ImageIcon(imageURL, "image");                             }catch(Exception e){                                    e.printStackTrace();                                     }                         }                     });               retrievalThread.start();               }          }               }}

public class ImageProxyTestDrive{    ImageComponent imageComponent;    public static void main(String[] args) throws Exception {         ImageProxyTestDrive testDrive - new ImageProxyTestDrive();     }     public ImageProxyTestDrive(){        Icon icon = new ImageProxy(initURL);        imageComponent = new ImageComponent(icon);        frame.getContentPane().add(imageComponent);      }}

参考资料：

远程代理、虚拟代理：《head first 设计模式》

动态代理：http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/index.html

                  http://rejoy.iteye.com/blog/1627405