Java 代理模式详解

代理模式是我们比较常用的设计模式之一。其中新思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信，代理模式一般涉及到的角色有：

抽象角色：声明真实对象和代理对象的共同接口；
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

以下以发送消息为例来说明一个简单的代理模式的基本实现：
首先明确目的：有一条消息，需要把这个消息发送出去，根据这个目的定义对应接口MessageHandler。需要的附加操作：假设需要验证消息的长度不能超过指定长度并且不能为空，并且我们需要统计相关信息发送到次数，超过指定的次数我们需要输出警报。我们通过代理模式来实现这个附加的操作。下面为对应的类关系图及示例代码。

//接口定义
public interface MessageHandler {
public void sendMessage(String msg);
}
//通过Email方式发送消息的实现类
public class EmailMessage implements MessageHandler {
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
System.out.println(msg+" send!!");
}
}
//消息处理的代理类
public class MessageProxy implements MessageHandler {
private static int count;
private MessageHandler emailMsg;
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
if(checkMessage(msg))
{
if(emailMsg==null) emailMsg=new EmailMessage();
count++;
emailMsg.sendMessage(msg);
System.out.println("Message sent:"+count);
}
}
private boolean checkMessage(String msg) {
return msg != null && msg.length() > 10;
}
}
//调用类
public class MainClass {
private static void runProxy(MessageHandler handler)
{
handler.sendMessage("message for test");
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
runProxy(new EmailMessage());
System.out.println("++++++++++++++++Pjroxy++++++++++++++++++");
runProxy(new MessageProxy());
}
}
输出
message for test send!!
++++++++++++++++Pjroxy++++++++++++++++++
message for test send!!
Message sent:1

在例子中我们可以方便的在消息发送过程中添加各种需要的附加处理方式，也能方便的替换消息的处理方式，如将通过Email发送消息替换为通过短信发送消息，而调用方不会有丝毫察觉！在任何你想要将一些额外操作分离到具体对象之外，特别是希望能够很容易做出修改，或者想在具体对象的方法执行前插入一些额外操作的时候，代理就显得十分有用！

动态代理
java中动态代理机制的引入使得代理模式的思想更加完善与进步，它允许动态的创建代理并支持对动态的对所代理的方法进行调用。Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

(1).Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Objectobj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

ProtectedProxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。

StaticClass getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

StaticObject newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic
Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。下面我们通过动态代理来重新实现上面发送信息的例子！



在上面的例子基础上，我们先添加一个通过短信来发送消息的处理类：

public class SmsMessage implements MessageHandler {
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
System.out.println("SMS Message :" + msg+" sent !");
}
}
//动态代理类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DynamicMessageProxy implements InvocationHandler {
private static int count;
private MessageHandler msgHandler;
public DynamicMessageProxy(MessageHandler handler) {
msgHandler = handler;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("++++++++=============+++++++++");
System.out.println("proxy:" + proxy.getClass());
System.out.println("method:" + method);
System.out.println("++++++++=============+++++++++");
if (args != null && args.length == 1 && checkMessage((String) args[0])) {
count++;
System.out.println("Message sent:" + count);
return method.invoke(msgHandler, args);
}
return null;
}
private boolean checkMessage(String msg) {
return msg != null && msg.length() > 10;
}
}
//下面是调用
import java.lang.reflect.Proxy;
public class MainClass {
private static void runProxy(MessageHandler handler) {
handler.sendMessage("message for test");
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
// runProxy(new EmailMessage());
// System.out.println("++++++++++++++++Proxy++++++++++++++++++");
// runProxy(new MessageProxy());
MessageHandler handler = new EmailMessage();
runProxy(handler);
MessageHandler proxy = (MessageHandler) Proxy.newProxyInstance(
MessageHandler.class.getClassLoader(),
new Class[] { MessageHandler.class }, new DynamicMessageProxy(
handler));
runProxy(proxy);
System.out.println("++++++++++++++++++++++++++++++++++");
// 短信方式
handler = new SmsMessage();
runProxy(handler);
proxy = (MessageHandler) Proxy.newProxyInstance(MessageHandler.class
.getClassLoader(), new Class[] { MessageHandler.class },
new DynamicMessageProxy(handler));
runProxy(proxy);
}
}
下面为以上方法的输出：
message for test send!!
++++++++=============+++++++++
proxy:class $Proxy0
method:public abstract void MessageHandler.sendMessage(java.lang.String)
++++++++=============+++++++++
Message sent:1
message for test send!!
++++++++++++++++++++++++++++++++++
SMS Message :message for test sent !
++++++++=============+++++++++
proxy:class $Proxy0
method:public abstract void MessageHandler.sendMessage(java.lang.String)
++++++++=============+++++++++
Message sent:2
SMS Message :message for test sent !

