結合代理模式，分别實作了靜态代理和動态代理，并根據實際的例子仔細分析了java中動态代理原理。
關于Java中的動态代理，我們首先需要了解的是一種常用的設計模式--代理模式，而對于代理，根據建立代理類的時間點，又可以分為靜态代理和動态代理。
一、代理模式
代理模式是常用的java設計模式，他的特征是代理類與委托類有同樣的接口，代理類主要負責為委托類預處理消息、過濾消息、把消息轉發給委托類，以及事後處理消息等。代理類與委托類之間通常會存在關聯關系，一個代理類的對象與一個委托類的對象關聯，代理類的對象本身并不真正實作服務，而是通過調用委托類的對象的相關方法，來提供特定的服務。簡單的說就是，我們在通路實際對象時，是通過代理對象來通路的，代理模式就是在通路實際對象時引入一定程度的間接性，因為這種間接性，可以附加多種用途。在後面我會
解釋這種間接性帶來的好處。代理模式結構圖（圖檔來自《大話設計模式》）：
二、靜态代理
1、靜态代理
靜态代理：由程式員建立或特定工具自動生成源代碼，也就是在編譯時就已經将接口，被代理類，代理類等确定下來。在程式運作之前，代理類的.class檔案就已經生成。
2、靜态代理簡單實作
根據上面代理模式的類圖，來寫一個簡單的靜态代理的例子。我這兒舉一個比較粗糙的例子，假如一個班的同學要向老師交班費，但是都是通過班長把自己的錢轉交給老師。這裡，班長就是代理學生上交班費，
班長就是學生的代理。
首先，我們建立一個Person接口。這個接口就是學生（被代理類），和班長（代理類）的公共接口，他們都有上交班費的行為。這樣，學生上交班費就可以讓班長來代理執行。
/**
* 建立Person接口
* @author Gonjan
*/
public interface Person {
//上交班費
void giveMoney();
} Student類實作Person接口。Student可以具體實施上交班費的動作。
public class Student implements Person {
private String name;
public Student(String name) {
this.name = name;
}
@Override
public void giveMoney() {
System.out.println(name + "上交班費50元");
}
} StudentsProxy類，這個類也實作了Person接口，但是還另外持有一個學生類對象，由于實作了Peson接口，同時持有一個學生對象，那麼他可以代理學生類對象執行上交班費（執行giveMoney()方法）行為。
/**
* 學生代理類，也實作了Person接口，儲存一個學生實體，這樣既可以代理學生産生行為
* @author Gonjan
*
*/
public class StudentsProxy implements Person{
//被代理的學生
Student stu;
public StudentsProxy(Person stu) {
// 隻代理學生對象
if(stu.getClass() == Student.class) {
this.stu = (Student)stu;
}
}
//代理上交班費，調用被代理學生的上交班費行為
public void giveMoney() {
stu.giveMoney();
}
} 下面測試一下，看如何使用代理模式：
public class StaticProxyTest {
public static void main(String[] args) {
//被代理的學生張三，他的班費上交有代理對象monitor（班長）完成
Person zhangsan = new Student("張三");
//生成代理對象，并将張三傳給代理對象
Person monitor = new StudentsProxy(zhangsan);
//班長代理上交班費
monitor.giveMoney();
}
} 運作結果：
這裡并沒有直接通過張三（被代理對象）來執行上交班費的行為，而是通過班長（代理對象）來代理執行了。這就是代理模式。
代理模式最主要的就是有一個公共接口（Person），一個具體的類（Student），一個代理類（StudentsProxy）,代理類持有具體類的執行個體，代為執行具體類執行個體方法。上面說到，代理模式就是在通路實際對象時引入一定程度的間接性，因為這種間接性，可以附加多種用途。這裡的間接性就是指不直接調用實際對象的方法，那麼我們在代理過程中就可以加上一些其他用途。就這個例子來說，加入班長在幫張三上交班費之前想要先反映一下張三最近學習有很大進步，通過代理模式很輕松就能辦到：
public class StudentsProxy implements Person{
//被代理的學生
Student stu;
public StudentsProxy(Person stu) {
// 隻代理學生對象
if(stu.getClass() == Student.class) {
this.stu = (Student)stu;
}
}
//代理上交班費，調用被代理學生的上交班費行為
public void giveMoney() {
System.out.println("張三最近學習有進步！");
stu.giveMoney();
}
} 可以看到，隻需要在代理類中幫張三上交班費之前，執行其他操作就可以了。這種操作，也是使用代理模式的一個很大的優點。最直白的就是在Spring中的面向切面程式設計（AOP），我們能在一個切點之前執行一些操作，在一個切點之後執行一些操作，這個切點就是一個個方法。這些方法所在類肯定就是被代理了，在代理過程中切入了一些其他操作。
三、動态代理
1.動态代理
代理類在程式運作時建立的代理方式被成為動态代理。 我們上面靜态代理的例子中，代理類(studentProxy)是自己定義好的，在程式運作之前就已經編譯完成。然而動态代理，代理類并不是在Java代碼中定義的，而是在運作時根據我們在Java代碼中的“訓示”動态生成的。相比于靜态代理， 動态代理的優勢在于可以很友善的對代理類的函數進行統一的處理，而不用修改每個代理類中的方法。 比如說，想要在每個代理的方法前都加上一個處理方法：
public void giveMoney() {
//調用被代理方法前加入處理方法
beforeMethod();
stu.giveMoney();
} 這裡隻有一個giveMoney方法，就寫一次beforeMethod方法，但是如果出了giveMonney還有很多其他的方法，那就需要寫很多次beforeMethod方法，麻煩。那看看下面動态代理如何實作。
2、動态代理簡單實作
在java的java.lang.reflect包下提供了一個Proxy類和一個InvocationHandler接口，通過這個類和這個接口可以生成JDK動态代理類和動态代理對象。
建立一個動态代理對象步驟，具體代碼見後面：
- 建立一個InvocationHandler對象
//建立一個與代理對象相關聯的InvocationHandler
InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu); - 使用Proxy類的getProxyClass靜态方法生成一個動态代理類stuProxyClass
Class<?> stuProxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class<?>[] {Person.class}); - 獲得stuProxyClass 中一個帶InvocationHandler參數的構造器constructor
Constructor<?> constructor = PersonProxy.getConstructor(InvocationHandler.class); - 通過構造器constructor來建立一個動态執行個體stuProxy
Person stuProxy = (Person) cons.newInstance(stuHandler); 就此，一個動态代理對象就建立完畢，當然，上面四個步驟可以通過Proxy類的newProxyInstances方法來簡化：
//建立一個與代理對象相關聯的InvocationHandler
InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);
//建立一個代理對象stuProxy，代理對象的每個執行方法都會替換執行Invocation中的invoke方法
Person stuProxy= (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler); 到這裡肯定都會很疑惑，這動态代理到底是如何執行的，是如何通過代理對象來執行被代理對象的方法的，先不急，我們先看看一個簡單的完整的動态代理的例子。還是上面靜态代理的例子，班長需要幫學生代交班費。
首先是定義一個Person接口:
/**
* 建立Person接口
* @author Gonjan
*/
public interface Person {
//上交班費
void giveMoney();
} 建立需要被代理的實際類：
public class Student implements Person {
private String name;
public Student(String name) {
this.name = name;
}
@Override
public void giveMoney() {
try {
//假設數錢花了一秒時間
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name + "上交班費50元");
}
}
再定義一個檢測方法執行時間的工具類，在任何方法執行前先調用start方法，執行後調用finsh方法，就可以計算出該方法的運作時間，這也是一個最簡單的方法執行時間檢測工具。
public class MonitorUtil {
private static ThreadLocal<Long> tl = new ThreadLocal<>();
public static void start() {
tl.set(System.currentTimeMillis());
}
//結束時列印耗時
public static void finish(String methodName) {
long finishTime = System.currentTimeMillis();
System.out.println(methodName + "方法耗時" + (finishTime - tl.get()) + "ms");
}
} 建立StuInvocationHandler類，實作InvocationHandler接口，這個類中持有一個被代理對象的執行個體target。InvocationHandler中有一個invoke方法，所有執行代理對象的方法都會被替換成執行invoke方法。
再再invoke方法中執行被代理對象target的相應方法。當然，在代理過程中，我們在真正執行被代理對象的方法前加入自己其他處理。這也是Spring中的AOP實作的主要原理，這裡還涉及到一個很重要的關于java反射方面的基礎知識。
public class StuInvocationHandler<T> implements InvocationHandler {
//invocationHandler持有的被代理對象
T target;
public StuInvocationHandler(T target) {
this.target = target;
}
/**
* proxy:代表動态代理對象
* method：代表正在執行的方法
* args：代表調用目标方法時傳入的實參
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理執行" +method.getName() + "方法");
*/
//代理過程中插入監測方法,計算該方法耗時
MonitorUtil.start();
Object result = method.invoke(target, args);
MonitorUtil.finish(method.getName());
return result;
}
} 做完上面的工作後，我們就可以具體來建立動态代理對象了，上面簡單介紹了如何建立動态代理對象，我們使用簡化的方式建立動态代理對象：
public class ProxyTest {
public static void main(String[] args) {
//建立一個執行個體對象，這個對象是被代理的對象
Person zhangsan = new Student("張三");
//建立一個與代理對象相關聯的InvocationHandler
InvocationHandler stuHandler = new StuInvocationHandler<Person>(zhangsan);
//建立一個代理對象stuProxy來代理zhangsan，代理對象的每個執行方法都會替換執行Invocation中的invoke方法
Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler)；
//代理執行上交班費的方法
stuProxy.giveMoney();
}
} 我們執行這個ProxyTest類，先想一下，我們建立了一個需要被代理的學生張三，将zhangsan對象傳給了stuHandler中，我們在建立代理對象stuProxy時，将stuHandler作為參數了的，上面也有說到所有執行代理對象的方法都會被替換成執行invoke方法，也就是說，最後執行的是StuInvocationHandler中的invoke方法。是以在看到下面的運作結果也就理所當然了。
上面說到，動态代理的優勢在于可以很友善的對代理類的函數進行統一的處理，而不用修改每個代理類中的方法。是因為所有被代理執行的方法，都是通過在InvocationHandler中的invoke方法調用的，是以我們隻要在invoke方法中統一處理，就可以對所有被代理的方法進行相同的操作了。例如，這裡的方法計時，所有的被代理對象執行的方法都會被計時，然而我隻做了很少的代碼量。
動态代理的過程，代理對象和被代理對象的關系不像靜态代理那樣一目了然，清晰明了。因為動态代理的過程中，我們并沒有實際看到代理類，也沒有很清晰地的看到代理類的具體樣子，而且動态代理中被代理對象和代理對象是通過InvocationHandler來完成的代理過程的，其中具體是怎樣操作的，為什麼代理對象執行的方法都會通過InvocationHandler中的invoke方法來執行。帶着這些問題，我們就需要對java動态代理的源碼進行簡要的分析，弄清楚其中緣由。
四、動态代理原理分析
1、Java動态代理建立出來的動态代理類
上面我們利用Proxy類的newProxyInstance方法建立了一個動态代理對象，檢視該方法的源碼，發現它隻是封裝了建立動态代理類的步驟(紅色标準部分)：
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
} 其實，我們最應該關注的是 Class<?> cl = getProxyClass0(loader, intfs);這句，這裡産生了代理類，後面代碼中的構造器也是通過這裡産生的類來獲得，可以看出，這個類的産生就是整個動态代理的關鍵，由于是動态生成的類檔案，我這裡不具體進入分析如何産生的這個類檔案，隻需要知道這個類檔案時緩存在java虛拟機中的，我們可以通過下面的方法将其列印到檔案裡面，一睹真容：
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Student.class.getInterfaces());
String path = "G:/javacode/javase/Test/bin/proxy/StuProxy.class";
try(FileOutputStream fos = new FileOutputStream(path)) {
fos.write(classFile);
fos.flush();
System.out.println("代理類class檔案寫入成功");
} catch (Exception e) {
System.out.println("寫檔案錯誤");
}
對這個class檔案進行反編譯，我們看看jdk為我們生成了什麼樣的内容：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Person;
public final class $Proxy0 extends Proxy implements Person
{
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
/**
*注意這裡是生成代理類的構造方法，方法參數為InvocationHandler類型，看到這，是不是就有點明白
*為何代理對象調用方法都是執行InvocationHandler中的invoke方法，而InvocationHandler又持有一個
*被代理對象的執行個體，不禁會想難道是....？ 沒錯，就是你想的那樣。
*
*super(paramInvocationHandler)，是調用父類Proxy的構造方法。
*父類持有：protected InvocationHandler h;
*Proxy構造方法：
* protected Proxy(InvocationHandler h) {
* Objects.requireNonNull(h);
* this.h = h;
* }
*
*/
public $Proxy0(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
//這個靜态塊本來是在最後的，我把它拿到前面來，友善描述
static
{
try
{
//看看這兒靜态塊兒裡面有什麼，是不是找到了giveMoney方法。請記住giveMoney通過反射得到的名字m3，其他的先不管
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("proxy.Person").getMethod("giveMoney", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
/**
*
*這裡調用代理對象的giveMoney方法，直接就調用了InvocationHandler中的invoke方法，并把m3傳了進去。
*this.h.invoke(this, m3, null);這裡簡單，明了。
*來，再想想，代理對象持有一個InvocationHandler對象，InvocationHandler對象持有一個被代理的對象，
*再聯系到InvacationHandler中的invoke方法。嗯，就是這樣。
*/
public final void giveMoney()
throws
{
try
{
this.h.invoke(this, m3, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
//注意，這裡為了節省篇幅，省去了toString，hashCode、equals方法的内容。原理和giveMoney方法一毛一樣。
} jdk為我們的生成了一個叫$Proxy0（這個名字後面的0是編号，有多個代理類會一次遞增）的代理類，這個類檔案時放在記憶體中的，我們在建立代理對象時，就是通過反射獲得這個類的構造方法，然後建立的代理執行個體。通過對這個生成的代理類源碼的檢視，我們很容易能看出，動态代理實作的具體過程。
我們可以對InvocationHandler看做一個中介類，中介類持有一個被代理對象，在invoke方法中調用了被代理對象的相應方法。通過聚合方式持有被代理對象的引用，把外部對invoke的調用最終都轉為對被代理對象的調用。
代理類調用自己方法時，通過自身持有的中介類對象來調用中介類對象的invoke方法，進而達到代理執行被代理對象的方法。也就是說，動态代理通過中介類實作了具體的代理功能。
五、總結
生成的代理類：$Proxy0 extends Proxy implements Person，我們看到代理類繼承了Proxy類，是以也就決定了java動态代理隻能對接口進行代理，Java的繼承機制注定了這些動态代理類們無法實作對class的動态代理。
上面的動态代理的例子，其實就是AOP的一個簡單實作了，在目标對象的方法執行之前和執行之後進行了處理，對方法耗時統計。Spring的AOP實作其實也是用了Proxy和InvocationHandler這兩個東西的。
後面補充，知其然，還要知其是以然。
------------------------
本文原創，文中若有表述不清或存在問題，歡迎指正。共同學習^_^。 ---2017.4.9
By--- Gonjan
本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段聲明，