qileilove

blog已经转移至github,大家请访问 http://qaseven.github.io/

跟屌丝大哥学习设计模式---代理模式之动态代理

动态代理

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

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

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

Protected Proxy(InvocationHandler h):构造函数,估计用于给内部的h赋值。 

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

Static Object 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()方法中传递进来了代理对象,当你需要区分请求来源时这是非常有用的,例如你可以通过判断传入的方法名屏蔽掉某些方法的执行!动态代理机制并不是会很频繁使用的方法,它通常用来解决一些特定情况下的问题,因此不要盲目的为了使用而使用,要根据自己的实际需求来决定!

动态代理的应用十分广泛,在struts2的拦截器中就用到了动态代理机制。还是以买车票为例子,现在用动态代理来实现,其中不懂的接口方法查查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("购买了车票");
}
}

// 用动态代理实现

//InvocationHandler 是代理实例的调用处理程序 实现的接口。 每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时,将对方法调用进行编码并将其指派到//它的调用处理程序的 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();
}
}

再来一个更牛的例子

  1. /** 
  2.  * 相亲接口 
  3.  *  
  4.  * @author zhengt 
  5.  * @time Jun 3, 2095 3:13:03 PM 
  6.  */  
  7. public interface XiangQinInterface {  
  8.     /** 
  9.      * 相亲方法 
  10.      */  
  11.     public void xiangQin();  
  12. }  
  13. /** 
  14.  * 张三相亲实现类 
  15.  *  
  16.  * @author zhengt 
  17.  * @time Jun 3, 2095 3:14:48 PM 
  18.  */  
  19. public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {  
  20.     public void xiangQin() {  
  21.         System.out.println("张三去相亲,娶个漂亮老婆。");  
  22.     }  
  23. }  
  24. import java.lang.reflect.InvocationHandler;  
  25. import java.lang.reflect.Method;  
  26.   
  27. /** 
  28.  * 相亲可是一辈子的大事,相亲前要准备一下,打扮得帅气些。 
  29.  *  
  30.  * @author zhengt 
  31.  * @time Jun 3, 2095 3:15:48 PM 
  32.  */  
  33. public class ReadyInvocationHandler implements InvocationHandler {  
  34.     //相亲接口的实现类,也就是张三相亲类  
  35.     private Object zhangSan = null;  
  36.   
  37.     public ReadyInvocationHandler(Object realSubject) {  
  38.         this.zhangSan = realSubject;  
  39.     }  
  40.   
  41.     public Object invoke(Object proxy, Method m, Object[] args) {  
  42.         Object result = null;  
  43.         try {  
  44.             /** 
  45.              * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法, 
  46.              * 而它自己的xiangQin方法里面调用的是super.h.invoke(this, , ),也就是父类Proxy的h的invoke方法, 
  47.              * 也就是ReadyInvocationHandler类的invoke方法。 
  48.              * 所以,invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0, 
  49.              * 如果你将其强转成XiangQinInterface然后调用它的xiangQin方法,然后它就会调用super.h.invoke(this, , ),这样就会死循环。 
  50.              */  
  51.             /** 
  52.              * 网上关于这里最多问题就是Object proxy放在这里用来做什么呢?这个我也不知道, 
  53.              * 不过至少我们知道它到底是个什么东西,具体做什么用嘛就不得而知了 
  54.              */  
  55.             System.out.println(proxy.getClass().getSimpleName());  
  56.             System.out.println("张三相亲前,代理人给他打扮了打扮。");  
  57.             result = m.invoke(zhangSan, args);  
  58.         } catch (Exception ex) {  
  59.             System.exit(1);  
  60.         }  
  61.         return result;  
  62.     }  
  63. }  
  64. import java.lang.reflect.InvocationHandler;  
  65. import java.lang.reflect.Method;  
  66. import java.lang.reflect.Proxy;  
  67.   
  68. /** 
  69.  * 张三来到了婚介所(相亲现场),开始相亲。 
  70.  *  
  71.  * @author zhengt 
  72.  * @time Jun 3, 2095 3:17:16 PM 
  73.  */  
  74. public class HunJieSuo {  
  75.     public static void main(String args[]) {  
  76.         //先将张三相亲这个相亲的实现类实例化,也就是得到XiangQinInterface接口的一个实例对象  
  77.         XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();  
  78.         /** 
  79.          * 得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类,同时为代理类绑定了一个处理类ReadyInvocationHandler。 
  80.          * 听着很绕口,其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时, 
  81.          * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用, 
  82.          * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke方法, 
  83.          * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法 
  84.          */  
  85.         /** 
  86.          * 在java种怎样实现动态代理呢 
  87.          * 第一步,我们要有一个接口,还要有一个接口的实现类,而这个实现类呢就是我们要代理的对象, 
  88.          * 所谓代理呢也就是在调用实现类的方法时,可以在方法执行前后做额外的工作,这个就是代理。 
  89.          * 第二步,我们要自己写一个在要代理类的方法执行时,能够做额外工作的类,而这个类必须继承InvocationHandler接口, 
  90.          * 为什么要继承它呢?因为代理类的实例在调用实现类的方法的时候,不会调真正的实现类的这个方法, 
  91.          * 而是转而调用这个类的invoke方法(继承时必须实现的方法),在这个方法中你可以调用真正的实现类的这个方法。 
  92.          * 第三步,在要用代理类的实例去调用实现类的方法的时候,写出下面两段代码。 
  93.          */  
  94.         XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(  
  95.                 zhangSan.getClass().getClassLoader(),  
  96.                 zhangSan.getClass().getInterfaces(),  
  97.                 new ReadyInvocationHandler(zhangSan));  
  98.         proxy.xiangQin();  
  99.         /** 
  100.          * 这里要解释下中部那段长长的代码的意思,以及具体做了哪些工作? 
  101.          * 第一,根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和 
  102.          * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口 
  103.          * 作为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces) 
  104.          * 的方法返回代理类的java.lang.Class对象,也就是得到了java动态生成的代理类$Proxy0的Class对象。 
  105.          * 同时,java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口,并继承了Proxy接口。 
  106.          * 第二,实例化这个动态生成的$Proxy0类的一个实例,实例化代理类的构造函数为Proxy(InvocationHandler h), 
  107.          * 也就是说要实例化这个动态生成的$Proxy0类,必须给它一个InvocationHandler参数,也就是我们自己实现的用来在代理类 
  108.          * 方法执行前后做额外工作的类ReadyInvocationHandler。 
  109.          * 这 段代码 Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan)) 
  110.          * 得到的其实是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。 
  111.          * 第三,将这个$Proxy0类强制转型成XiangQinInterface类型,调用xiangQin方法。 
  112.          */  
  113.     }  

网上看到一个牛人读过这个动态代理的源代码,现把网址留在这里,希望对网友们有帮助。
http://hi.baidu.com/malecu/blog/item/45d4952b31bc0e27d52af17a.html
在目前的Java开发包中包含了对动态代理的支持,但是其实现只支持对接口的的实现。

  其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

  Proxy类主要用来获取动态代理对象,InvocationHandler接口用来约束调用者实现,如下,DiaoSi接口定义的 业务方法,DiaoSiNanImpl是DiaoSi接口的实现,
DiaoSiNanHandler是 InvocationHandler接口实现。代码如下:
业务接口:
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实现,需要在接口方法调用前后加入一部份处理工作,这里仅仅在方法调用前后向后台输出两句字符串,其代码如下:
package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DiaoSiNanHander implements InvocationHandler{
    //要代理的原始对象
    
private Object diaosinan;
/**

* 构造函数。

* @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();
        //调用原始对象的方法
        result = method.invoke(this.diaosinan ,args);
        //方法调用之后
        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();

        

}
}
Ø 首先获取一个业务接口的实现对象;

  Ø 获取一个InvocationHandler实现,此处是
DiaoSiNanHanderHandler对象;

  Ø 创建动态代理对象;

  Ø 通过动态代理对象调用luGuan()方法,此时会在原始对象DiaoSiNan.luGuan()方法前后输出两句字符串。

  运行测试类输出如下:

  
before method invoke!
我试撸管王
after method invoke!


  此处Test类中的方法调用代码比较多,在我们的实际应用中可以通过配置文件来来简化客户端的调用实现。另外也可以通过动态代理来实现简单的AOP。




 

posted on 2012-12-13 11:53 顺其自然EVO 阅读(349) 评论(0)  编辑  收藏 所属分类: 设计模式学习


只有注册用户登录后才能发表评论。


网站导航:
 
<2012年12月>
2526272829301
2345678
9101112131415
16171819202122
23242526272829
303112345

导航

统计

常用链接

留言簿(54)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