http://www.cnblogs.com/zuoxiaolong/p/pattern3.html

作者：zuoxiaolong8810（左瀟龍），轉(zhuǎn)載請注明出處，特別說明：本博文來自博主原博客，為保證新博客中博文的完整性，特復(fù)制到此留存，如需轉(zhuǎn)載請注明新博客地址即可。

? ? ? ? ? ? ? ?我特意將本系列改了下名字，原名是《設(shè)計模式學(xué)習之路》，原因是因為之前寫過一篇《spring源碼學(xué)習之路》，但是我感覺本次寫二十三種設(shè)計模式，更多的還是分享給各位自己的理解，所以感覺學(xué)習之路有點不合適，另外，從本章開始，正式啟用本人稱呼，LZ。

? ? ? ? ? ? ? ?好了，廢話至此，本章接著討論第二種要介紹的設(shè)計模式，代理模式。

? ? ? ? ? ? ? ?LZ不希望寫的東西與網(wǎng)絡(luò)上的資料千篇一律，所以這一系列不會像很多典型文章一章，只是列出這個模式的定義以及一堆適用的情況，然后就是一堆這個模式的各個角色，對于這種羅列LZ并不反對，相比之下會比較清晰，但是如果脫離了實際，就會導(dǎo)致看的人特別是初學(xué)者覺得設(shè)計模式很陌生很遙遠。

? ? ? ? ? ? ? ?LZ并不反對這種教學(xué)式的標準模式，但說實話，LZ本人看這種帖子從來都感覺收獲不大，看一遍看一遍，到現(xiàn)在都沒記住那些各個適用的情況與一堆亂七八糟的角色。

? ? ? ? ? ? ? ?所以LZ探討代理模式，不會再按這個步驟進行，而是跟著自己的思維進行。

? ? ? ? ? ? ? ?首先代理模式，可以分為兩種，一種是靜態(tài)代理，一種是動態(tài)代理。

? ? ? ? ? ? ? ?兩種代理從虛擬機加載類的角度來講，本質(zhì)上都是一樣的，都是在原有類的行為基礎(chǔ)上，加入一些多出的行為，甚至完全替換原有的行為。

? ? ? ? ? ? ? ?靜態(tài)代理采用的方式就是我們手動的將這些行為換進去，然后讓編譯器幫我們編譯，同時也就將字節(jié)碼在原有類的基礎(chǔ)上加入一些其他的東西或者替換原有的東西，產(chǎn)生一個新的與原有類接口相同卻行為不同的類型。

? ? ? ? ? ? ? ?說歸說，我們來真實的去試驗一下，實驗的話需要找一個示例，就拿我們的數(shù)據(jù)庫連接來做例子吧。

? ? ? ? ? ? ? ?我們都知道，數(shù)據(jù)庫連接是很珍貴的資源，頻繁的開關(guān)數(shù)據(jù)庫連接是非常浪費服務(wù)器的CPU資源以及內(nèi)存的，所以我們一般都是使用數(shù)據(jù)庫連接池來解決這一問題，即創(chuàng)造一堆等待被使用的連接，等到用的時候就從池里取一個，不用了再放回去，數(shù)據(jù)庫連接在整個應(yīng)用啟動期間，幾乎是不關(guān)閉的，除非是超過了最大閑置時間。

? ? ? ? ? ? ? ?但是在程序員編寫程序的時候，會經(jīng)常使用connection.close()這樣的方法，去關(guān)閉數(shù)據(jù)庫連接，而且這樣做是對的，所以你并不能告訴程序員們說，你們使用連接都不要關(guān)了，去調(diào)用一個其他的類似歸還給連接池的方法吧。這是不符合程序員的編程思維的，也很勉強，而且具有風險性，因為程序員會忘的。

? ? ? ? ? ? ? ?解決這一問題的辦法就是使用代理模式，因為代理模式可以替代原有類的行為，所以我們要做的就是替換掉connection的close行為。

? ? ? ? ? ? ? ?下面是connection接口原有的樣子，我去掉了很多方法，因為都類似，全貼上來占地方。

import java.sql.SQLException; import java.sql.Statement; import java.sql.Wrapper;public interface Connection extends Wrapper {Statement createStatement() throws SQLException;void close() throws SQLException;}

? ? ? ? ? ? ? 這里只貼了兩個方法，但是我們代理的精髓只要兩個方法就能掌握，下面使用靜態(tài)代理，采用靜態(tài)代理我們通常會使用組合的方式，為了保持對程序猿是透明的，我們實現(xiàn)Connection這個接口，?如下所示。

