Java代理

     代理模式，是GOF中的一种；此模式中主要有client（调用者），proxy（代理），delegate（原对象、委托对象）；client不是对delegate发请求，而是对proxy发请求，proxy内部将责任委托给delegate。一般proxy将一些复杂的操作封装起来，使client可以透明地调用delegate的方法，而无须知道proxy内部的实现细节。

    

     代理模式常见的用法有：远程调用代理（如RMI）、虚代理、计数代理等等。

 

     例如：计数代理

              public interface IOrderManager {

                   void addOrder(Order order);

              }

 

              public class OrderManagerImp implements IOrderManager {

                    public void addOrder(Order order) {

                           // some operation

                    }

              }

 

              public class CountProxy implements IOrderManager {

                   private IOrderManager orderManager;

                   private int count = 0;

                  

                   public CountProxy(IOrderManager orderManager) {

                         this.orderManager = orderManager;

                   }

 

                   public void addOrder(Order order)  {

                        count++;

                        orderManager.addOrder(order);

                   }

              }

             

              public class TestCountProxy {

                  public static void main(String args[]) {

                       // 一些操作，用于注册一些类

                       /*

                            比如：

                            IOrderManager orderMgr = new OrderManagerImp();

                            CountProxy proxy = new CountProxy(orderMgr);

                            Registry.regOrderManager(proxy);

                        */

                       IOrderManager orderManager = Registry.getOrderManager();

                       orderManager.addOrder(...);

                  }

              }

 

 

 在Java中有一种方便的方式实现代理，代码如下：

  public class DynamicProxy {

     public static Object wrapper(Object delegate) {

        return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),

                                                           delegate.getClass().getInterfaces(),

                                                           new DynamicProxyHandler(delegate));

    }

  }

 

  public class DynamicProxyHandler {

      private final Object delegate; //防止被第二次赋值

     

      public DynamicProxyHandler(Object delegate) {

          this.delegate = delegate;

     }

 

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

         // do something

         Object ret = null;

         try {

            ret = method.invoke(delegate, args);  //调用原方法

         } catch (Throwable e) {

                e.printStackTrace();

         }

         // do something

        return ret;

    }

  }