代理模式之強制代理模式以及動態代理原理

 

1：強制代理模式

         普通代理模式和強制代理模式是代理模式的其中倆個部分。對於這倆個代理模式，我們採用一個類似事情解釋下：

在網絡上的代理服務器分透明代理和普通代理；對於透明代理來說，字如其意，就是這個代理服務器對用戶來說是透明的，用戶根本不知道這個服務器的存在。而普通代理則是用戶需要自己手動去設置代理服務器的ip，很顯然，對於這點上，用戶必須知道代理服務器的存在。現在對號入座：代理模式中的強制代理類似網絡上的代理服務器的透明代理，代理模式中的普通代理模式就類似網絡上的代理服務器的普通代理。

普通代理模式比較常見，在這裏就不作多說了，那麼在這裏就重點來看看強制代理模式。

 

        強制代理模式在設計模式中比較怪怪的，很另類。一般的思維都是通過代理模式找到真實的角色，但是強制代理模式反其道而行之，必須強制通過真實角色去查找到到模式，否則不能訪問。換句話說就是有真實角色去管理代理角色。總而言之：就是通過new或者其他方式創建一個真實角色的對象，最後卻是會有真實角色返回他自己的代理角色。類似日常生活中：哥們咱想通過給點錢給某某局長，讓他出面給咱們半個事情，結果他給我們一張他祕書的名片(理由很簡單，這種事情當老大的不會出面)，讓他們本想通過局長要做的事情，直接通過祕書去做。其實：祕書能做這些，也就是此局長的權勢；說白了祕書就是該局長的替身，代理。上圖：

 

在接口上設置一個getProxy()方法，真實角色就能可以指定一個自己的代理。除了代理，誰也不能訪問。很顯然，當官的人都是會讓指定的親信做事，其他人信不過，當然不能勝任此事。上代碼:局長抑或祕書至少都是官員

 

public interface IOfficer { /** *當官的必須收錢才做事 */ public void receiveMoney(); /** *當官的也要送錢，爲了升官發財 * @param userName 行賄人名 * @param amount 行賄數量 */ public void sendMoney(); /** * 返回替身代理，這裏是局長返回他的祕書；如果祕書權勢也大，仍然可以找自己的代理替身去做 * @return */ public IOfficer getProxy(); } 

 

 

 

真實角色和代理角色都應該實現上面的基類。

public class Officer implements IOfficer { private String name = ""; private IOfficer proxy = null; public Officer(String _name) { this.name = _name; } @Override public IOfficer getProxy() { this.proxy = new OfficerProxy(this); return this.proxy; } @Override public void receiveMoney() { if (this.isProxy()) { System.out.println(name + " are starting to receiveMoney"); } else { System.out.println("please user pointed proxy access"); } } @Override public void sendMoney() { if (this.isProxy()) { System.out.println(name + " are starting to sendMoney"); } else { System.out.println("please user pointed proxy sendMoney"); } } /** * 檢查是否是通過代理訪問 * @return */ private boolean isProxy() { if (this.proxy == null) { return false; } else { return true; } } }

 

真實角色，增加一個私有方法，檢查是否爲自己的代理，如果是自己的代理，才能執行自己的方法。接下來看看代替實現：

 

public class OfficerProxy implements IOfficer { private IOfficer officer; public OfficerProxy(IOfficer _officer) { this.officer = _officer; } //該代理爲官員的祕書，這裏祕書只能返回自己了； @Override public IOfficer getProxy() { return this; } @Override public void receiveMoney() { officer.receiveMoney(); } @Override public void sendMoney() { officer.sendMoney

 

 

 

 下面將演示3中場景：

public class Officialdom { //場景1 public static void main(String[] args) { IOfficer player = new Officer("張局長"); player.receiveMoney(); player.sendMoney(); } //場景2 public static void main(String[] args) { IOfficer player = new Officer("張局長"); OfficerProxy proxy =new OfficerProxy(player); proxy.receiveMoney(); proxy.sendMoney(); } //場景3 public static void main(String[] args) { IOfficer player = new Officer("張局長"); IOfficer proxy = player.getProxy(); proxy.receiveMoney(); proxy.sendMoney(); } }

 

運行結果：

 

場景1:

please user pointed proxy receiveMoney
please user pointed proxy sendMoney

 

場景2:

please user pointed proxy receiveMoney
please user pointed proxy sendMoney

 

場景3:

張局長 are starting to receiveMoney
張局長 are starting to sendMoney

 

        所以從上面的實例中可以得出：強制代理的概念就是必須從真實角色中查找返回其代理角色，不允許直接通過調用真實角色的方法，因爲在每次調用真實角色從基類繼承的方法時候，該方法都會先去判斷是否爲代理調用。高層模塊只需訪問真實角色的getProxy(),就可以完成訪問真實角色的所有方法，它根本就不需要產生一個代理處理，代理的管理已經由真實角色自己完成。強制代理模式使得高層模塊與真實角色的業務場景耦合度極地；真實角色的修改，在高層模塊中完全不用修改。倆者只通過真實角色提供的一個getProxy()接口來交互。在整個實現過程，採用回調思想，在真實角色中調用代理對象的方法，代理對象通過回調來調用真實角色的方法。

 

2：動態代理模式

