代理模式与动态代理模式

代理模式与动态代理模式

1、代理模式

所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用。
代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

生活中的例子：过年加班比较忙，没空去买火车票，这时可以打个电话到附近的票务中心，叫他们帮你买张回家的火车票，当然这会附加额外的劳务费。但要清楚票务中心自己并不卖票，只有火车站才真正卖票，票务中心卖给你的票其实是通过火车站实现的。这点很重要！

上面这个例子，你就是“客户”，票务中心就是“代理角色”，火车站是“真实角色”，卖票称为“抽象角色”！

代理模式JAVA代码示例：
 1//抽象角色：抽象类或接口
 2 interface  Business
 3 {
 4    void doAction();
 5 }
 6// 真实角色：真正实现了业务逻辑接口
 7class  BusinessImpl implements Business
 8 {
 9    public void doAction()
10     {
11        System.out.println( "真实角色中的方法被执行！");
12    }
13}
14//代理角色：自己并未实现业务逻辑接口，而是调用真实角色来实现
15class  BusinessImplProxy implements Business
16 {
17     private  BusinessImpl bi;
18     public void doAction()
19     {
20        if (bi==null )
21         {
22            bi  = new BusinessImpl();
23        }
24        doBefore();
25        bi.doAction();
26        doAfter();
27    }
28    public  void doBefore()
29     {
30        System.out.println( "前置处理！");
31     }
32    public  void doAfter()
33     {
34        System.out.println( "后置处理！");
35    }
36}
37//测试类
38class  Test
39 {
40    public  static  void  main(String[] args)
41     {
42        //引用变量定义为抽象角色类型
43        Business bi  = new  BusinessImplProxy();
44        bi.doAction();
45    }
46}
47
代理模式允许使用抽象类或接口作为“抽象角色”，每个“代理角色”代理了一个“真实角色”，如果要代理的“真实角色”比较多，这势必造成大量的“代理角色”造成代码的急剧膨胀，其实其内部结构都是类似的，要是在运行时能动态生成“代理角色”就好了。

2、JAVA中的动态代理模式

从JDK1.3开始，java中引入了动态代理机制。相关的接口或类有如下两个：InvocationHandler和Proxy，都位于java.lang.reflect包下
InvocationHandler接口只定义了一个抽象方法：
        Object invoke(Object proxy, Method method, Object[] args)
Proxy类中主要的2个静态方法：
        Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) 
        Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
        getProxyClass返回一个动态创建的代理类(Class)，newProxyInstance则返回改代理类的实例(Object)。

所以，借助于JVM的支持，可以在运行时动态生成代理类（“代理角色”），我们就可以解决上述代理模式中代码膨胀的问题，使用了动态代理后，“代理角色”将不用手动生成，而由JVM在运行时，通过指定类加载器、接口数组、调用处理程序这3个参数来动态生成。

动态代理模式JAVA代码示例：
 1import java.lang.reflect.InvocationHandler;
 2import java.lang.reflect.Proxy;
 3import java.lang.reflect.Method;
 4//抽象角色：java动态代理的实现目前只支持接口，不支持抽象类
 5interface  BusinessFoo
 6 {
 7    void foo();
 8}
 9interface BusinessBar
10 {
11    String bar(String message);
12}
13//真实角色：真正实现业务逻辑方法
14class BusinessFooImpl  implements BusinessFoo
15 {
16    public  void foo()
17     {
18        System.out.println(" BusinessFooImpl.foo()");
19    }
20}
21class BusinessBarImpl  implements BusinessBar
22 {
23    public String bar(String message)
24     {
25        System.out.println(" BusinessBarImpl.bar()");
26        return message;
27     }
28}
29//动态角色：动态生成代理类
30class BusinessImplProxy  implements InvocationHandler
31 {
32    private Object obj;
33    BusinessImplProxy()  {
34    }
35    BusinessImplProxy(Object obj)  {
36        this.obj  = obj;
37    }
38    public Object invoke(Object proxy,Method method,Object[] args)  throws Throwable
39     {
40        Object result =  null;
41        doBefore();
42        result =  method.invoke(obj,args);
43         doAfter();
44        return result;
45    }
46     public void doBefore() {
47        System.out.println(" do something before Business Logic");
48    }
49     public void doAfter() {
50        System.out.println(" do something after Business Logic");
51    }
52    public  static Object factory(Object obj)
53     {
54        Class cls =  obj.getClass();
55         return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), new  BusinessImplProxy(obj));
56    }
57}
58// 测试类
59public class  DynamicProxy
60 {    
61    public  static void  main(String[] args)  throws  Throwable
62     {
63        BusinessFooImpl bfoo =  new BusinessFooImpl();
64        BusinessFoo bf =  (BusinessFoo)BusinessImplProxy.factory(bfoo);
65         bf.foo();
66        System.out.println();
67        
68        BusinessBarImpl bbar =  new BusinessBarImpl();
69        BusinessBar bb =  (BusinessBar)BusinessImplProxy.factory(bbar);
70        String message  = bb.bar( "Hello,World ");
71        System.out.println(message);
72    }
73}
程序流程说明：
       new BusinessFooImpl();创建一个“真实角色”，传递给工厂方法BusinessImplProxy.factory()，进而初始化“调用处理器”——即实现InvocationHandler的类。并返回一个动态创建的代理类实例，由于“代理角色”也必然实现了“抽象角色”提供的业务逻辑方法，故可向下转型为BusinessBar，并赋值给指向BusinessBar类型的引用bb。
       newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)方法由程序员来指定参数动态返回需要的代理类，而invoke(Object proxy, Method method, Object[] args) 方法则是由JVM在运行时动态调用的。当执行“bb.bar("Hello,World");”方法时，JVM动态指派“调用处理器”，向外层invoke传递参数，并调用method.invoke(obj,args)真正执行！

BusinessImplProxy.Factory静态方法用来动态生成代理类（“代理角色”），在运行时根据不同的业务逻辑接口BusinessFoo和BusinessBar，在运行时分别动态生成了代理角色。“抽象角色”、“代理角色”以及调用处理器（实现InvocationHandler接口的类）这三者都可以改变，所以说JAVA的动态代理十分强大。

posted on 2008-01-04 21:02 菜园小鸟 阅读(7265) 评论(1)  编辑  收藏