JAVA代理模式

 JAVA代理模式的一个例子

//代理角色：
public class ProxySubject extends Subject{
      private RealSubject realSubject; //以真实角色作为代理角色的属性 
       public ProxySubject(){
       } 
      public void request(){ //该方法封装了真实对象的request方法 
          preRequest(); 
          if( realSubject == null ){
                realSubject = new RealSubject();
          }
          realSubject.request(); //此处执行真实对象的request方法 
            postRequest(); 
       }
      private void preRequest(){ 
       //something you want to do before requesting 
      }
      private void postRequest(){ 
      //something you want to do after requesting 
      }
      public static void main(String[] args) {
    	//客户端调用：
    	  Subject sub=new ProxySubject();
    	  sub.request(); 
	}
}

//抽象角色：
abstract  class Subject{      
      abstract public void request();
}

//真实角色：实现了Subject的request()方法。
class RealSubject extends Subject{
      public RealSubject(){ 
      }
      public void request(){
            System.out.println("From real subject.");
      }
} 

这里是UML图

JDK里面也有一套现在的代理机制.

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Client{ 
	static public void main(String[] args) throws Throwable {
		// 被代理的对象(RealSubject)可以在运行时动态改变，
		// 需要控制的接口(Subject接口)可以在运行时改变，
		// 控制的方式(DynamicSubject类)也可以动态改变，
		// 从而实现了非常灵活的动态代理关系
	   
   RealSubject2 rs = new RealSubject2(); //在这里指定被代理类
   InvocationHandler ds = new DynamicSubject(rs); //初始化代理类
   Class cls = rs.getClass();
   //以下是分解步骤
   /*
   Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces());
   Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});
   Subject subject =(Subject) ct.newInstance(new Object[]{ds});
*/

//以下是一次性生成

   Subject2 subject = (Subject2) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),ds);
   subject.request();
}
}

class DynamicSubject implements InvocationHandler{
    private Object sub; 
    public DynamicSubject(Object sub){            
          this.sub = sub;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before calling " + method); 
        method.invoke(sub,args);    //sub是实际的被代理对象,args是被代理对象方法的参数
        System.out.println("after calling " + method); 
        return null; 
    }
}

//抽象角色(之前是抽象类，此处应改为接口)：
interface Subject2{
      public void request();
}  

//具体角色RealSubject：实现了Subject接口的request()方法。
class RealSubject2 implements Subject2{ 
      public RealSubject2(){

      }
      public void request(){ 
            System.out.println("From real subject."); 
      } 
}

 以后有用上了研究一下它的实现机制,现在暂时留个印象