動態(tài)代理
java中動態(tài)代理機制的引入使得代理模式的思想更加完善與進步,它允許動態(tài)的創(chuàng)建代理并支持對動態(tài)的對所代理的方法進行調(diào)用。Java動態(tài)代理類位于Java.lang.reflect包下,一般主要涉及到以下兩個類:
(1). Interface InvocationHandler:該接口中僅定義了一個方法Object:invoke(Object obj,Method method, Object[] args)。在實際使用時,第一個參數(shù)obj一般是指代理類,method是被代理的方法,如上例中的request(),args為該方法的參數(shù)數(shù)組。這個抽象方法在代理類中動態(tài)實現(xiàn)。
(2).Proxy:該類即為動態(tài)代理類,作用類似于上例中的ProxySubject,其中主要包含以下內(nèi)容:
Protected Proxy(InvocationHandler h):構(gòu)造函數(shù),估計用于給內(nèi)部的h賦值。
Static Class getProxyClass (ClassLoader loader, Class[] interfaces):獲得一個代理類,其中l(wèi)oader是類裝載器,interfaces是真實類所擁有的全部接口的數(shù)組。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):返回代理類的一個實例,返回后的代理類可以當作被代理類使用(可使用被代理類的在Subject接口中聲明過的方法)。
所謂Dynamic Proxy是這樣一種class:它是在運行時生成的class,在生成它時你必須提供一組interface給它,然后該class就宣稱它實現(xiàn)了這些interface。你當然可以把該class的實例當作這些interface中的任何一個來用。當然啦,這個Dynamic Proxy其實就是一個Proxy,它不會替你作實質(zhì)性的工作,在生成它的實例時你必須提供一個handler,由它接管實際的工作。 下面我們通過動態(tài)代理來重新實現(xiàn)上面發(fā)送信息的例子!

