Java代理模式

、代理模式

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

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

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


代理模式JAVA代码示例:
 //抽象角色:抽象类或接口

  1. interface Business  
  2. {  
  3.     void doAction();  
  4. }  

 //真实角色:真正实现了业务逻辑接口

//代理角色:自己并未实现业务逻辑接口,而是调用真实角色来实现
  1. class BusinessImplProxy implements Business  
  2. {  
  3.     private BusinessImpl bi;  
  4.     public void doAction()  
  5.     {  
  6.         if (bi==null)  
  7.         {  
  8.             bi = new BusinessImpl();  
  9.         }  
  10.         doBefore();  
  11.         bi.doAction();  
  12.         doAfter();  
  13.     }  
  14.     public void doBefore()  
  15.     {  
  16.         System.out.println("前置处理!");  
  17.     }  
  18.     public void doAfter()  
  19.     {  
  20.         System.out.println("后置处理!");  
  21.     }  
  22. }  
  23. //测试类  
  24. class Test  
  25. {  
  26.     public static void main(String[] args)  
  27.     {  
  28.         //引用变量定义为抽象角色类型  
  29.         Business bi = new BusinessImplProxy();  
  30.         bi.doAction();  
  31.     }  
  32. }  

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

动态代理模式JAVA代码示例:

  1. import java.lang.reflect.InvocationHandler;  
  2.  import java.lang.reflect.Proxy;  
  3.  import java.lang.reflect.Method;  
  4.  //抽象角色:java动态代理的实现目前只支持接口,不支持抽象类  
  5.  interface BusinessFoo  
  6.  {  
  7.      void foo();  
  8.  }  
  9.  interface BusinessBar  
  10. {  
  11.     String bar(String message);  
  12. }  
  13. //真实角色:真正实现业务逻辑方法  
  14. class BusinessFooImpl implements BusinessFoo  
  15. {  
  16.     public void foo()  
  17.     {  
  18.         System.out.println("BusinessFooImpl.foo()");  
  19.     }  
  20. }  
  21. class BusinessBarImpl implements BusinessBar  
  22. {  
  23.     public String bar(String message)  
  24.     {  
  25.         System.out.println("BusinessBarImpl.bar()");  
  26.         return message;  
  27.     }  
  28. }  
  29. //动态角色:动态生成代理类  
  30. class 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. //测试类  
  59. public 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的动态代理十分强大。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值