以上例子中，通过调用Proxy.newProxyInstance方法创建动态代理对象，该方法需要传入一个类加载器、一组希望代理实现的接口列表、InvocationHandler接口的一个具体实现。动态代理可以将所有调用重定向到调用处理器，通常我们会向该处理器传递一个时间对象的引用。invoke()方法中传递进来了代理对象，当你需要区分请求来源时这是非常有用的，例如你可以通过判断传入的方法名屏蔽掉某些方法的执行！动态代理机制并不是会很频繁使用的方法，它通常用来解决一些特定情况下的问题，因此不要盲目的为了使用而使用，要根据自己的实际需求来决定！

另一个好理解的例子

Java代码


/**

* 相亲接口

*

* @author zhengt

* @time Jun 3, 2095 3:13:03 PM

*/

public interface XiangQinInterface {

/**

* 相亲方法

*/

public void xiangQin();

}

/**

* 张三相亲实现类

*

* @author zhengt

* @time Jun 3, 2095 3:14:48 PM

*/

public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {

public void xiangQin() {

System.out.println("张三去相亲，娶个漂亮老婆。");

}

}

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

/**

* 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。

*

* @author zhengt

* @time Jun 3, 2095 3:15:48 PM

*/

public class ReadyInvocationHandler implements InvocationHandler {

//相亲接口的实现类，也就是张三相亲类

private Object zhangSan = null;

public ReadyInvocationHandler(Object realSubject) {

this.zhangSan = realSubject;

}

public Object invoke(Object proxy, Method m, Object[] args) {

Object result = null;

try {

/**

* 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法，

* 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法，

* 也就是ReadyInvocationHandler类的invoke方法。

* 所以，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0，

* 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用super.h.invoke(this, , )，这样就会死循环。

*/

/**

* 网上关于这里最多问题就是Object proxy放在这里用来做什么呢？这个我也不知道，

* 不过至少我们知道它到底是个什么东西，具体做什么用嘛就不得而知了

*/

System.out.println(proxy.getClass().getSimpleName());

System.out.println("张三相亲前，代理人给他打扮了打扮。");

result = m.invoke(zhangSan, args);

} catch (Exception ex) {

System.exit(1);

}

return result;

}

}

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

/**

* 张三来到了婚介所(相亲现场)，开始相亲。

*

* @author zhengt

* @time Jun 3, 2095 3:17:16 PM

*/

public class HunJieSuo {

public static void main(String args[]) {

//先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象

XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();

/**

* 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。

* 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时，

* 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用，

* 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法,

* 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法

*/

/**

* 在java种怎样实现动态代理呢

* 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象，

* 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。

* 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口，

* 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法，

* 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。

* 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。

*/

XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(

zhangSan.getClass().getClassLoader(),

zhangSan.getClass().getInterfaces(),

new ReadyInvocationHandler(zhangSan));

proxy.xiangQin();

/**

* 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？

* 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和

* zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口

* 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)

* 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。

* 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。

* 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)，

* 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类

* 方法执行前后做额外工作的类ReadyInvocationHandler。

* 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))

* 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。

* 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。

*/

}

}