1. 代理模式主要有兩種：靜態(tài)代理和動態(tài)代理 

2. 靜態(tài)代理： 

比如要在輸出“HelloWorld”前打印一個字符串“Welcome” 

A:先定義一個接口類 
Java代碼
  1. package ttitfly.proxy;      
  2.      
  3. public interface HelloWorld {      
  4.     public void print();      
  5. //  public void say();      
  6. }   
  7.      
 


B: 定義一個該接口的實現(xiàn)類 

Java代碼
  1. package ttitfly.proxy;      
  2.      
  3. public class HelloWorldImpl implements HelloWorld{      
  4.      
  5.     public void print(){      
  6.         System.out.println("HelloWorld");      
  7.     }      
  8. //  public void say(){      
  9. //      System.out.println("Say Hello!");      
  10. //  }      
  11. }     
 


C:定義一個靜態(tài)代理類 
Java代碼
  1. package ttitfly.proxy;      
  2.      
  3. public class StaticProxy implements HelloWorld{      
  4.      
  5.     public HelloWorld helloWorld ;      
  6.     public StaticProxy(HelloWorld helloWorld){      
  7.         this.helloWorld = helloWorld;      
  8.     }      
  9.           
  10.     public void print(){      
  11.         System.out.println("Welcome");      
  12.         //相當(dāng)于回調(diào)      
  13.         helloWorld.print();      
  14.     }      
  15.           
  16. //  public void say(){      
  17. //      //相當(dāng)于回調(diào)      
  18. //      helloWorld.say();      
  19. //  }      
  20. }      
 


D: 一個測試類: 
   
Java代碼
  1. package ttitfly.proxy;      
  2.      
  3. public class TestStaticProxy {      
  4.      
  5.     public static void main(String[] args){      
  6.         HelloWorld helloWorld = new HelloWorldImpl();      
  7.         StaticProxy staticProxy = new StaticProxy(helloWorld);      
  8.         staticProxy.print();      
  9.               
  10. //      staticProxy.say();      
  11.     }      
  12. }      


可以看出靜態(tài)代理類有一個很不爽的缺點：當(dāng)如果接口加一個方法（把上面所有的代碼的注釋給去掉），所有的實現(xiàn)類和代理類里都需要做個實現(xiàn)。這就增加了代碼的復(fù)雜度。動態(tài)代理就可以避免這個缺點。
靜態(tài)代理的問題：

     1. 一個真實角色必須對應(yīng)一個代理角色，如果大量使用會導(dǎo)致類的急劇膨脹；

     2. 當(dāng)如果接口加一個方法（比如上面的say），所有的實現(xiàn)類和代理類里都需要做個實現(xiàn)。這就增加了代碼的復(fù)雜度;

     3.如果事先并不知道真實角色，該如何使用代理呢？

 

采用動態(tài)解決以上問題。



3 。動態(tài)代理 

動態(tài)代理與普通的代理相比較，最大的好處是接口中聲明的所有方法都被轉(zhuǎn)移到一個集中的方法中處理（invoke），這樣，在接口方法數(shù)量比較多的時候，我們可以進(jìn)行靈活處理，而不需要像靜態(tài)代理那樣每一個方法進(jìn)行中轉(zhuǎn)。 

動態(tài)代理類只能代理接口，代理類都需要實現(xiàn)InvocationHandler類，實現(xiàn)invoke方法。該invoke方法就是調(diào)用被代理接口的所有方法時需要調(diào)用的，該invoke方法返回的值是被代理接口的一個實現(xiàn)類 

代理類： 
      
Java代碼
  1. package ttitfly.proxy;          
  2.          
  3. import java.lang.reflect.InvocationHandler;          
  4. import java.lang.reflect.Method;          
  5. import java.lang.reflect.Proxy;          
  6. //動態(tài)代理類只能代理接口，代理類都需要實現(xiàn)InvocationHandler類，實現(xiàn)invoke方法。該invoke方法就是調(diào)用被代理接口的所有方法時需要調(diào)用的，該invoke方法返回的值是被代理接口的一個實現(xiàn)類          
  7. public class DynamicProxy implements InvocationHandler{          
  8.               
  9.     private Object object;           
  10.     //綁定關(guān)系，也就是關(guān)聯(lián)到哪個接口（與具體的實現(xiàn)類綁定）的哪些方法將被調(diào)用時，執(zhí)行invoke方法。      
  11.     //Proxy.newProxyInstance的第三個參數(shù)是表明這些被攔截的方法執(zhí)行時需要執(zhí)行哪個InvocationHandler的invoke方法      
  12.     public Object bindRelation(Object object){           
  13.         this.object = object;          
  14.         return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);           
  15.     }           
  16.     //攔截關(guān)聯(lián)的這個實現(xiàn)類的方法被調(diào)用時將被執(zhí)行          
  17.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {           
  18.         System.out.println("Welcome");          
  19.         Object result = method.invoke(object, args);           
  20.         return result;          
  21.     }          
  22.          
  23. }          


測試類： 
     
Java代碼
  1. package ttitfly.proxy;          
  2.          
  3. public class TestDynamicProxy {          
  4.     public static void main(String[] args){          
  5.         HelloWorld helloWorld = new HelloWorldImpl();          
  6.         DynamicProxy dp = new DynamicProxy();          
  7.         //在這里綁定的是HelloWorld,也就是HelloWorld是被代理接口。所以綁定關(guān)系時，需要傳遞一個HelloWorld的實現(xiàn)類的實例化對象。          
  8.         HelloWorld helloWorld1 = (HelloWorld)dp.bindRelation(helloWorld);           
  9.         helloWorld1.print();           
  10.         helloWorld1.say();          
  11.               
  12.         //helloWorld2將不被攔截      
  13.         HelloWorld helloWorld2 = new HelloWorldImpl();      
  14.         helloWorld2.print();           
  15.         helloWorld2.say();      
  16.               
  17.     }          
  18. }