從代理模式說起
回顧前文: 設計模式系列之代理模式(Proxy Pattern)
要讀懂動態代理，應從代理模式說起。而實現代理模式，常見有下面兩種實現：
(1) 代理類關聯目標物件，實現目標物件實現的介面
public class Proxy implements Subject {
// 維持一個對真實主題物件的引用
private RealSubject realSubject;
public Proxy(RealSubject realSubject) {
this.realSubject = realSubject;
}
public void preRequest() {
// ...
}
public void postRequest() {
// ...
}
@Override
public void request() {
preRequest();
// 呼叫真實主題物件的方法
realSubject.request();
postRequest();
}
}
(2) 代理類繼承目標類，重寫需要代理的方法
public class Proxy extends RealSubject {
public void preRequest() {
// ...
}
public void postRequest() {
// ...
}
@Override
public void request() {
preRequest();
super.request();
postRequest();
}
}
如果程式
執行前就在Java程式碼中定義好代理類(Proxy)，那麼這種代理方式就叫做靜態代理；若代理類在程式執行時建立就叫做動態代理
- 如果為特定類的特定方法生成固定的代理，當然使用
靜態代理就能很好滿足需求。 - 如果要為大量不同類的不同方法生成代理，使用靜態代理的話就需要編寫大量的代理類，且大量程式碼冗餘，此時
動態代理就應該閃亮登場了。
Java中實現動態代理常用的技術包括JDK的動態代理、CGLib等。
JDK的動態代理
快速入門
假設我們的業務系統中有對使用者(UserService)和商品(ProductService)的查詢(query)和刪除(delete)業務邏輯，程式碼如下：
public interface CommonService {
Object query(Long id);
void delete(Long id);
}
public class UserService implements CommonService {
@Override
public Object query(Long id) {
String s = "查詢到使用者：" + id;
System.out.println(s);
return s;
}
@Override
public void delete(Long id) {
System.out.println("已刪除使用者：" + id);
}
}
public class ProductService implements CommonService {
@Override
public Object query(Long id) {
String s = "查詢到商品：" + id;
System.out.println(s);
return s;
}
@Override
public void delete(Long id) {
System.out.println("已刪除商品：" + id);
}
}
現在想用代理模式給這些Service統一加上業務處理時間的日誌(log)，如果使用靜態代理，那麼拿上面的例子來說就要再手動寫代理類，但實際的業務系統肯定遠不止這2個類，那麼就需要寫大量的相似冗餘的程式碼。
那麼使用JDK提供的動態代理，應該如何實現呢？
(1) 編寫日誌處理器LogHandler，該處理器需要實現java中的InvocationHandler介面中的invoke方法
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class LogHandler implements InvocationHandler {
// 目標物件
private Object target;
public LogHandler(Object target) {
this.target = target;
}
private void preHandle() {
System.out.println("開始處理請求時間: " + System.currentTimeMillis());
}
private void postHandle() {
System.out.println("結束處理請求時間: " + System.currentTimeMillis());
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 請求處理前 記錄日誌
preHandle();
// 目標物件的業務處理邏輯
Object result = method.invoke(target, args);
// 請求處理完成 記錄日誌
postHandle();
return result;
}
}
(2) 生成代理物件，並測試代理是否生效
public static void main(String[] args) {
/**
* @see sun.misc.ProxyGenerator#saveGeneratedFiles
* jdk1.8加上這樣的配置(其他版本應當取找sun.misc.ProxyGenerator#saveGeneratedFiles用的是什麼)
* 會將執行時生成的代理Class落磁碟，方便我們檢視動態代理生成的class檔案。jdk1.8應該是在當前專案根目錄的com/sun/proxy目錄
* 注意：在main方法中加該配置
*/
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
// 原物件
CommonService userService = new UserService();
CommonService productService = new ProductService();
// 代理物件
CommonService proxyUserService = (CommonService) Proxy.newProxyInstance(
CommonService.class.getClassLoader(),
new Class[]{CommonService.class},
new LogHandler(userService));
CommonService proxyProductService = (CommonService) Proxy.newProxyInstance(
CommonService.class.getClassLoader(),
new Class[]{CommonService.class},
new LogHandler(productService));
// 測試代理是否生效
proxyUserService.query(1L);
System.out.println("----------");
proxyUserService.delete(1L);
System.out.println("\n");
proxyProductService.query(1L);
System.out.println("----------");
proxyProductService.delete(1L);
}
(3) 執行結果
開始處理請求時間: 1594528163163
查詢到使用者：1
結束處理請求時間: 1594528163163
----------
開始處理請求時間: 1594528163163
已刪除使用者：1
結束處理請求時間: 1594528163163
開始處理請求時間: 1594528163163
查詢到商品：1
結束處理請求時間: 1594528163163
----------
開始處理請求時間: 1594528163163
已刪除商品：1
結束處理請求時間: 1594528163163
可見，通過代理模式增加統一日誌處理生效了，而且即便是給多個不同類的物件新增統一日誌處理，寫一個LogHandler就夠了，不用為每個類額外寫一個對應的代理類。
實現原理
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
上面程式碼中有這樣一行，加上這個之後就能把執行時生成的代理class檔案寫到檔案中(在專案根目錄的com/sun/proxy下），關鍵奧祕就在於生成的這個class檔案。
執行之後，在當前專案的根目錄的com/sun/proxy下，會多出一個$Proxy0.class檔案，反編譯檢視原始碼(這裡去除了equals()、toString()、hashCode()方法)，如下：
package com.sun.proxy;
import com.github.itwild.proxy.CommonService;
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 CommonService {
private static Method m4;
private static Method m3;
public $Proxy0(InvocationHandler var1) {
super(var1);
}
public final Object query(Long var1) {
try {
return (Object)super.h.invoke(this, m4, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void delete(Long var1) {
try {
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
static {
try {
m4 = Class.forName("com.github.itwild.proxy.CommonService").getMethod("query", Class.forName("java.lang.Long"));
m3 = Class.forName("com.github.itwild.proxy.CommonService").getMethod("delete", Class.forName("java.lang.Long"));
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
看到上面的程式碼，你有沒有似曾相識的感覺，這不正是部落格一開篇介紹的實現代理模式的第一種方式嗎(代理類關聯目標物件，實現目標物件實現的介面)。
我們再理一下生成的代理類的程式碼邏輯，$Proxy0繼承了java.lang.reflect.Proxy，並實現了CommonService介面，對代理類的方法呼叫(比如說query())實際上都會轉發到super.h物件的invoke()方法呼叫，再看下super.h到底是啥，追蹤一下父類java.lang.reflect.Proxy可知
/**
* the invocation handler for this proxy instance.
*/
protected InvocationHandler h;
這正是快速入門中我們編寫的LogHandler所實現的InvocationHandler介面。這樣整個過程就理清了，這裡通過super.h呼叫了我們前面編寫的LogHandler中的處理邏輯。
那麼，新的問題又來了，代理類是怎麼生成的，我們沒有寫任何相關的程式碼，它是怎麼知道我需要代理的方法以及方法引數等等。我們在建立代理物件的時候呼叫Proxy.newProxyInstance傳入了代理類需要實現的介面
/**
* Returns an instance of a proxy class for the specified interfaces
* that dispatches method invocations to the specified invocation
* handler.
*
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class
* to implement
* @param h the invocation handler to dispatch method invocations to
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
至於一步步如何生成class的byte[]可先追蹤java.lang.reflect.Proxy中的ProxyClassFactory相關程式碼
/**
* A factory function that generates, defines and returns the proxy class given
* the ClassLoader and array of interfaces.
*/
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
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");
}
/*
* 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.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* 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 (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.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, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
通過上面一段程式碼不知道你有沒有明白生成的第一個代理類的ClassName為什麼是$Proxy0。通過觀察生成的class $Proxy0 extends Proxy implements CommonService，我們知道JDK的動態代理必須要針對介面，而上面一段程式碼也做了合法性檢查
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
然後就要往sun.misc.ProxyGenerator#generateProxyClass()方法裡看了
private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();
if (saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
// 省略...
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}
這裡看到了為什麼我們要在main方法一開始加上sun.misc.ProxyGenerator.saveGeneratedFiles配置就是為了讓生成的代理class位元組碼落盤生成檔案。
繼續就是ProxyGenerator#generateClassFile()如何根據className、interfaces生成classfile的byte[]以及如何得到class物件java.lang.reflect.Proxy#defineClass0，有興趣可以深入探究。
private static native Class<?> defineClass0(ClassLoader loader, String name,
byte[] b, int off, int len);
注意事項
JDK的動態代理是不需要第三方庫支援的，被代理的物件必須要實現介面。
CGLib
CGLib(Code Generation Library)是一個功能較為強大、效能也較好的程式碼生成包，在許多AOP框架中得到廣泛應用。
快速入門
除了UserService、ProductService，還有訂單業務(OrderService)也需要用代理模式新增統一日誌處理，但是注意，OrderService並沒有實現任何介面，且delete()方法用final修飾。
public class OrderService {
public Object query(Long id) {
String s = "查詢到訂單：" + id;
System.out.println(s);
return s;
}
public final void delete(Long id) {
System.out.println("已刪除訂單：" + id);
}
}
我們知道，JDK的動態代理必須要求實現了介面，而cglib沒有這個限制。具體操作如下：
(1) 引入cglib的maven依賴
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
(2) 編寫方法攔截器
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class LogInterceptor implements MethodInterceptor {
private void preHandle() {
System.out.println("開始處理請求時間: " + System.currentTimeMillis());
}
private void postHandle() {
System.out.println("結束處理請求時間: " + System.currentTimeMillis());
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
// pre handle
preHandle();
// Invoke the original (super) method on the specified object
Object object = proxy.invokeSuper(obj, args);
// post handle
postHandle();
return object;
}
}
(3) 生成代理物件，並測試代理是否生效
public static void main(String[] args) {
// 指定目錄生成動態代理類class檔案
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/tmp/cglib");
Enhancer enhancer = new Enhancer();
// set the class which the generated class will extend
enhancer.setSuperclass(OrderService.class);
// set the single Callback to use
enhancer.setCallback(new LogInterceptor());
// generate a new class
OrderService proxy = (OrderService) enhancer.create();
proxy.query(1L);
System.out.println();
proxy.delete(1L);
}
(4) 執行結果
開始處理請求時間: 1594653500162
查詢到訂單：1
結束處理請求時間: 1594653500183
已刪除訂單：1
可見，對OrderService的query()方法實現了代理，而被final修飾的delete()方法沒有被代理。
實現原理
非常類似學習JDK的動態代理，這裡我們同樣反編譯生成的代理class檔案，去除其他暫時這裡不關注的資訊，程式碼如下：
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class OrderService$$EnhancerByCGLIB$$ba8463fa extends OrderService implements Factory {
private static final Method CGLIB$query$0$Method;
private static final MethodProxy CGLIB$query$0$Proxy;
static void CGLIB$STATICHOOK1() {
CGLIB$query$0$Method = ReflectUtils.findMethods(new String[]{"query", "(Ljava/lang/Long;)Ljava/lang/Object;"}, (var1 = Class.forName("com.github.itwild.proxy.OrderService")).getDeclaredMethods())[0];
CGLIB$query$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Long;)Ljava/lang/Object;", "query", "CGLIB$query$0");
}
final Object CGLIB$query$0(Long var1) {
return super.query(var1);
}
public final Object query(Long var1) {
MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
if (var10000 == null) {
CGLIB$BIND_CALLBACKS(this);
var10000 = this.CGLIB$CALLBACK_0;
}
return var10000 != null ? var10000.intercept(this, CGLIB$query$0$Method, new Object[]{var1}, CGLIB$query$0$Proxy) : super.query(var1);
}
public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
String var10000 = var0.toString();
switch(var10000.hashCode()) {
case -508378822:
if (var10000.equals("clone()Ljava/lang/Object;")) {
return CGLIB$clone$4$Proxy;
}
break;
case 842547398:
if (var10000.equals("query(Ljava/lang/Long;)Ljava/lang/Object;")) {
return CGLIB$query$0$Proxy;
}
break;
case 1826985398:
if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
return CGLIB$equals$1$Proxy;
}
break;
case 1913648695:
if (var10000.equals("toString()Ljava/lang/String;")) {
return CGLIB$toString$2$Proxy;
}
break;
case 1984935277:
if (var10000.equals("hashCode()I")) {
return CGLIB$hashCode$3$Proxy;
}
}
return null;
}
static {
CGLIB$STATICHOOK1();
}
}
觀察OrderService$$EnhancerByCGLIB$$ba8463fa得知該類繼承了OrderService，並且override了query(Long id)方法，而delete方法被final修飾不能被重寫。
到了這裡，不知道你有沒有想起開篇講到的實現代理模式的第二種方式(代理類繼承目標類，重寫需要代理的方法)。這裡應用的正是這種。
關於cglib更詳細的介紹並不是這裡的重點，後面我會抽時間細緻學習學習做個筆記出來。不過這裡還是要多提幾句。
當呼叫代理類的query()方法時，會尋找該query()方法上有沒有被繫結攔截器(比如說編寫程式碼時實現的MethodInterceptor介面)，沒有的話則不需要代理。JDK動態代理的攔截物件是通過反射的機制來呼叫被攔截方法的，反射的效率較低，cglib採用了FastClass的機制來實現對被攔截方法的呼叫。FastClass機制會對一個類的方法建立索引，通過索引來直接呼叫相應的方法，提高了效率。