在上面的例子基礎(chǔ)上,我們先添加一個通過短信來發(fā)送消息的處理類:
public class SmsMessage implements MessageHandler {
@Override
public void sendMessage(String msg) {
// TODO Auto-generated method stub
System.out.println("SMS Message :" + msg+" sent !");
}
}
//動態(tài)代理類
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;
}
}
//下面是調(diào)用
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 !
以上例子中,通過調(diào)用Proxy.newProxyInstance方法創(chuàng)建動態(tài)代理對象,該方法需要傳入一個 類加載器、一組希望代理實現(xiàn)的接口列表、InvocationHandler 接口的一個具體實現(xiàn)。動態(tài)代理可以將所有調(diào)用重定向到調(diào)用處理器,通常我們會向該處理器傳遞一個時間對象的引用。invoke()方法中傳遞進來了代理對象,當你需要區(qū)分請求來源時這是非常有用的,例如你可以通過判斷傳入的方法名屏蔽掉某些方法的執(zhí)行!動態(tài)代理機制并不是會很頻繁使用的方法,它通常用來解決一些特定情況下的問題,因此不要盲目的為了使用而使用,要根據(jù)自己的實際需求來決定!
動態(tài)代理的應(yīng)用十分廣泛,在struts2的攔截器中就用到了動態(tài)代理機制。還是以買車票為例子,現(xiàn)在用動態(tài)代理來實現(xiàn),其中不懂的接口方法查查Java api就會明白了,在此不多做解釋,代碼如下(注意PassengerProxy類):
import java.lang.reflect.*;
public interface Passenger {
public void buyTicket();
}
public class RealPassenger implements Passenger {
@Override
public void buyTicket() {
// TODO Auto-generated method stub
System.out.println("購買了車票");
}
}
// 用動態(tài)代理實現(xiàn)
//InvocationHandler
是代理實例的調(diào)用處理程序 實現(xiàn)的接口。 每個代理實例都具有一個關(guān)聯(lián)的調(diào)用處理程序。對代理實例調(diào)用方法時,將對方法調(diào)用進行編碼并將其指派到//它的調(diào)用處理程序的 invoke
方法。
public class PassengerProxy implements InvocationHandler {
public Object obj;
// 把obj交給代理類
public Object obj(Object obj) {
this.obj = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("通過代理");
method.invoke(obj, args);
return null;
}
}
public class Client {
public static void main(String[] args) {
PassengerProxy proxy = new PassengerProxy();
Passenger passenger = (Passenger) proxy.obj(new RealPassenger());
passenger.buyTicket();
}
}
再來一個更牛的例子
- /**
- * 相親接口
- *
- * @author zhengt
- * @time Jun 3, 2095 3:13:03 PM
- */
- public interface XiangQinInterface {
- /**
- * 相親方法
- */
- public void xiangQin();
- }
- /**
- * 張三相親實現(xiàn)類
- *
- * @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 {
- //相親接口的實現(xiàn)類,也就是張三相親類
- private Object zhangSan = null;
-
- public ReadyInvocationHandler(Object realSubject) {
- this.zhangSan = realSubject;
- }
-
- public Object invoke(Object proxy, Method m, Object[] args) {
- Object result = null;
- try {
- /**
- * 動態(tài)代理類$Proxy0調(diào)用xiangQin方法時會調(diào)用它自己的xiangQin方法,
- * 而它自己的xiangQin方法里面調(diào)用的是super.h.invoke(this, , ),也就是父類Proxy的h的invoke方法,
- * 也就是ReadyInvocationHandler類的invoke方法。
- * 所以,invoke(Object proxy, Method m, Object[] args)種的proxy實際上就是動態(tài)代理類$Proxy0,
- * 如果你將其強轉(zhuǎn)成XiangQinInterface然后調(diào)用它的xiangQin方法,然后它就會調(diào)用super.h.invoke(this, , ),這樣就會死循環(huán)。
- */
- /**
- * 網(wǎng)上關(guān)于這里最多問題就是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;
-
- /**
- * 張三來到了婚介所(相親現(xiàn)場),開始相親。
- *
- * @author zhengt
- * @time Jun 3, 2095 3:17:16 PM
- */
- public class HunJieSuo {
- public static void main(String args[]) {
- //先將張三相親這個相親的實現(xiàn)類實例化,也就是得到XiangQinInterface接口的一個實例對象
- XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();
- /**
- * 得到ZhangSanXiangQinInterfaceImpl這個類的一個代理類,同時為代理類綁定了一個處理類ReadyInvocationHandler。
- * 聽著很繞口,其實就是每次調(diào)用ZhangSanXiangQinInterfaceImpl這個子類的xiangQin方法時,
- * 不是zhangSan這個ZhangSanXiangQinInterfaceImpl類的實例去調(diào)用,
- * 而是這個ZhangSanXiangQinInterfaceImpl的代理類ReadyInvocationHandler去調(diào)用它自己的invoke方法,
- * 這個invoke方法里呢可以調(diào)用zhangSan這個實例的xiangQin方法
- */
- /**
- * 在java種怎樣實現(xiàn)動態(tài)代理呢
- * 第一步,我們要有一個接口,還要有一個接口的實現(xiàn)類,而這個實現(xiàn)類呢就是我們要代理的對象,
- * 所謂代理呢也就是在調(diào)用實現(xiàn)類的方法時,可以在方法執(zhí)行前后做額外的工作,這個就是代理。
- * 第二步,我們要自己寫一個在要代理類的方法執(zhí)行時,能夠做額外工作的類,而這個類必須繼承InvocationHandler接口,
- * 為什么要繼承它呢?因為代理類的實例在調(diào)用實現(xiàn)類的方法的時候,不會調(diào)真正的實現(xiàn)類的這個方法,
- * 而是轉(zhuǎn)而調(diào)用這個類的invoke方法(繼承時必須實現(xiàn)的方法),在這個方法中你可以調(diào)用真正的實現(xiàn)類的這個方法。
- * 第三步,在要用代理類的實例去調(diào)用實現(xiàn)類的方法的時候,寫出下面兩段代碼。
- */
- XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(
- zhangSan.getClass().getClassLoader(),
- zhangSan.getClass().getInterfaces(),
- new ReadyInvocationHandler(zhangSan));
- proxy.xiangQin();
- /**
- * 這里要解釋下中部那段長長的代碼的意思,以及具體做了哪些工作?
- * 第一,根據(jù)zhangSan.getClass().getClassLoader()這個要代理類的類加載器和
- * zhangSan.getClass().getInterfaces()要代理類所實現(xiàn)的所有的接口
- * 作為參數(shù)調(diào)用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)
- * 的方法返回代理類的java.lang.Class對象,也就是得到了java動態(tài)生成的代理類$Proxy0的Class對象。
- * 同時,java還讓這個動態(tài)生成的$Proxy0類實現(xiàn)了要代理類的實現(xiàn)的所有接口,并繼承了Proxy接口。
- * 第二,實例化這個動態(tài)生成的$Proxy0類的一個實例,實例化代理類的構(gòu)造函數(shù)為Proxy(InvocationHandler h),
- * 也就是說要實例化這個動態(tài)生成的$Proxy0類,必須給它一個InvocationHandler參數(shù),也就是我們自己實現(xiàn)的用來在代理類
- * 方法執(zhí)行前后做額外工作的類ReadyInvocationHandler。
- * 這 段代碼 Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))
- * 得到的其實是一個類名叫$Proxy0 extends Proxy implements XiangQinInterface的類。
- * 第三,將這個$Proxy0類強制轉(zhuǎn)型成XiangQinInterface類型,調(diào)用xiangQin方法。
- */
- }
- }
在目前的Java開發(fā)包中包含了對動態(tài)代理的支持,但是其實現(xiàn)只支持對接口的的實現(xiàn)。
其實現(xiàn)主要通過是java.lang.reflect.Proxy類和java.lang.reflect.InvocationHandler接口。
Proxy類主要用來獲取動態(tài)代理對象,InvocationHandler接口用來約束調(diào)用者實現(xiàn),如下,DiaoSi接口定義的 業(yè)務(wù)方法,DiaoSiNanImpl是DiaoSi接口的實現(xiàn),
DiaoSiNanHandler是 InvocationHandler接口實現(xiàn)。代碼如下:
業(yè)務(wù)接口:
package proxy;
public interface DiaoSi {
void luGuan();
}
public class DiaoSiNan implements DiaoSi {
@Override
public void luGuan() {
// TODO Auto-generated method stub
System.out.println("我是擼管王");
}
}
InvocationHandler實現(xiàn),需要在接口方法調(diào)用前后加入一部份處理工作,這里僅僅在方法調(diào)用前后向后臺輸出兩句字符串,其代碼如下:
package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DiaoSiNanHander implements InvocationHandler{
//要代理的原始對象
private Object diaosinan;
/**
* 構(gòu)造函數(shù)。
* @param obj 要代理的原始對象。
*/
public DiaoSiNanHander(Object diaosinan) {
this.diaosinan = diaosinan;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
Object result ;
doBefore();
//調(diào)用原始對象的方法
result = method.invoke(this.diaosinan ,args);
//方法調(diào)用之后
doafter();
return result;
}
private void doafter() {
// TODO Auto-generated method stub
System.out.println("after method invoke!");
}
private void doBefore() {
// TODO Auto-generated method stub
System.out.println("before method invoke!");
}
}
測試代碼:
package proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
DiaoSi ds = new DiaoSiNan();
DiaoSiNanHander handler = new DiaoSiNanHander(ds);
DiaoSi proxy = (DiaoSi) Proxy.newProxyInstance(
ds.getClass().getClassLoader(),
ds.getClass().getInterfaces(),
handler);
/*public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) {
throw new NullPointerException();
}*/
proxy.luGuan();
}
}
Ø 首先獲取一個業(yè)務(wù)接口的實現(xiàn)對象;
Ø 獲取一個InvocationHandler實現(xiàn),此處是
DiaoSiNanHanderHandler對象;
Ø 創(chuàng)建動態(tài)代理對象;
Ø 通過動態(tài)代理對象調(diào)用luGuan()方法,此時會在原始對象DiaoSiNan.luGuan()方法前后輸出兩句字符串。
運行測試類輸出如下:
before method invoke!
我試擼管王
after method invoke!
此處Test類中的方法調(diào)用代碼比較多,在我們的實際應(yīng)用中可以通過配置文件來來簡化客戶端的調(diào)用實現(xiàn)。另外也可以通過動態(tài)代理來實現(xiàn)簡單的AOP。