代理模式中的两种代理：静态代理和动态代理

 

//静态代理模式

//其实这个可以是个接口，房地产开发商

public abstract class Subject

{

       public abstract void request();

}

 

//购房的房主，真实对象

public class RealSubject extends Subject

{

       public void request()

       {

              System.out.println("From real subject.");

       }

}

 

//代理对象，中介

public class ProxySubject extends Subject

{

       private RealSubject realSubject; //代理角色内部引用了真实角色

      

       public void request()

       {

              this.preRequest(); //在真实角色操作之前所附加的操作

             

              if(null == realSubject)

              {

                     realSubject = new RealSubject();

              }

             

              realSubject.request(); //真实角色所完成的事情

             

              this.postRequest(); //在真实角色操作之后所附加的操作

       }

      

       private void preRequest()

       {

              System.out.println("pre request");

       }

      

       private void postRequest()

       {

              System.out.println("post request");

       }

}

 

 

//客户端使用

public class Client

{

       public static void main(String[] args)

       {

              Subject subject = new ProxySubject();

             

              subject.request();

       }

}

 

输出结果：

pre request

From real subject

post request

 

 

 

//动态代理模式

//这里必须是接口，因为在代理对象中实例化参数是接口数组

public interface Subject

{

       public void request();

}

//真实对象，购房者

public class RealSubject implements Subject

{

       public void request()

       {

              System.out.println("From real subject!");

       }

 

}

 

 

/**

 * 该代理类的内部属性是Object类型，实际使用的时候通过该类的构造方法传递进来一个对象

 * 此外，该类还实现了invoke方法，该方法中的method.invoke其实就是调用被代理对象的将要

 * 执行的方法，方法参数是sub，表示该方法从属于sub，通过动态代理类，我们可以在执行真实对象的方法前后

 * 加入自己的一些额外方法。

 *

 */

//动态代理

public class DynamicSubject implements InvocationHandler

{

       private Object sub;

      

       public DynamicSubject(Object obj)

       {

              this.sub = obj;

       }

      

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

                     throws Throwable

       {

              System.out.println("before calling: " + method);

             

              method.invoke(sub, args);//其实这个method就是class对象下的request()方法，调用了真实对象下的request（）方法，参数new Object[]{}是null空的。

             

              System.out.println(args == null);

             

              System.out.println("after calling: " + method);

             

              return null;

       }

      

      

}

 

//客户端

public class Client

{

       public static void main(String[] args)

       {

              RealSubject realSubject = new RealSubject();

 

              InvocationHandler handler = new DynamicSubject(realSubject);

 

              Class<?> classType = handler.getClass();

 

              // 下面的代码一次性生成代理

 

              Subject subject = (Subject) Proxy.newProxyInstance(realSubject

                            .getClassLoader(), realSubject.getClass().getInterfaces(),

                            handler);//实例化一个代理出来，每一个代理实例都会有一个相应的handler处理里面的invoke方法

 

              subject.request();//这个subject的实例是$Proxy0代理

 

              System.out.println(subject.getClass());

 

       }

      

      

       另外一种动态代理的表示形式：

public class VectorProxy implements InvocationHandler

{

       private Object proxyObj;

 

       public VectorProxy(Object obj)

       {

              this.proxyObj = obj;

       }

 

       public static Object factory(Object obj)

       {

              Class<?> classType = obj.getClass();

 

              return Proxy.newProxyInstance(classType.getClassLoader(),

                            classType.getInterfaces(), new VectorProxy(obj));

       }

      

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

                     throws Throwable

       {

              System.out.println("before calling: " + method);

             

              if(null != args)

              {

                     for(Object obj : args)

                     {

                            System.out.println(obj);

                     }

              }

             

              Object object = method.invoke(proxyObj, args);

             

              System.out.println("after calling: " + method);

             

              return object;

       }

      

       public static void main(String[] args)

       {

              List v = (List)factory(new Vector());

             

              System.out.println(v.getClass().getName());

             

              v.add("New");

              v.add("York");

             

              System.out.println(v);

             

              v.remove(0);

              System.out.println(v);

             

       }