用了一下午的時間把代理又複習了一遍，下面我對有關代理的相關知識做一下總結匯總。主要歸結為以下幾個主要問題：

1、什麼是動態代理?
2、為什麼使用動態代理?
3、使用它有哪些好處?
4、哪些地方需要動態代理?

首先，先來介紹一下代理模式

代理模式是常用的java設計模式，他的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理訊息、過濾訊息、把訊息轉發給委託類，以及事後處理訊息等。代理類與委託類之間通常會存在關聯關係，一個代理類的物件與一個委託類的物件關聯，代理類的物件本身並不真正實現服務，而是通過呼叫委託類的物件的相關方法，來提供特定的服務。

按照代理的建立時期，代理類可以分為兩種。 

動態代理： 

和動態代理有關的有兩個類
1.interface InvocationHandler
Object invoke(Object proxy, Method method, Object[] args)

2.class Proxy
真正表示動態代理的類，提供兩個靜態方法:

Class<?> getProxyClass(ClassLoader loader, Class<?>[] interface)

看完與動態代理有關的兩個類後，大致明白動態代理的含義：

A介面有c方法，類B實現A介面，原本應該是執行B類中的c方法，現在可以不這樣做；

下面是根據對動態代理的理解所畫出的一個原理圖 ：

動態代理事例：
 

package proxy;

public interface Hello {
	//打招呼
	void sayHello(String str);  
	//列印輸出
	void print(String str); 
}

它的實現類：

package proxy;

public class HelloImpl implements Hello {

	@Override
	public void sayHello(String str) {
		// TODO Auto-generated method stub
		System.out.println("Say hello to" + str);
	}

	@Override
	public void print(String str) {
		// TODO Auto-generated method stub
		System.out.println("Print:" + str);
	}
}

下面生成與代理類相關聯的InvocationHandler物件 ：

package proxy;

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

public class LogHandler implements InvocationHandler {
	private Object obj; 
	
	public LogHandler(Object obj) {  
		this.obj= obj;  
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		doBefore();  
		//在這裡可以做任何事情
		Object result = method.invoke(obj, args);  
		after();  
		return result;
	}
	
	private void doBefore() {  
		System.out.println("...before...");  
	}  
	
	private void after() {  
		System.out.println("...after...");  
	}  
}

最後編寫一個測試類，程式碼如下：

package proxy;

import java.lang.reflect.Proxy;

public class ProxyTest {

    public static void main(String[] args) {
        HelloImpl impl = new HelloImpl();
        LogHandler handler = new LogHandler(impl);
        //這裡把handler與impl新生成的代理類相關聯
        Hello hello = (Hello) Proxy.newProxyInstance(impl.getClass().getClassLoader(), 
        		impl.getClass().getInterfaces(), handler);
        
        //這裡無論訪問哪個方法，都是會把請求轉發到handler.invoke
        hello.print("正在測試");
        hello.sayHello("Chu");
    }

}

【執行結果】如下：

...before...
Print:正在測試
...after...
...before...
Say hello toChu
...after...

最後我們來回答本文開始時提出的幾個總結性問題:

1、什麼是動態代理?
一種用於轉發請求，進行特殊處理的機制，“動態”應該指的是“執行期”。

2、為什麼使用動態代理?
可以對請求進行任何處理(如事務，日誌等，這都是網上說的，我當然可以做任何處理) ；動態代理類的位元組碼在程式執行時由Java反射機制動態生成，無需程式設計師手工編寫它的原始碼。動態代理類不僅簡化了程式設計工作，而且提高了軟體系統的可擴充套件性，因為Java 反射機制可以生成任意型別的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。

3、使用它有哪些好處?
可以對請求進行任何處理(如事務，日誌等，這都是網上說的，我當然可以做任何處理) ；與靜態代理類對照的是動態代理類，動態代理類的位元組碼在程式執行時由Java反射機制動態生成，無需程式設計師手工編寫它的原始碼。動態代理類不僅簡化了程式設計工作，而且提高了軟體系統的可擴充套件性，因為Java 反射機制可以生成任意型別的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。

4.哪些地方需要，動態代理?
不允許直接訪問某些類；對訪問要做特殊處理的時候就要用到代理。

 最後的總結：

1、如果想宣告產生B類的代理類，那個B類必須要實現介面，如果沒有介面，代理類就不能偽裝成B類的“兄弟”，也就沒有存在的意思， 其實也可以偽裝成B類的“孩子”。

2、當請求代理類的方法時，這個請求會被轉到執行與代理類關聯InvocationHandler
的invoke方法。

InvocationHandler可以這樣理解:
它用來處理方法的呼叫，實現類也有同樣的意義；與代理類物件相關聯，它就是負責處理代理類應該有的動作，把所有的方法請求分發到 invoke 這個方法上。

由Proxy類的靜態方法建立的動態代理類具有以下特點：

動態代理類是public、final和非抽象型別的；
動態代理類繼承了java.lang.reflect.Proxy類；
動態代理類的名字以“$Proxy”開頭；
動態代理類實現 getProxyClass() 和 newProxyInstance() 方法中引數 interfaces 指定的所有介面；

Proxy 類的isProxyClass(Class<?> cl)靜態方法可用來判斷引數指定的類是否為動態代理類。只有通過Proxy類建立的類才是動態代理類；

動態代理類都具有一個public 型別的構造方法，該構造方法有一個InvocationHandler 型別的引數。

由Proxy類的靜態方法建立的動態代理類的例項具有以下特點：

1、假定變數foo 是一個動態代理類的例項，並且這個動態代理類實現了Foo 介面，那麼“foo instanceof Foo”的值為true。把變數foo強制轉換為Foo型別是合法的：
(Foo) foo //合法

2、每個動態代理類例項都和一個InvocationHandler 例項關聯。Proxy 類的getInvocationHandler(Object proxy)靜態方法返回與引數proxy指定的代理類例項所關聯的InvocationHandler 物件。

3、假定Foo介面有一個amethod()方法，那麼當程式呼叫動態代理類例項foo的amethod()方法時，該方法會呼叫與它關聯的InvocationHandler 物件的invoke()方法。

InvocationHandler 介面為方法呼叫介面，它聲明瞭負責呼叫任意一個方法的invoke()方法：
Object invoke(Object proxy,Method method,Object[] args) throws Throwable

引數proxy指定動態代理類例項，引數method指定被呼叫的方法，引數args 指定向被呼叫方法傳遞的引數，invoke()方法的返回值表示被呼叫方法的返回值。