一文讀懂Java中的動態代理
從代理模式提及
回顧前文: 設計模式系列之代理模式(Proxy Pattern)html
要讀懂動態代理，應從代理模式提及。而實現代理模式，常見有下面兩種實現：java
(1) 代理類關聯目標對象，實現目標對象實現的接口git
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) 代理類繼承目標類，重寫須要代理的方法github
public class Proxy extends RealSubject {
public void preRequest() {
// ...
}
public void postRequest() {
// ...
}
@Override
public void request() {
preRequest();
super.request();
postRequest();
}
}
若是程序
運行前就在Java代碼中定義好代理類(Proxy)，那麼這種代理方式就叫作靜態代理；若代理類在程序運行時建立就叫作動態代理設計模式
- 若是爲特定類的特定方法生成固定的代理，固然使用
靜態代理就能很好知足需求。 - 若是要爲大量不一樣類的不一樣方法生成代理，使用靜態代理的話就須要編寫大量的代理類，且大量代碼冗餘，此時
動態代理就應該閃亮登場了。
Java中實現動態代理經常使用的技術包括JDK的動態代理、CGLib等。app
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個類，那麼就須要寫大量的類似冗餘的代碼。maven
那麼使用JDK提供的動態代理，應該如何實現呢？ide
(1) 編寫日誌處理器LogHandler，該處理器須要實現java中的InvocationHandler接口中的invoke方法post
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機制會對一個類的方法創建索引，經過索引來直接調用相應的方法，提升了效率。
相關文章
- 1. 一文讀懂Java動態代理
- 2. 一文徹底搞懂靜態代理和動態代理
- 3. 一篇文章完全搞懂java動態代理的實現
- 4. java中的動態代理
- 5. Java 中的動態代理
- 6. Java中的動態代理
- 7. Java中的代理模式--靜態代理和動態代理
- 8. 一文讀懂 Java 中的原子類
- 9. Java 靜態代理、Java動態代理、CGLIB動態代理
- 10. 017 Java中的靜態代理、JDK動態代理、cglib動態代理
- 更多相關文章...
- • Spring JDK動態代理（附帶實例） - Spring教程
- • Spring CGLlB動態代理（附帶實例） - Spring教程
- • SpringBoot中properties文件不能自動提示解決方法
- • Scala 中文亂碼解決
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章