设计模式2—Proxy设计模式

Proxy代理设计模式是一种控制对象访问的设计模式，类似于网络代理，网络代理机制如下图：

客户端——代理服务器——目标资源

Proxy代理设计模式机制如下：

客户端查询——代理程序——目标程序

代理模式UML图如下：

 

代理模式顺序图如下：

客户端程序通过代理查询访问真正的目标程序，代理查询对外隐藏了目标程序。普通代理设计模式列子代码如下：

interface ProxyBase{

 public void f();

 public void g();

 public void h();

}

//代理程序

class Proxy implement ProxyBase(){

   private ProxyBase implementation;

   public Proxy(){

      //目标程序

      implementation = new ProxyImplementation();

 }

 public void f(){

       implementation.f();

 }

 public void g(){

    implementation.g()

 }

 public void h(){

   implementation.h();

 }

//目标程序

clcass ProxyImplementation implements ProxyBase{

      public void f(){

           System.out.println("ProxyImlementation.f()");

      }

     public void g(){

            System.out.println("ProxyImplementation.g()");

     }

    public void h(){

          System.out.println("ProxyImplementation.h()");

    }

}

//客户端程序调用代理

public class ProxyDemo {

    public static void main(String[] args){

          //客户端调用代理程序

           Proxy p = new Proxy();

           p.f();

           p.g();

           p.h();

     }

}

从JDK1.3以后，java引入了动态代理机制，java的动态代理只能针对接口进行动态代理，即要实现动态代理的类必须实现接口，CGLIB提供了针对类的动态代理功能。JDK动态代理的例子如下：

//代理接口

interface Foo{

   public void f(String s);

   public void g(int i);

   public void h(int i,String s);

}

//接口实现类，即被代理类

class FooImpl implements Foo{

    public void f(String s){

            System.out.println("FooImpl.f(),s=" + s);

    }

    public void g(int i){

          System.out.println("FooImpl.g(),i=" + i);

   }

   public void h(int i,String s) {

      System.out.println("FooImpl.h(),i=" + i + ",s=" + s);

  }

}

//动态代理处理类

class ProxyHandler implements InvocationHandler {

   //代理实现类

   private Object delegate;

      public ProxyHandler(Object obj) {

           delegate = obj;

      }

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

              System.out.println("Before method:" + method);

               method.invoke(this.delegate,args);

              System.out.println("After method:" + method);

              return null;

          }

     }

   public class DynamicProxyDemo{

         public static void main(String[] args){

               Foo foo = new FooImpl();

               ProxyHandler handler = new ProxyHandler(foo);

               //产生动态代理

               Foo proxy = (Foo)Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[]{Foo.class},handler);

               proxy.f("f");

               proxy.g(1);

               proxy.h("h",2);

    }

}

动态代理好普通代理的区别：动态代理中的代理类是由java.lang.reflect.Proxy类在运行期间根据接口定义，采用java反射功能动态生成的。和java.lang.reflect.InvocationHandler结合，可以加强现有类的方法实现。动态代理自定义Handler实现InvocationHandler接口，自定义Handler实例化时，将代理的实现类传入自定义Handler对象中。自定义Handler需要实现invoke方法，该方法可以使用java反射调用实现类的实现的方法，同时当然可以实现其他功能，例如在调用实现类方法前后加入Log，实现安全认证等。而Proxy类根据Handler和需要代理的接口动态生成一个接口实现类的对象。当用户调用这个动态生成的实现类时，实际上是调用了自定义Handler的invoke方法。