       先解釋下何爲動態代理模式，所謂動態代理模式就是在實現階段毋須關心代理誰，只有在運行階段才指定代理哪一個對象。通俗點講就是：自己動手寫代理類的方式就是靜態代理模式。採用動態代理模式比較爲大家所熟知的比如AOP(切面編程)，其核心機制就是採用動態代理機制。我們繼續使用上面的官員行賄和受賄的例子來解析動態代理模式原理：上圖

 

 

 

 

 

在類圖中增加一個InvocationHandler接口；其中InvocationHandler是JDK提供的動態代理接口，對被代理的類（即是真實角色的對象，譬如上例中的局長角色）的方法進行代理。看代碼：

public class OfficerProxyDynamic implements InvocationHandler { Class cls; Object object; //設置該代理對象要代理誰，比如說代理對象祕書，他要代理的就是他的頭，局長的麻 public OfficerProxyDynamic(Object object){ this.object = object; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // TODO Auto-generated method stub Object result = method.invoke(this.object, args); return result ; } }

其中invoke方法是InvocationHandler派生類必須實現的方法，它完成對真實角色(祕書調用局長的方法)的方法的調用。動態代理就是根據被代理的真實角色所屬的接口生成所有方法，換而言之：代理對象已經實現接口下（IOfficer）的所有方法。類似靜態代理模式：public class OfficerProxy implements IOfficer 也要實現該接口下所有方法。

 

public class Officialdom { public static void main(String[] args) { IOfficer officerDynamic = new OfficerDynamic("張局長"); InvocationHandler handler = new OfficerProxyDynamic(officerDynamic); ClassLoader loader = officerDynamic.getClass().getClassLoader(); IOfficer proxy = (IOfficer) Proxy.newProxyInstance(loader, new Class[] { IOfficer.class }, handler); proxy.receiveMoney(); proxy.sendMoney(); } }  

 

運行結果：

張局長 are starting to receiveMoney
張局長 are starting to sendMoney

 

粗看很不解，IOfficer proxy是生成的代理類，但是沒有看到代理類實現接口的方法。(IOfficer) Proxy.newProxyInstance來生成代理對象，裏面到底是如何處理的，我們進去看看Proxy.newProxyInstance這個方法：

 

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對象，關鍵 Class cl = getProxyClass(loader, interfaces); /* * Invoke its constructor with the designated invocation handler. */ try { //class對象的實例化 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 cl = getProxyClass(loader, interfaces);Proxy利用類裝載器和代理類的接口來生成一個實現了接口各個方法的代理類的class對象。我們分析下代碼getProxyClass(loader, interfaces)代碼

 

public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException { if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } Class proxyClass = null; //初始化一個class /* collect interface names to use as key for proxy class cache */ //將interface的名字作爲 proxy class cache的一個key String[] interfaceNames = new String[interfaces.length]; Set interfaceSet = new HashSet(); // for detecting duplicates 存放接口class對象的，可以避免重複放同一個class對象 //for語句作用： //1：interfaceSet 存放各個接口的class對象 2：interfaceNames 數組中存放各個接口的名字 for (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 { interfaceClass = Class.forName(interfaceName, false, loader); } catch (ClassNotFoundException e) { } 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"); } /* * 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; } //將數組轉化程list對象 Object key = Arrays.asList(interfaceNames); /* * Find or create the proxy class cache for the class loader. */ 爲類裝載期查找或者創建一個代理的class對象的cache Map cache; synchronized (loaderToCache) { cache = (Map) loaderToCache.get(loader); if (cache == null) { cache = new HashMap(); loaderToCache.put(loader, cache);///該Cache以類裝載器爲key，value也爲一個Cache } } synchronized (cache) { do { Object value = cache.get(key); if (value instanceof Reference) { proxyClass = (Class) ((Reference) value).get(); } if (proxyClass != null) { // proxy class already generated: return it return proxyClass; } else if (value == pendingGenerationMarker) { // proxy class being generated: wait for it try { 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; } 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. */ cache.put(key, pendingGenerationMarker); //以接口名的list爲key，存放正在生成的proxy對象 break; } } while (true); } try { String proxyPkg = null; // package to define proxy class in /* * 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. */ /* * Generate the specified proxy class. */ //重點：generateProxyClass方法爲代理類實現了接口的所有方法，返回字節流 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()); } } // add to set of all generated proxy classes, for isProxyClass proxyClasses.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.put(key, new WeakReference(proxyClass)); } else { cache.remove(key); } cache.notifyAll(); } } return proxyClass; }

 

所以：Proxy.newProxyInstance內部機制爲：

 

1：實現接口
2：裝載字節流文件到虛擬機
3：實例化，並返回對象

 

類推：代理對象調用方法：Proxy.sendMoney(),他的實現應該類似如何:

public final int sendMoney() { try { return ((Integer)super.handler.invoke(this, sendMoney, null)).intValue(); } catch(Error _ex) { } catch(Throwable throwable) { throw new UndeclaredThrowableException(throwable); } }

通過InvocationHandler的invoke方法類來調用真實角色對應方法