深度剖析java中JDK動態(tài)代理機制
更新時間：2017年04月05日 08:54:19 作者：MOBIN
本篇文章主要介紹了深度剖析java中JDK動態(tài)代理機制 ，動態(tài)代理避免了開發(fā)人員編寫各個繁鎖的靜態(tài)代理類，只需簡單地指定一組接口及目標(biāo)類對象就能動態(tài)的獲得代理對象。
摘要
相比于靜態(tài)代理，動態(tài)代理避免了開發(fā)人員編寫各個繁鎖的靜態(tài)代理類，只需簡單地指定一組接口及目標(biāo)類對象就能動態(tài)的獲得代理對象。
代理模式
使用代理模式必須要讓代理類和目標(biāo)類實現(xiàn)相同的接口，客戶端通過代理類來調(diào)用目標(biāo)方法，代理類會將所有的方法調(diào)用分派到目標(biāo)對象上反射執(zhí)行，還可以在分派過程中添加"前置通知"和后置處理（如在調(diào)用目標(biāo)方法前校驗權(quán)限，在調(diào)用完目標(biāo)方法后打印日志等）等功能。
使用動態(tài)代理的五大步驟
1.通過實現(xiàn)InvocationHandler接口來自定義自己的InvocationHandler;
2.通過Proxy.getProxyClass獲得動態(tài)代理類
3.通過反射機制獲得代理類的構(gòu)造方法，方法簽名為getConstructor(InvocationHandler.class)
4.通過構(gòu)造函數(shù)獲得代理對象并將自定義的InvocationHandler實例對象傳為參數(shù)傳入
5.通過代理對象調(diào)用目標(biāo)方法
動態(tài)代理的使用
例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{
//目標(biāo)對象
private Object target;
public HWInvocationHandler(Object target){
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("------插入前置通知代碼-------------");
//執(zhí)行相應(yīng)的目標(biāo)方法
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");
//獲取動態(tài)代理類
Class proxyClazz = Proxy.getProxyClass(IHello.class.getClassLoader(),IHello.class);
//獲得代理類的構(gòu)造函數(shù)，并傳入?yún)?shù)類型InvocationHandler.class
Constructor constructor = proxyClazz.getConstructor(InvocationHandler.class);
//通過構(gòu)造函數(shù)來創(chuàng)建動態(tài)代理對象，將自定義的InvocationHandler實例傳入
IHello iHello = (IHello) constructor.newInstance(new HWInvocationHandler(new Hello()));
//通過代理對象調(diào)用目標(biāo)方法
iHello.sayHello();
}
}
輸出：
------插入前置通知代碼-------------
Hello world!!
------插入后置處理代碼-------------
Proxy類中還有個將2~4步驟封裝好的簡便方法來創(chuàng)建動態(tài)代理對象，其方法簽名為：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();
}
輸出結(jié)果一樣.
下面以newProxyInstance方法為切入點來剖析代理類的生成及代理方法的調(diào)用
（為了篇幅整潔去掉了次要的代碼）
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();
//一些安全的權(quán)限檢查
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//產(chǎn)生代理類
Class<!--?--> cl = getProxyClass0(loader, intfs);
//獲取代理類的構(gòu)造函數(shù)對象
//參數(shù)constructorParames為常量值：private static final Class<!--?-->[] constructorParams = { InvocationHandler.class };
final Constructor<!--?--> cons = cl.getConstructor(constructorParames);
final InvocationHandler ih = h;
//根據(jù)代理類的構(gòu)造函數(shù)對象來創(chuàng)建代理類對象
return newInstance(cons, ih);
}
這段代碼就是對代理類對象的創(chuàng)建，就是對例1中34~38行封裝，其中g(shù)etProxyClass0就是生成代理類的方法
getProxyClass0方法剖析
private static Class<!--?--> getProxyClass0(ClassLoader loader,
Class<!--?-->... interfaces) {
//接口數(shù)不得超過65535個
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//代理類緩存，如果緩存中有代理類了直接返回，否則將由ProxyClassFactory創(chuàng)建代理類
return proxyClassCache.get(loader, interfaces);
}
看看ProxyClassFactory是怎樣生成代理類的?
private static final class ProxyClassFactory
implements BiFunction<classloader, class<?="">[], Class<!--?-->>
{
//統(tǒng)一代理類的前綴名都以$Proxy開關(guān)
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");
}
// 驗證該接口是否重復(fù)了
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 (系統(tǒng)找不到指定的路徑。)的錯誤，就先在你項目中創(chuàng)建com.sun.proxy路徑*/
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//將當(dāng)前nextUniqueNumber的值以原子的方式的加1，所以第一次生成代理類的名字為$Proxy0.class
long num = nextUniqueNumber.getAndIncrement();
//代理類的完全限定名，如com.sun.proxy.$Proxy0.calss,
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成代理類字節(jié)碼文件
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}</class<?></classloader,>
而生成代理類字節(jié)碼文件又主要通過ProxyGenerate的generateProxyClass(proxyName，interfaces)
public static byte[] generateProxyClass(final String var0, Class[] var1) {
ProxyGenerator var2 = new ProxyGenerator(var0, var1);
//生成代理類字節(jié)碼文件的真正方法
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;
}
層層調(diào)用后，最終generateClassFile才是真正生成代理類字節(jié)碼文件的方法，注意開頭的三個addProxyMethod方法是只將Object的hashcode,equals,toString方法添加到代理方法容器中，代理類除此之外并沒有重寫其他Object的方法，所以除這三個方法外，代理類調(diào)用其他方法的行為與Object調(diào)用這些方法的行為一樣不通過Invoke
private byte[] generateClassFile() {
/addProxyMethod系列方法就是將接口的方法和Object的hashCode,equals,toString方法添加到代理方法容器(proxyMethods),
其中方法簽名作為key,proxyMethod作為value*/
/*hashCodeMethod方法位于靜態(tài)代碼塊中通過Object對象獲得，hashCodeMethod=Object.class.getMethod("hashCode",new Class[0]),
相當(dāng)于從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); //驗證具有相同方法簽名的的方法的返回值類型是否一致，因為不可能有兩個方法名相同,參數(shù)相同，而返回值卻不同的方法
};
//接下來就是寫代理類文件的步驟了
Iterator var11
try {
//生成代理類的構(gòu)造函數(shù)
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());
}
}
//為代理類生成靜態(tài)代碼塊，對一些字段進行初始化
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(); //方法參數(shù)類型數(shù)組
Class var5 = var1.getReturnType(); //返回值類型
Class[] var6 = var1.getExceptionTypes(); //異常類型
String var7 = var3 + getParameterDescriptors(var4); //方法簽名
Object var8 = (List)this.proxyMethods.get(var7); //根據(jù)方法簽名卻獲得proxyMethods的Value
if(var8 != null) { //處理多個代理接口中重復(fù)的方法的情況
Iterator var9 = ((List)var8).iterator();
while(var9.hasNext()) {
ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
if(var5 == var10.returnType) {
/*歸約異常類型以至于讓重寫的方法拋出合適的異常類型，我認(rèn)為這里可能是多個接口中有相同的方法，而這些相同的方法拋出的異常類 型又不同，所以對這些相同方法拋出的異常進行了歸約*/
ArrayList var11 = new ArrayList();
collectCompatibleTypes(var6, var10.exceptionTypes, var11);
collectCompatibleTypes(var10.exceptionTypes, var6, var11);
var10.exceptionTypes = new Class[var11.size()];
//將ArrayList轉(zhuǎn)換為Class對象數(shù)組
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為空，就創(chuàng)建一個數(shù)組，并以方法簽名為key,proxymethod對象數(shù)組為value添加到proxyMethods*/
}
InvocationHandler的作用
在動態(tài)代理中InvocationHandler是核心，每個代理實例都具有一個關(guān)聯(lián)的調(diào)用處理程序(InvocationHandler)。對代理實例調(diào)用方法時，將對方法調(diào)用進行編碼并將其指派到它的調(diào)用處理程序(InvocationHandler)的 invoke 方法。所以對代理方法的調(diào)用都是通InvocationHadler的invoke來實現(xiàn)中，而invoke方法根據(jù)傳入的代理對象，方法和參數(shù)來決定調(diào)用代理的哪個方法
invoke方法簽名：invoke（Object Proxy，Method method，Object[] args）
$Proxy0.class
來看看例1(MyProxy)的代理類是怎樣的？
public final class $Proxy0 extends Proxy implements IHello { //繼承了Proxy類和實現(xiàn)IHello接口
//變量，都是private static Method XXX
private static Method m3;
private static Method m1;
private static Method m0;
private static Method m2;
//代理類的構(gòu)造函數(shù)，其參數(shù)正是是InvocationHandler實例，Proxy.newInstance方法就是通過通過這個構(gòu)造函數(shù)來創(chuàng)建代理實例的
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());
}
}
}
以上就是對代理類如何生成，代理類方法如何被調(diào)用的分析！在很多框架都使用了動態(tài)代理如Spring,HDFS的RPC調(diào)用等等，分析過程中收獲很多，如果想深入的了解JDK動態(tài)代理機制一定要深入到源碼去剖析??！希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
您可能感興趣的文章:
- Java JDK 動態(tài)代理的使用方法示例
- Java JDK動態(tài)代理（AOP）的實現(xiàn)原理與使用詳析
- 詳解java JDK 動態(tài)代理類分析(java.lang.reflect.Proxy)
- 深入理解java動態(tài)代理的兩種實現(xiàn)方式（JDK/Cglib）
- 淺談Java代理(jdk靜態(tài)代理、動態(tài)代理和cglib動態(tài)代理)
- Java JDK動態(tài)代理的基本原理詳細(xì)介紹
- java jdk動態(tài)代理詳解
- java動態(tài)代理(jdk與cglib)詳細(xì)解析
- java代理 jdk動態(tài)代理應(yīng)用案列
- 詳解Java JDK動態(tài)代理
相關(guān)文章
這篇文章主要介紹了SpringBoot整合Tomcat連接池的使用，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-04-04
這篇文章主要介紹了SpringBoot?如何從容器中獲取對象，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-08-08
這篇文章主要介紹了springBoot啟動報錯log4j沖突的解決方案，具有很好的參考價值，希望對大家有所幫助。2021-07-07
這篇文章主要為大家介紹了Nacos源碼之注冊中心的實現(xiàn)詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-02-02
使用JavaConfig代替xml實現(xiàn)Spring配置操作
這篇文章主要介紹了使用JavaConfig代替xml實現(xiàn)Spring配置操作，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-09-09
解決SpringMVC、tomcat、Intellij idea、ajax中文亂碼問題
這篇文章主要介紹了解決SpringMVC、tomcat、Intellij idea、ajax中文亂碼問題，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-09-09
解讀Spring配置與服務(wù)組件的關(guān)系和注入機制
這篇文章主要介紹了解讀Spring配置與服務(wù)組件的關(guān)系和注入機制,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-09-09
SpringSecurity中的Filter Chain(過濾器鏈)
Spring Security的Filter Chain是由一系列過濾器組成的管道,每個過濾器執(zhí)行特定的安全功能,Spring Security能夠提供強大而靈活的安全控制機制,從而保護你的應(yīng)用程序不受各種網(wǎng)絡(luò)安全威脅的侵害,本文介紹SpringSecurity中的Filter Chain,感興趣的朋友跟隨小編一起看看吧2024-06-06
這篇文章主要介紹了SpringBoot之為何推薦使用構(gòu)造器注入問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-03-03
如何將eclipse項目導(dǎo)入到idea的方法步驟(圖文)
這篇文章主要介紹了如何將eclipse項目導(dǎo)入到idea的方法步驟，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-03-03