import java.sql.SQLException; import java.sql.Statement;public class ConnectionProxy implements Connection{private Connection connection;public ConnectionProxy(Connection connection) {super();this.connection = connection;}public Statement createStatement() throws SQLException{return connection.createStatement();}public void close() throws SQLException{System.out.println("不真正關(guān)閉連接，歸還給連接池");}}

? ? ? ? ? ? ? ? 我們在構(gòu)造方法中讓調(diào)用者強行傳入一個原有的連接，接下來我們將我們不關(guān)心的方法，交給真正的Connection接口去處理，就像createStatement方法一樣，而我們將真正關(guān)心的close方法用我們自己希望的方式去進行。

? ? ? ? ? ? ? ? 此處為了更形象，LZ給出一個本人寫的非常簡單的連接池，意圖在于表明實現(xiàn)的思路。下面我們來看一下連接池的變化，在里面注明了變化點。

import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.LinkedList;public class DataSource {private static LinkedList<Connection> connectionList = new LinkedList<Connection>();static{try {Class.forName("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) {e.printStackTrace();}}private static Connection createNewConnection() throws SQLException{return DriverManager.getConnection("url","username", "password");}private DataSource(){if (connectionList == null || connectionList.size() == 0) {for (int i = 0; i < 10; i++) {try {connectionList.add(createNewConnection());} catch (SQLException e) {e.printStackTrace();}}}}public Connection getConnection() throws Exception{if (connectionList.size() > 0) {//return connectionList.remove(); 這是原有的方式，直接返回連接，這樣可能會被程序員把連接給關(guān)閉掉//下面是使用代理的方式，程序員再調(diào)用close時，就會歸還到連接池return new ConnectionProxy(connectionList.remove());}return null;}public void recoveryConnection(Connection connection){connectionList.add(connection);}public static DataSource getInstance(){return DataSourceInstance.dataSource;}private static class DataSourceInstance{private static DataSource dataSource = new DataSource();}}

? ? ? ? ? ? ? ?連接池我們把它做成單例，所以假設(shè)是上述連接池的話，我們代理中的close方法可以再具體化一點，就像下面這樣，用歸還給連接池的動作取代關(guān)閉連接的動作。

public void close() throws SQLException{DataSource.getInstance().recoveryConnection(connection);}

? ? ? ? ? ? ? ?好了，這下我們的連接池返回的連接全是代理，就算程序員調(diào)用了close方法也只會歸還給連接池了。

? ? ? ? ? ? ? ?我們使用代理模式解決了上述問題，從靜態(tài)代理的使用上來看，我們一般是這么做的。

? ? ? ? ? ? ? ?1，代理類一般要持有一個被代理的對象的引用。

? ? ? ? ? ? ? ?2，對于我們不關(guān)心的方法，全部委托給被代理的對象處理。

? ? ? ? ? ? ? ?3，自己處理我們關(guān)心的方法。

? ? ? ? ? ? ? ?這種代理是死的，不會在運行時動態(tài)創(chuàng)建，因為我們相當于在編譯期，也就是你按下CTRL+S的那一刻，就給被代理的對象生成了一個不可動態(tài)改變的代理類。

? ? ? ? ? ? ? ?靜態(tài)代理對于這種，被代理的對象很固定，我們只需要去代理一個類或者若干固定的類，數(shù)量不是太多的時候，可以使用，而且其實效果比動態(tài)代理更好，因為動態(tài)代理就是在運行期間動態(tài)生成代理類，所以需要消耗的時間會更久一點。就像上述的情況，其實就比較適合使用靜態(tài)代理。

? ? ? ? ? ? ? ?下面介紹下動態(tài)代理，動態(tài)代理是JDK自帶的功能，它需要你去實現(xiàn)一個InvocationHandler接口，并且調(diào)用Proxy的靜態(tài)方法去產(chǎn)生代理類。

? ? ? ? ? ? ? ?接下來我們依然使用上面的示例，但是這次該用動態(tài)代理處理，我們來試一下看如何做。

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.sql.Connection;public class ConnectionProxy implements InvocationHandler{private Connection connection;public ConnectionProxy(Connection connection) {super();this.connection = connection;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//這里判斷是Connection接口的close方法的話if (Connection.class.isAssignableFrom(proxy.getClass()) && method.getName().equals("close")) {//我們不執(zhí)行真正的close方法//method.invoke(connection, args);//將連接歸還連接池 DataSource.getInstance().recoveryConnection(connection);return null;}else {return method.invoke(connection, args);}}public Connection getConnectionProxy(){return (Connection) Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Connection.class}, this);}}

? ? ? ? ? ? ? ?上面是我們針對connection寫的動態(tài)代理，InvocationHandler接口只有一個invoke方法需要實現(xiàn)，這個方法是用來在生成的代理類用回調(diào)使用的，關(guān)于動態(tài)代理的原理一會做詳細的分析，這里我們先只關(guān)注用法。很顯然，動態(tài)代理是將每個方法的具體執(zhí)行過程交給了我們在invoke方法里處理。而具體的使用方法，我們只需要創(chuàng)造一個ConnectionProxy的實例，并且將調(diào)用getConnectionProxy方法的返回結(jié)果作為數(shù)據(jù)庫連接池返回的連接就可以了。

? ? ? ? ? ? ? ?上述便是我們針對connection做動態(tài)代理的方式，但是我們從中得不到任何好處，除了能少寫點代碼以外，因為這個動態(tài)代理還是只能代理Connection這一個接口，如果我們寫出這種動態(tài)代理的方式的話，說明我們應(yīng)該使用靜態(tài)代理處理這個問題，因為它代表我們其實只希望代理一個類就好。從重構(gòu)的角度來說，其實更簡單點，那就是在你發(fā)現(xiàn)你使用靜態(tài)代理的時候，需要寫一大堆重復(fù)代碼的時候，就請改用動態(tài)代理試試吧。

? ? ? ? ? ? ? ?通常情況下，動態(tài)代理的使用是為了解決這樣一種問題，就是我們需要代理一系列類的某一些方法，最典型的應(yīng)用就是我們前段時間討論過的springAOP，我們需要創(chuàng)造出一批代理類，切入到一系列類當中的某一些方法中。下面給出一個經(jīng)常使用的動態(tài)代理方式。

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;public class DynamicProxy implements InvocationHandler{private Object source;public DynamicProxy(Object source) {super();this.source = source;}public void before(){System.out.println("在方法前做一些事，比如打開事務(wù)");}public void after(){System.out.println("在方法返回前做一些事，比如提交事務(wù)");}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//假設(shè)我們切入toString方法，其他其實也是類似的，一般我們這里大部分是針對特定的方法做事情的，通常不會對類的全部方法切入//比如我們常用的事務(wù)管理器，我們通常配置的就是對save,update,delete等方法才打開事務(wù)if (method.getName().equals("toString")) {before();}Object result = method.invoke(source, args);if (method.getName().equals("toString")) {after();}return result;}public Object getProxy(){return Proxy.newProxyInstance(getClass().getClassLoader(), source.getClass().getInterfaces(), this);}}

? ? ? ? ? ? ? ? 上述我做了一些注釋，其實已經(jīng)說明一些問題，這個代理類的作用是可以代理任何類，因為它被傳入的對象是Object，而不再是具體的類，比如剛才的Connection，這些產(chǎn)生的代理類在調(diào)用toString方法時會被插入before方法和after方法。

? ? ? ? ? ? ? ? 動態(tài)代理有一個強制性要求，就是被代理的類必須實現(xiàn)了某一個接口，或者本身就是接口，就像我們的Connection。

? ? ? ? ? ? ? ? 道理其實很簡單，這是因為動態(tài)代理生成的代理類是繼承Proxy類的，并且會實現(xiàn)被你傳入newProxyInstance方法的所有接口，所以我們可以將生成的代理強轉(zhuǎn)為任意一個代理的接口或者Proxy去使用，但是Proxy里面幾乎全是靜態(tài)方法，沒有實例方法，所以轉(zhuǎn)換成Proxy意義不大，幾乎沒什么用。假設(shè)我們的類沒有實現(xiàn)任何接口，那么就意味著你只能將生成的代理類轉(zhuǎn)換成Proxy，那么就算生成了，其實也沒什么用，而且就算你傳入了接口，可以強轉(zhuǎn)，你也用不了這個沒有實現(xiàn)你傳入接口的這個類的方法。

? ? ? ? ? ? ? ?你可能會說，假設(shè)有個接口A，那我將接口A傳給newProxyInstance方法，并代理一個沒實現(xiàn)接口A的類B，但類B與接口A有一樣的方法可以嗎？

? ? ? ? ? ? ? ?答案是可以的，并且JDK的動態(tài)代理只認你傳入的接口，只要你傳入，你就可以強轉(zhuǎn)成這個接口，這個一會解釋，但是你無法在invoke方法里調(diào)用method.invoke方法，也就是說，你只能全部替換A接口的方法，而不能使用類B中原有與接口A方法描述相同的方法，這是因為invoke中傳入的Method的class信息是接口A，而類B因為沒實現(xiàn)接口A，所以無法執(zhí)行傳入的Method，會拋出非法參數(shù)異常。

? ? ? ? ? ? ? ?下面我貼出測試代碼，各位可以自己試一下，具體為何會這樣是在后面解釋的，這里不再多做解釋。

? ? ? ? ? ? ? 先是一個普通接口。

public interface TestInterface {void method1();void method2();void method3(); }

? ? ? ? ? ? 然后是一個類，和接口一模一樣的方法，但是就是沒實現(xiàn)這個接口。

public class TestClass{public void method1() {System.out.println("TestClass.method1");}public void method2() {System.out.println("TestClass.method2");}public void method3() {System.out.println("TestClass.method3");}}

? ? ? ? ? ? ? ?下面是測試類。

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;public class DynamicProxy implements InvocationHandler{private Object source;public DynamicProxy(Object source) {super();this.source = source;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("接口的方法全部變成這樣了");//這里source是TestClass，但是我們不能使用反射調(diào)用它的方法，像下面這樣，放開這一行會拋異常//return method.invoke(source, args);return null;}public static void main(String[] args) {//只要你傳入就可以強轉(zhuǎn)成功TestInterface object = (TestInterface) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{TestInterface.class}, new DynamicProxy(new TestClass()));object.method1();object.method2();object.method3();} }

? ? ? ? ? ? ? ?上面我們運行就會發(fā)現(xiàn)接口的方法全部都只能輸出一個很2的字符串了。如果是要繼續(xù)使用TestClass的方法也不是不行，只要你確認你傳入的類包括了所有你傳入的接口的方法，只是沒實現(xiàn)這些接口而已，那么你可以在invoke中這樣使用。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("before");Method sourceMethod = source.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());sourceMethod.setAccessible(true);Object result = sourceMethod.invoke(source, args);System.out.println("after");return result;}

? ? ? ? ? ? ? ? 這就與你實現(xiàn)接口的表現(xiàn)行為一致了，但是我們本來就只需要一句method.invoke就可以了，就因為沒實現(xiàn)接口就要多寫兩行，所以這種突破JDK動態(tài)代理必須實現(xiàn)接口的行為就有點畫蛇添足了。因為你本來就實現(xiàn)了該接口的方法，只是差了那一句implements而已。

? ? ? ? ? ? ? ?上面寫這個例子只是為了解釋LZ當初的疑惑，因為LZ曾一度認為不實現(xiàn)接口就不能使用動態(tài)代理，現(xiàn)在想想那時候LZ有點2，呵呵。

? ? ? ? ? ? ? ?好了，從現(xiàn)在開始，我們開始詳細講解動態(tài)代理的原理，這算是進階篇，如果是新手的話，可以跳過下面的內(nèi)容，因為現(xiàn)在還沒必要知道這些，而且弄不好會越看越蒙，不過僅僅是LZ個人建議，你要有耐心，完全可以繼續(xù)看下去。

? ? ? ? ? ? ? ?接下來我們結(jié)合源碼去看一下，代理類是如何產(chǎn)生的，首先當然就是要進入Proxy的newProxyInstance方法，這里是產(chǎn)生代理的入口，源碼如下。

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException{if (h == null) {throw new NullPointerException();}/** Look up or generate the designated proxy class.*/Class cl = getProxyClass(loader, interfaces);/** Invoke its constructor with the designated invocation handler.*/try {Constructor cons = cl.getConstructor(constructorParams);return (Object) cons.newInstance(new Object[] { h });} catch (NoSuchMethodException e) {throw new InternalError(e.toString());} catch (IllegalAccessException e) {throw new InternalError(e.toString());} catch (InstantiationException e) {throw new InternalError(e.toString());} catch (InvocationTargetException e) {throw new InternalError(e.toString());}}

? ? ? ? ? ? ? ?這個方法其實很簡單，首先獲取了代理類的運行時Class引用，然后調(diào)用了這個Class中的構(gòu)造方法，這個構(gòu)造方法只有一個參數(shù)，正是InvocationHandler接口，由此產(chǎn)生了一個代理類的實例。那么關(guān)鍵的地方就在于如何獲取的代理類運行時的class信息的呢？我們進入getProxyClass方法看一下。為了方便起見，我直接加注釋，這個方法需要解釋的地方比較多。

public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces) throws IllegalArgumentException {//如果傳入的接口長度大于65535就拋出異常，我去你妹。。。if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}Class proxyClass = null;/* collect interface names to use as key for proxy class cache */String[] interfaceNames = new String[interfaces.length];Set interfaceSet = new HashSet(); // for detecting duplicatesfor (int i = 0; i < interfaces.length; i++) {/** Verify that the class loader resolves the name of this interface* to the same Class object.*/String interfaceName = interfaces[i].getName();Class interfaceClass = null;try {//加載每一個接口的運行時Class信息interfaceClass = Class.forName(interfaceName, false, loader);} catch (ClassNotFoundException e) {}//如果采用你傳入的類加載器載入的Class和你傳入的Class不相等則拋出異常if (interfaceClass != interfaces[i]) {throw new IllegalArgumentException(interfaces[i]+ " is not visible from class loader");}//如果你傳入的不是接口拋出異常/** Verify that the Class object actually represents an interface.*/if (!interfaceClass.isInterface()) {throw new IllegalArgumentException(interfaceClass.getName()+ " is not an interface");}//如果你傳入的接口重復(fù)拋異常/** Verify that this interface is not a duplicate.*/if (interfaceSet.contains(interfaceClass)) {throw new IllegalArgumentException("repeated interface: "+ interfaceClass.getName());}interfaceSet.add(interfaceClass);interfaceNames[i] = interfaceName;}/** Using string representations of the proxy interfaces as keys in the* proxy class cache (instead of their Class objects) is sufficient* because we require the proxy interfaces to be resolvable by name* through the supplied class loader, and it has the advantage that* using a string representation of a class makes for an implicit weak* reference to the class.*/Object key = Arrays.asList(interfaceNames);/** Find or create the proxy class cache for the class loader.*/Map cache;synchronized (loaderToCache) {//這個是為了存儲每一個類加載器所載入過的代理接口的代理類cache = (Map) loaderToCache.get(loader);if (cache == null) {cache = new HashMap();loaderToCache.put(loader, cache);}/** This mapping will remain valid for the duration of this method,* without further synchronization, because the mapping will only be* removed if the class loader becomes unreachable.*/}/** Look up the list of interfaces in the proxy class cache using the* key. This lookup will result in one of three possible kinds of* values: null, if there is currently no proxy class for the list of* interfaces in the class loader, the pendingGenerationMarker object,* if a proxy class for the list of interfaces is currently being* generated, or a weak reference to a Class object, if a proxy class* for the list of interfaces has already been generated.*/synchronized (cache) {/** Note that we need not worry about reaping the cache for entries* with cleared weak references because if a proxy class has been* garbage collected, its class loader will have been garbage* collected as well, so the entire cache will be reaped from the* loaderToCache map.*/do {//檢查是否有生成好的代理Object value = cache.get(key);if (value instanceof Reference) {proxyClass = (Class) ((Reference) value).get();}//有的話直接返回if (proxyClass != null) {// proxy class already generated: return itreturn proxyClass;//否則看一下這個代理類是不是正在構(gòu)造中，是的話就在cache對象上等待} else if (value == pendingGenerationMarker) {// proxy class being generated: wait for ittry {cache.wait();} catch (InterruptedException e) {/** The class generation that we are waiting for should* take a small, bounded time, so we can safely ignore* thread interrupts here.*/}continue;//如果沒有現(xiàn)成的，也沒有創(chuàng)造中的，那就開始創(chuàng)造代理類} else {/** No proxy class for this list of interfaces has been* generated or is being generated, so we will go and* generate it now. Mark it as pending generation.*///將當前代理類置為正在構(gòu)造中，并直接退出循環(huán) cache.put(key, pendingGenerationMarker);break;}} while (true);}try {String proxyPkg = null; // package to define proxy class in//這一段是看你傳入的接口中有沒有不是public的接口，如果有，這些接口必須全部在一個包里定義的，否則拋異常/** Record the package of a non-public proxy interface so that the* proxy class will be defined in the same package. Verify that all* non-public proxy interfaces are in the same package.*/for (int i = 0; i < interfaces.length; i++) {int flags = interfaces[i].getModifiers();if (!Modifier.isPublic(flags)) {String name = interfaces[i].getName();int n = name.lastIndexOf('.');String pkg = ((n == -1) ? "" : name.substring(0, n + 1));if (proxyPkg == null) {proxyPkg = pkg;} else if (!pkg.equals(proxyPkg)) {throw new IllegalArgumentException("non-public interfaces from different packages");}}}if (proxyPkg == null) { // if no non-public proxy interfaces,proxyPkg = ""; // use the unnamed package }{/** Choose a name for the proxy class to generate.*/long num;synchronized (nextUniqueNumberLock) {num = nextUniqueNumber++;}//生成一個隨機代理類名String proxyName = proxyPkg + proxyClassNamePrefix + num;/** Verify that the class loader hasn't already defined a class* with the chosen name.*///這一句就是重中之重了，生成代理類的class文件，這就是JDK動態(tài)代理的原理了，通過動態(tài)生成class文件來產(chǎn)生的代理類//這個generateProxyClass方法下面會著重介紹/** Generate the specified proxy class.*/byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);try {//得到class文件二進制流后，直接載入代理類proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);} catch (ClassFormatError e) {/** A ClassFormatError here means that (barring bugs in the* proxy class generation code) there was some other invalid* aspect of the arguments supplied to the proxy class* creation (such as virtual machine limitations exceeded).*/throw new IllegalArgumentException(e.toString());}}//proxyClasses這個Map是為了來判斷是不是代理的Class// add to set of all generated proxy classes, for isProxyClassproxyClasses.put(proxyClass, null);} finally {/** We must clean up the "pending generation" state of the proxy* class cache entry somehow. If a proxy class was successfully* generated, store it in the cache (with a weak reference);* otherwise, remove the reserved entry. In all cases, notify all* waiters on reserved entries in this cache.*/synchronized (cache) {if (proxyClass != null) {//最終將生成的代理用弱引用包裝起來放到cache當中cache.put(key, new WeakReference(proxyClass));} else {//如果代理類是空則移除代理的接口所代表的key值 cache.remove(key);}//通知正在等待在cache對象上的線程，告訴他們可以繼續(xù)了，代理Class加載完畢了 cache.notifyAll();}}return proxyClass;}

? ? ? ? ? ? ? ? 上面基本上已經(jīng)解釋的很清楚了，下面就是去看一下byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces)這句話是如何處理的，也就是如何得到的代理類的class文件的，我們進去源碼看一下，我依然會加上注釋。

public static byte[] generateProxyClass(String paramString, Class[] paramArrayOfClass) {//新建一個ProxyGenerator實例，傳入類名和接口數(shù)組ProxyGenerator localProxyGenerator = new ProxyGenerator(paramString, paramArrayOfClass);//這個才是真正生成class文件的地方final byte[] arrayOfByte = localProxyGenerator.generateClassFile();//看保存生成文件的標志是否為真，如果是就將class文件生成到本地，生成時要檢查權(quán)限if (saveGeneratedFiles) {AccessController.doPrivileged(new PrivilegedAction() {public Object run() {try {FileOutputStream localFileOutputStream = new FileOutputStream( ProxyGenerator.dotToSlash(this.val$name) + ".class");localFileOutputStream.write(arrayOfByte);localFileOutputStream.close();return null;} catch (IOException localIOException) {throw new InternalError( "I/O exception saving generated file: " + localIOException);}}});}return arrayOfByte;}

? ? ? ? ? ? ? ? 我們繼續(xù)跟蹤到localProxyGenerator.generateClassFile()這一句當中，依然會加上注釋。

private byte[] generateClassFile() {//addProxyMethod方法，就是將方法都加入到一個列表中，并與對應(yīng)的class對應(yīng)起來//這里給Object對應(yīng)了三個方法hashCode，toString和equalsaddProxyMethod(hashCodeMethod, Object.class);addProxyMethod(equalsMethod, Object.class);addProxyMethod(toStringMethod, Object.class);//同樣將接口與接口下的方法對應(yīng)起來for (int i = 0; i < this.interfaces.length; i++) {localObject1 = this.interfaces[i].getMethods();for (int k = 0; k < localObject1.length; k++) {addProxyMethod(localObject1[k], this.interfaces[i]);}}//檢查所有代理方法的返回類型for (Iterator localIterator1 = this.proxyMethods.values().iterator(); localIterator1.hasNext();) {localObject1 = (List) localIterator1.next();checkReturnTypes((List) localObject1);}Object localObject2;try {//方法中加入構(gòu)造方法，這個構(gòu)造方法只有一個，就是一個帶有InvocationHandler接口的構(gòu)造方法//這個才是真正給class文件，也就是代理類加入方法了，不過還沒真正處理，只是先加進來等待循環(huán)，構(gòu)造方法在class文件中的名稱描述是<init>this.methods.add(generateConstructor());//循環(huán)代理方法for (localIterator1 = this.proxyMethods.values().iterator(); localIterator1.hasNext();) {localObject1 = (List) localIterator1.next();for (localIterator2 = ((List) localObject1).iterator(); localIterator2.hasNext();) {localObject2 = (ProxyMethod) localIterator2.next();//給每一個代理方法加一個Method類型的屬性，數(shù)字10是class文件的標識符，代表這些屬性都是private static的this.fields.add(new FieldInfo(((ProxyMethod) localObject2).methodFieldName,"Ljava/lang/reflect/Method;", 10));//將每一個代理方法都加到代理類的方法中this.methods.add(((ProxyMethod) localObject2).generateMethod());}}Iterator localIterator2;//加入一個靜態(tài)初始化塊，將每一個屬性都初始化，這里靜態(tài)代碼塊也叫類構(gòu)造方法，其實就是名稱為<clinit>的方法，所以加到方法列表this.methods.add(generateStaticInitializer());} catch (IOException localIOException1) {throw new InternalError("unexpected I/O Exception");}//方法和屬性個數(shù)都不能超過65535，包括剛才的接口個數(shù)也是這樣，//這是因為在class文件中，這些個數(shù)都是用4位16進制表示的，所以最大值是2的16次方-1if (this.methods.size() > 65535) {throw new IllegalArgumentException("method limit exceeded");}if (this.fields.size() > 65535) {throw new IllegalArgumentException("field limit exceeded");}//這里是將類名中的.轉(zhuǎn)成成斜線為了寫入class文件。this.cp.getClass(dotToSlash(this.className));this.cp.getClass("java/lang/reflect/Proxy");for (int j = 0; j < this.interfaces.length; j++) {this.cp.getClass(dotToSlash(this.interfaces[j].getName()));}this.cp.setReadOnly();//這里開始真正的寫class文件ByteArrayOutputStream localByteArrayOutputStream = new ByteArrayOutputStream();Object localObject1 = new DataOutputStream(localByteArrayOutputStream);try {//寫入class文件的標識號，標識這是一個class文件((DataOutputStream) localObject1).writeInt(-889275714);//次版本號0((DataOutputStream) localObject1).writeShort(0);//主版本號，49代表的是JDK1.5((DataOutputStream) localObject1).writeShort(49);//這里寫入的是常量池，包括一些屬性名稱，類名稱，方法描述符，屬性描述符等等，常量池在加載時會被放到方法區(qū)或者說永久代。this.cp.write((OutputStream) localObject1);//這里寫入的是這個類的訪問標識，49代表的是public final，也就是說JDK動態(tài)代理生成的代理類都是final的((DataOutputStream) localObject1).writeShort(49);//寫入代理類的類名((DataOutputStream) localObject1).writeShort(this.cp.getClass(dotToSlash(this.className)));//寫入代理類的父類類名，也就是Proxy類，這個位置的類如果說是JAVA文件，相當于extend后面的類，也就是父類((DataOutputStream) localObject1).writeShort(this.cp.getClass("java/lang/reflect/Proxy"));//寫入代理類所實現(xiàn)的接口數(shù)量 ((DataOutputStream) localObject1).writeShort(this.interfaces.length);//寫入代理類所實現(xiàn)的接口類名，同樣的，對于JAVA文件來說，相當于implements后面的接口，也就是實現(xiàn)的接口for (int m = 0; m < this.interfaces.length; m++) {((DataOutputStream) localObject1).writeShort(this.cp.getClass(dotToSlash(this.interfaces[m].getName())));}//寫入屬性個數(shù)((DataOutputStream) localObject1).writeShort(this.fields.size());//寫入屬性描述for (Iterator localIterator3 = this.fields.iterator(); localIterator3.hasNext();) {localObject2 = (FieldInfo) localIterator3.next();((FieldInfo) localObject2).write((DataOutputStream) localObject1);}//寫入方法個數(shù)((DataOutputStream) localObject1).writeShort(this.methods.size());//寫入方法描述，方法的code屬性，以及構(gòu)造方法和類構(gòu)造方法都在這里被寫入了。for (localIterator3 = this.methods.iterator(); localIterator3.hasNext();) {localObject2 = (MethodInfo) localIterator3.next();((MethodInfo) localObject2).write((DataOutputStream) localObject1);}//結(jié)束((DataOutputStream) localObject1).writeShort(0);} catch (IOException localIOException2) {throw new InternalError("unexpected I/O Exception");}return localByteArrayOutputStream.toByteArray();}

? ? ? ? ? ? ? ? 其實代理類的class文件并不復(fù)雜，還是有很多規(guī)律可循的，所以上述過程基本上可以讓各位了解下JDK動態(tài)代理生成代理類時都生成了什么東西。

? ? ? ? ? ? ? ? 下面我們可以調(diào)用下JDK中生成Class文件的方法，并且寫入到本地文件，然后使用反編譯工具來看一下生成的代理類到底是什么樣子的。下面是生成文件的測試類。我們暫且將生成的類名寫成TestProxy，代理的接口就是我們上面的TestInterface。如下。

import java.io.File; import java.io.FileOutputStream; import java.io.IOException;import sun.misc.ProxyGenerator;public class CreateClassTest {public static void main(String[] args) throws IOException {byte[] classFile = ProxyGenerator.generateProxyClass("TestProxy", new Class[]{TestInterface.class});File file = new File("F:/TestProxy.class");FileOutputStream fos = new FileOutputStream(file);fos.write(classFile);fos.flush();fos.close();}}

? ? ? ? ? ? ? ? 生成后，我們反編譯過來會是如下格式的JAVA文件。我加入了注釋，大致說明了下文件中生成的部分與剛才分析的時候?qū)懭氲倪^程的對應(yīng)關(guān)系。

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException;//public final的，繼承Proxy，實現(xiàn)你傳入的接口 public final class TestProxy extends Proxyimplements TestInterface {//private static 的Method屬性，對應(yīng)所有方法private static Method m1;private static Method m5;private static Method m3;private static Method m4;private static Method m0;private static Method m2;//唯一的構(gòu)造方法，需要一個InvocationHandler接口傳入public TestProxy(InvocationHandler paramInvocationHandler)throws {super(paramInvocationHandler);}//重寫Object的三個方法public final boolean equals(Object paramObject)throws {try{return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();}catch (Error|RuntimeException localError){throw localError;}catch (Throwable localThrowable){throw new UndeclaredThrowableException(localThrowable);}}public final void method3()throws {try{this.h.invoke(this, m5, null);return;}catch (Error|RuntimeException localError){throw localError;}catch (Throwable localThrowable){throw new UndeclaredThrowableException(localThrowable);}}//代理的三個方法，回調(diào)傳入的InvocationHandler的invoke方法public final void method1()throws {try{this.h.invoke(this, m3, null);return;}catch (Error|RuntimeException localError){throw localError;}catch (Throwable localThrowable){throw new UndeclaredThrowableException(localThrowable);}}public final void method2()throws {try{this.h.invoke(this, m4, null);return;}catch (Error|RuntimeException localError){throw localError;}catch (Throwable localThrowable){throw new UndeclaredThrowableException(localThrowable);}}public final int hashCode()throws {try{return ((Integer)this.h.invoke(this, m0, null)).intValue();}catch (Error|RuntimeException localError){throw localError;}catch (Throwable localThrowable){throw new UndeclaredThrowableException(localThrowable);}}public final String toString()throws {try{return (String)this.h.invoke(this, m2, null);}catch (Error|RuntimeException localError){throw localError;}catch (Throwable localThrowable){throw new UndeclaredThrowableException(localThrowable);}}//這個就是剛才this.methods.add(generateStaticInitializer());這一句話所加入的靜態(tài)初始化塊，初始化每一個屬性static{try{//每一個屬性所代表的Method都是與上面加入代理方法列表時與固定類綁定的，這是class文件中的格式，方法要與固定的類綁定m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });m5 = Class.forName("TestInterface").getMethod("method3", new Class[0]);m3 = Class.forName("TestInterface").getMethod("method1", new Class[0]);m4 = Class.forName("TestInterface").getMethod("method2", new Class[0]);m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);return;}catch (NoSuchMethodException localNoSuchMethodException){throw new NoSuchMethodError(localNoSuchMethodException.getMessage());}catch (ClassNotFoundException localClassNotFoundException){throw new NoClassDefFoundError(localClassNotFoundException.getMessage());}} }

? ? ? ? 看到這里就知道invoke方法是干嘛的了，其實就是生成的代理類對每一個方法的處理就是回調(diào)invoke方法。從生成的代理類源文件中也可以發(fā)現(xiàn)，每一個Method除了hashCode，toString和equals外，都是與所屬的接口綁定的，所以這也就解釋了為什么我們不實現(xiàn)這個接口，只傳入進入的話，不能直接使用method.invoke，而是要轉(zhuǎn)成source對應(yīng)的method才可以調(diào)用。

? ? ? ? 好了，代理模式就分析到這里了，這里講的更多的是代理模式的原理，對于如何使用并沒有講述太多，是因為代理模式在平時工作中用的雖然很多，但我們大多是使用的現(xiàn)成的，原因很簡單，就是因為spring的AOP已經(jīng)給我們弄了一個很好的動態(tài)代理的框架，所以我們幾乎不需要自己去寫，只要明白其原理，知道動態(tài)代理和靜態(tài)代理主要處理的問題是那種的，知道在何處用，也能夠用起來得心應(yīng)手就可以了，當然這只是LZ個人之見，僅供參考。

? ? ? ? 下期預(yù)告，簡單工廠模式。

?

總結(jié)

以上是生活随笔為你收集整理的代理模式详解（包含原理详解）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。