代理模式(proxy)

1、代理模式

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。

在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式一般涉及到的角色有：
抽象角色：声明真实对象和代理对象的共同接口。
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在                   执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

 /*
 *抽象角色
 */
 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();
     }
 }

2、动态代理

 /*
 *抽象角色
 */
 package dynamicproxy;

 public interface Subject
 {
     public void request();
 }

 /*
 *真实角色
 */
 package dynamicproxy;

 public class RealSubject implements Subject
 {
     public void request()
     {
         System.out.println("From real subject!");
     }

 }

 package dynamicproxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;

 /**
  * 该代理类的内部属性是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);

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

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

         return null;
     }
 }

 package dynamicproxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Proxy;

 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(classType
                 .getClassLoader(), realSubject.getClass().getInterfaces(),
                 handler);

         subject.request();

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

     }
 }