系列文章索引： 1. [Spring事務Transactional和動態代理（一）-JDK代理實現](http://www.itrensheng.com/archives/spring_transaction_jdk_proxy) 2. [Spring事務Transactional和動態代理（二）-cglib動態代理](Spring事務Transactional和動態代理（一）-JDK代理實現) 3. [Spring事務Transactional和動態代理（三）-事務失效的場景](http://www.itrensheng.com/archives/spring_transactional_uneffect) ### 什麼是代理 理設計模式提供了對目標物件的間接訪問方式，能力模式能夠解耦合並且便於擴充套件目標的功能。 在現實生活這，我們消費者如果要去購買一杯牛奶的時候，並不是直接去找牛奶廠商購買，而是在便利店或者超市購買（零售商）；超市進貨的時候也通常不是直接找牛奶廠商，而是找市級代理（渠道經銷商），市級代理再找省級代理（代理商），省級代理從牛奶生產商（廠商）提貨。 如下圖，雖然通過層層代理，一杯牛奶的價格會有增加，但是使用者省卻了時間（使用者不能跑到內蒙去買牛奶）。  ### 靜態代理 靜態代理的實現比較簡單，代理類通過實現與目標物件相同的介面，並在類中維護一個代理物件。通過構造器塞入目標物件，賦值給代理物件，進而執行代理物件實現的介面方法 ```java public interface Person { void eat(); } public class Child implements Person { @Override public void eat() { System.out.println("A Child eats something"); } } public class StaticProxyDemo { public static void main(String[] args) { Person person = new Child(); person.eat(); } } ``` 代理類如下： ```java public class PersonProxy { private Person person; public PersonProxy(Person person){ this.person = person; } private void beforeExecute(){ System.out.println("before"); } public void execute(){ beforeExecute(); person.eat(); afterExecute(); } private void afterExecute(){ System.out.println("after"); } public static void main(String[] args) { PersonProxy personProxy = new PersonProxy(new Child()); personProxy.execute(); } } ``` #### 靜態代理的優點： 這樣可以通過PersonProxy來操作目標物件Person，且在不修改Person物件的條件下能夠對目標物件進行beforeExecute()和afterExecute()的攔截操作，這樣就達到了解耦合和擴充套件目標物件的功能。 #### 靜態代理的缺點： 因為代理物件，需要實現與目標物件一樣的介面，會導致代理類十分繁多，不易維護，同時一旦介面增加方法，則目標物件和代理類都需要維護。 ### 動態代理的實現 JDK的動態代理是基於java.lang.reflect.Proxy實現的InvocationHandler介面 增加Proxy物件，需要實現InvocationHandler，可以看到DynamicPersonProxy類並沒有實現Person介面或者繼承Person介面的子類,DynamicPersonProxy類是完全與Person鬆耦合 ```java import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class DynamicPersonProxy implements InvocationHandler { private Object target; public DynamicPersonProxy(Object target){ this.target = target; } public T getProxy(){ return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this); } private void beforeInvoke(){ System.out.println("before"); } private void afterInvoke(){ System.out.println("after"); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { beforeInvoke(); Object result = method.invoke(target,args); afterInvoke(); return result; } } ``` 測試類如下： ```java public class DynamicProxyTest{ public static void main(String[] args) { // System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); Person person = new Child(); DynamicPersonProxy dynamicPersonProxy = new DynamicPersonProxy(person); Person proxyPerson = (Person) dynamicPersonProxy.getProxy(); proxyPerson.eat(); } } //輸出如下： before A Child eats something after ``` #### 動態代理的優點： 代理物件無需實現介面，介面增加方法也就無需再修改代理物件 #### 動態代理的缺點： 目標物件一定要實現介面，**否則無法使用JDK動態代理** ### 動態代理的原理 動態代理的核心流程是： 1. 為介面建立代理類的位元組碼檔案 2. 使用ClassLoader將位元組碼檔案載入到JVM 3. 建立代理類例項物件 4. 執行物件的目標方法 #### JDK Proxy原始碼分析 下面從原始碼的角度來看一下動態代理的實現原理 核心方法Proxy.newProxyInstance原始碼如下： ```java @CallerSensitive public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException { //InvocationHandler不能為空 Objects.requireNonNull(h); //clone介面 final Class[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } //首先從快取查詢是否有代理類，沒有就生成一個 Class cl = getProxyClass0(loader, intfs); /* * 通過InvocationHandler呼叫目標類的建構函式 */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } //constructorParams是指指定代理類的建構函式型別 final Constructor cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; //如果建構函式不是public修飾，修改 if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction() { 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); } } ``` 其中查詢Proxy類的原始碼如下： ```java private static Class getProxyClass0(ClassLoader loader, Class... interfaces) { //長度檢查 if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } //呼叫了下面的WeakCache.get(K key, P parameter)方法，loader作為key，interfaces作為parameter引數 //定義如下：proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) return proxyClassCache.get(loader, interfaces); } //首先當前key（也就是上面的ClassLoader）已經載入存在，就直接從快取中返回 //如果不存在，就會通過ProxyClassFactory來建立代理物件 public V get(K key, P parameter) { Objects.requireNonNull(parameter); expungeStaleEntries(); //根據key的hash值和一個ReferenceQueue來構造 Object cacheKey = CacheKey.valueOf(key, refQueue); // 從map中取出cacheKey的值 ConcurrentMap> valuesMap = map.get(cacheKey); if (valuesMap == null) { ConcurrentMap> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>()); if (oldValuesMap != null) { valuesMap = oldValuesMap; } } Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter)); Supplier supplier = valuesMap.get(subKey); Factory factory = null; while (true) { if (supplier != null) { // supplier可能是Factory或者CacheValue V value = supplier.get(); if (value != null) { return value; } } // 快取中沒有supplier，同時supplier中沒有 // 懶載入的方式建立一個Factory if (factory == null) { factory = new Factory(key, parameter, subKey, valuesMap); } if (supplier == null) { supplier = valuesMap.putIfAbsent(subKey, factory); if (supplier == null) { // 安裝 Factory supplier = factory; } } else { if (valuesMap.replace(subKey, supplier, factory)) { supplier = factory; } else { supplier = valuesMap.get(subKey); } } } } ``` 再看一下上面提到的ProxyClassFactory是一個 工廠方法，是一個靜態final類，實現了BiFunction介面，其中只有一個apply方法 ```java //類定義 private static final class ProxyClassFactory implements BiFunction[], Class>{ @Override public Class apply(ClassLoader loader, Class[] interfaces) { Map, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class intf : interfaces) { /* * 校驗當前類載入器ClassLoader解析到的名稱和定義的名稱是否相同 */ Class interfaceClass = null; try { interfaceClass = Class.forName(intf.getName(), false, loader); } catch (ClassNotFoundException e) { } if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from class loader"); } /* * 校驗是否是介面型別，這也就是為什麼JDK動態代理只能基於介面 */ if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } /* * 防重 */ if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } // 代理物件的目錄 String proxyPkg = null; int accessFlags = Modifier.PUBLIC | Modifier.FINAL; ..... /* * 生成指定Proxy代理物件的位元組碼 */ byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); try { //呼叫的native方法 return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { /* * 生成的代理類有bug */ throw new IllegalArgumentException(e.toString()); } } } ``` #### Proxy代理位元組碼生成分析 去掉DynamicProxyTest類中的註釋 ```java System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); ``` 這樣就可以看到JDK生成的class檔案。所生成的$Proxy0特性如下： 1. 繼承了Proxy，實現了目標介面Person。因為Java不允許多重繼承，這就限制了：使用JDK代理不能是普通類或者抽象類，只能是介面型別 2. 只有一個InvocationHandler引數的建構函式，所以代理類必須繼承InvocationHandler介面 3. 生成了同名的eat()方法，且呼叫了InvocationHandler的invoke方法 4. 使用靜態程式碼塊初始化Object類的equals，toString和hashCode方法，還有Person介面的eat方法 如上示例反編譯所生成的class檔案內容如下： ```java package com.sun.proxy; import com.randy.dynamicproxy.jdk.interfaces.Person; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; public final class $Proxy0 extends Proxy implements Person { private static Method m1; private static Method m3; private static Method m2; private static Method m0; public $Proxy0(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return (Boolean)super.h.invoke(this, m1, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void eat() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m3 = Class.forName("com.randy.dynamicproxy.jdk.interfaces.Person").getMethod("eat"); m2 = Class.forName("java.lang.Object").getMethod("toString"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); }