深度剖析JDK動態代理機制
摘要
相比於靜態代理，動態代理避免了開發人員編寫各個繁鎖的靜態代理類，只需簡單地指定一組接口及目標類對象就能動態的得到代理對象。java
代理模式
使用代理模式必需要讓代理類和目標類實現相同的接口，客戶端經過代理類來調用目標方法，代理類會將全部的方法調用分派到目標對象上反射執行，還能夠在分派過程當中添加"前置通知"和後置處理（如在調用目標方法前校驗權限，在調用完目標方法後打印日誌等）等功能。
使用動態代理的五大步驟
1.經過實現InvocationHandler接口來自定義本身的InvocationHandler;
2.經過Proxy.getProxyClass得到動態代理類
3.經過反射機制得到代理類的構造方法，方法簽名爲getConstructor(InvocationHandler.class)
4.經過構造函數得到代理對象並將自定義的InvocationHandler實例對象傳爲參數傳入
5.經過代理對象調用目標方法
動態代理的使用
例1(方式一)
public class MyProxy {
public interface IHello{
void sayHello();
}
static class Hello implements IHello{
public void sayHello() {
System.out.println("Hello world!!");
}
}
//自定義InvocationHandler
static class HWInvocationHandler implements InvocationHandler{
//目標對象
private Object target;
public HWInvocationHandler(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("------插入前置通知代碼-------------");
//執行相應的目標方法
Object rs = method.invoke(target,args);
System.out.println("------插入後置處理代碼-------------");
return rs;
}
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetExc eption, InstantiationException {
//生成$Proxy0的class文件
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
//獲取動態代理類
Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
//得到代理類的構造函數，並傳入參數類型InvocationHandler.class
Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
//經過構造函數來建立動態代理對象，將自定義的InvocationHandler實例傳入
IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));
//經過代理對象調用目標方法
iHello.sayHello();
}
}
輸出：
------插入前置通知代碼-------------
Hello world!!
------插入後置處理代碼-------------
Proxy類中還有個將2~4步驟封裝好的簡便方法來建立動態代理對象，其方法簽名爲：newProxyInstance(ClassLoader loader,Class<?>[] instance, InvocationHandler h)，以下例：
(方式二)
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//生成$Proxy0的class文件
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
IHello ihello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), //加載接口的類加載器
new Class[]{IHello.class}, //一組接口
new HWInvocationHandler(new Hello())); //自定義的InvocationHandler
ihello.sayHello();
}
輸出結果同樣.
下面以newProxyInstance方法爲切入點來剖析代理類的生成及代理方法的調用
（爲了篇幅整潔去掉了次要的代碼）
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
if (h == null) { //若是h爲空直接拋出異常，因此InvocationHandler實例對象是必須的
throw new NullPointerException();
}
//對象的拷貝,暫不知道這裏拷貝下的意義是啥？
final Class<?>[] intfs = interfaces.clone();
//一些安全的權限檢查
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//產生代理類
Class<?> cl = getProxyClass0(loader, intfs);
//獲取代理類的構造函數對象
//參數constructorParames爲常量值：private static final Class<?>[] constructorParams = { InvocationHandler.class };
final Constructor<?> cons = cl.getConstructor(constructorParames);
final InvocationHandler ih = h;
//根據代理類的構造函數對象來建立代理類對象
return newInstance(cons, ih);
}
這段代碼就是對代理類對象的建立，就是對例1中34~38行封裝，其中getProxyClass0就是生成代理類的方法
getProxyClass0方法剖析
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//接口數不得超過65535個
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//代理類緩存，若是緩存中有代理類了直接返回，不然將由ProxyClassFactory建立代理類
return proxyClassCache.get(loader, interfaces);
}
看看ProxyClassFactory是怎樣生成代理類的?
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
//統一代理類的前綴名都以$Proxy開關
private static final String proxyClassNamePrefix = "$Proxy";
//使用惟一的編號給做爲代理類名的一部分，如$Proxy0,$Proxy1等
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) {
//驗證指定的類加載器(loader)加載接口所獲得的Class對象(interfaceClass)是否與intf對象相同
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");
}
//驗證該Class對象是否是接口
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;
/*驗證你傳入的接口中是否有非public接口，只要有一個接口是非public的，那麼這些接口都必須在同一包中
這裏的接口修飾符直接影響到System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true")所生成
的代理類的路徑，往下看！！*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
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) {
/*若是都是public接口，那麼生成的代理類就在com.sun.proxy包下若是報java.io.FileNotFoundException: com\sun\proxy\$Proxy0.c lass (系統找不到指定的路徑。)的錯誤，就先在你項目中建立com.sun.proxy路徑*/
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//將當前nextUniqueNumber的值以原子的方式的加1，因此第一次生成代理類的名字爲$Proxy0.class
long num = nextUniqueNumber.getAndIncrement();
//代理類的徹底限定名，如com.sun.proxy.$Proxy0.calss,
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成代理類字節碼文件
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
而生成代理類字節碼文件又主要經過ProxyGenerate的generateProxyClass(proxyName，interfaces)
public static byte[] generateProxyClass(final String var0, Class[] var1) {
ProxyGenerator var2 = new ProxyGenerator(var0, var1);
//生成代理類字節碼文件的真正方法
final byte[] var3 = var2.generateClassFile();
//保存文件
if(saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction() {
public Void run() {
try {
FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");
var1.write(var3);
var1.close();
return null;
} catch (IOException var2) {
throw new InternalError("I/O exception saving generated file: " + var2);
}
}
});
}
return var3;
}
層層調用後，最終generateClassFile纔是真正生成代理類字節碼文件的方法，
注意開頭的三個addProxyMethod方法是隻將Object的hashcode,equals,toString方法添加到代理方法容器中，代理類除此以外並無重寫其餘Object的方法，因此除這三個方法外，代理類調用其餘方法的行爲與Object調用這些方法的行爲同樣不經過Invoke
private byte[] generateClassFile() {
/addProxyMethod系列方法就是將接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),
其中方法簽名做爲key,proxyMethod做爲value*/
/*hashCodeMethod方法位於靜態代碼塊中經過Object對象得到，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),
至關於從Object中繼承過來了這三個方法equalsMethod,toStringMethod*/
this.addProxyMethod(hashCodeMethod, Object.class); -->
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
int var1;
int var3;
//得到全部接口中的全部方法，並將方法添加到代理方法中
for(var1 = 0; var1 < this.interfaces.length; ++var1) {
Method[] var2 = this.interfaces[var1].getMethods();
for(var3 = 0; var3 < var2.length; ++var3) {
this.addProxyMethod(var2[var3], this.interfaces[var1]);
}
}
Iterator var7 = this.proxyMethods.values().iterator();
List var8;
while(var7.hasNext()) {
var8 = (List)var7.next();
checkReturnTypes(var8); //驗證具備相同方法簽名的的方法的返回值類型是否一致，由於不可能有兩個方法名相同,參數相同，而返回值卻不一樣的方法
};
//接下來就是寫代理類文件的步驟了
Iterator var11
try {
//生成代理類的構造函數
this.methods.add(this.generateConstructor());
var7 = this.proxyMethods.values().iterator();
while(var7.hasNext()) {
var8 = (List)var7.next();
var11 = var8.iterator();
while(var11.hasNext()) {
ProxyGenerator.ProxyMethod var4 = (ProxyGenerator.ProxyMethod)var11.next();
/將代理字段聲明爲Method，10爲ACC_PRIVATE和ACC_STATAIC的與運算，表示該字段的修飾符爲private static
因此代理類的字段都是private static Method XXX*/
this.fields.add(new ProxyGenerator.FieldInfo(var4.methodFieldName, "Ljava/lang/reflect/Method;", 10));
//生成代理類的代理方法
this.methods.add(var4.generateMethod());
}
}
//爲代理類生成靜態代碼塊，對一些字段進行初始化
this.methods.add(this.generateStaticInitializer());
} catch (IOException var6) {
throw new InternalError("unexpected I/O Exception");
}
if(this.methods.size() > '\uffff') { //代理方法超過65535將拋出異常
throw new IllegalArgumentException("method limit exceeded");
} else if(this.fields.size() > '\uffff') { //代理類的字段超過65535將拋出異常
throw new IllegalArgumentException("field limit exceeded");
} else {
//這裏開始就是一些代理類文件的過程，此過程略過
this.cp.getClass(dotToSlash(this.className));
this.cp.getClass("java/lang/reflect/Proxy");
for(var1 = 0; var1 < this.interfaces.length; ++var1) {
this.cp.getClass(dotToSlash(this.interfaces[var1].getName()));
}
this.cp.setReadOnly();
ByteArrayOutputStream var9 = new ByteArrayOutputStream();
DataOutputStream var10 = new DataOutputStream(var9);
try {
var10.writeInt(-889275714);
var10.writeShort(0);
var10.writeShort(49);
this.cp.write(var10);
var10.writeShort(49);
var10.writeShort(this.cp.getClass(dotToSlash(this.className)));
var10.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
var10.writeShort(this.interfaces.length);
for(var3 = 0; var3 < this.interfaces.length; ++var3) {
var10.writeShort(this.cp.getClass(dotToSlash(this.interfaces[var3].getName())));
}
var10.writeShort(this.fields.size());
var11 = this.fields.iterator();
while(var11.hasNext()) {
ProxyGenerator.FieldInfo var12 = (ProxyGenerator.FieldInfo)var11.next();
var12.write(var10);
}
var10.writeShort(this.methods.size());
var11 = this.methods.iterator();
while(var11.hasNext()) {
ProxyGenerator.MethodInfo var13 = (ProxyGenerator.MethodInfo)var11.next();
var13.write(var10);
}
var10.writeShort(0);
return var9.toByteArray();
} catch (IOException var5) {
throw new InternalError("unexpected I/O Exception");
}
}
}
addProxyMethod方法剖析
private void addProxyMethod(Method var1, Class var2) {
String var3 = var1.getName(); //方法名
Class[] var4 = var1.getParameterTypes(); //方法參數類型數組
Class var5 = var1.getReturnType(); //返回值類型
Class[] var6 = var1.getExceptionTypes(); //異常類型
String var7 = var3 + getParameterDescriptors(var4); //方法簽名
Object var8 = (List)this.proxyMethods.get(var7); //根據方法簽名卻得到proxyMethods的Value
if(var8 != null) { //處理多個代理接口中重複的方法的狀況
Iterator var9 = ((List)var8).iterator();
while(var9.hasNext()) {
ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
if(var5 == var10.returnType) {
/*歸約異常類型以致於讓重寫的方法拋出合適的異常類型，我認爲這裏多是多個接口中有相同的方法，而這些相同的方法拋出的異常類 型又不一樣，因此對這些相同方法拋出的異常進行了歸約*/
ArrayList var11 = new ArrayList();
collectCompatibleTypes(var6, var10.exceptionTypes, var11);
collectCompatibleTypes(var10.exceptionTypes, var6, var11);
var10.exceptionTypes = new Class[var11.size()];
//將ArrayList轉換爲Class對象數組
var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);
return;
}
}
} else {
var8 = new ArrayList(3);
this.proxyMethods.put(var7, var8);
}
((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));
/*24~27行的意思就是若是var8爲空，就建立一個數組，並以方法簽名爲key,proxymethod對象數組爲value添加到proxyMethods*/
}
InvocationHandler的做用
在動態代理中InvocationHandler是核心，每一個代理實例都具備一個關聯的調用處理程序(InvocationHandler)。對代理實例調用方法時，將對方法調用進行編碼並將其指派到它的調用處理程序(InvocationHandler)的
invoke 方法。因此對代理方法的調用都是通InvocationHadler的invoke來實現中，而invoke方法根據傳入的代理對象，方法和參數來決定調用代理的哪一個方法
invoke方法簽名：invoke（Object Proxy，Method method，Object[] args）
$Proxy0.class
來看看例1(MyProxy)的代理類是怎樣的？
public final class $Proxy0 extends Proxy implements IHello { //繼承了Proxy類和實現IHello接口
//變量，都是private static Method XXX
private static Method m3;
private static Method m1;
private static Method m0;
private static Method m2;
//代理類的構造函數，其參數正是是InvocationHandler實例，Proxy.newInstance方法就是經過經過這個構造函數來建立代理實例的
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
//接口代理方法
public final void sayHello() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
//如下Object中的三個方法
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final int hashCode() throws {
try {
return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
} 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);
}
}
//對變量進行一些初始化工做
static {
try {
m3 = Class.forName("com.mobin.proxy.IHello").getMethod("sayHello", new Class[0]);
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
以上就是對代理類如何生成，代理類方法如何被調用的分析！在不少框架都使用了動態代理如Spring,HDFS的RPC調用等等，分析過程當中收穫不少，若是想深刻的瞭解JDK動態代理機制必定要深刻到源碼去剖析！！
相關文章
- 1. 深度剖析JDK動態代理機制 侵立刪
- 2. JDK動態代理實現機制 JDK動態代理實現機制
- 3. JDK-Proxy動態代理深度探究
- 4. Java反射機制剖析（四）-深度剖析動態代理原理及總結
- 5. mybatis動態代理剖析
- 6. 基於 JDK 的動態代理機制
- 7. JDK中的動態代理機制
- 8. java JDK動態代理的機制
- 9. JDK動態代理淺析
- 10. Java動態代理深度解析
- 更多相關文章...
- • TCP滑動窗口機制深度剖析 - TCP/IP教程
- • Spring JDK動態代理（附帶實例） - Spring教程
- • 漫談MySQL的鎖機制
- • 算法總結-深度優先算法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 安裝cuda+cuDNN
- 2. GitHub的使用說明
- 3. phpDocumentor使用教程【安裝PHPDocumentor】
- 4. yarn run build報錯Component is not found in path 「npm/taro-ui/dist/weapp/components/rate/index「
- 5. 精講Haproxy搭建Web集羣
- 6. 安全測試基礎之MySQL
- 7. C/C++編程筆記：C語言中的複雜聲明分析，用實例帶你完全讀懂
- 8. Python3教程(1)----搭建Python環境
- 9. 李宏毅機器學習課程筆記2：Classification、Logistic Regression、Brief Introduction of Deep Learning
- 10. 阿里雲ECS配置速記
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 深度剖析JDK動態代理機制 侵立刪
- 2. JDK動態代理實現機制 JDK動態代理實現機制
- 3. JDK-Proxy動態代理深度探究
- 4. Java反射機制剖析（四）-深度剖析動態代理原理及總結
- 5. mybatis動態代理剖析
- 6. 基於 JDK 的動態代理機制
- 7. JDK中的動態代理機制
- 8. java JDK動態代理的機制
- 9. JDK動態代理淺析
- 10. Java動態代理深度解析