您好,登錄后才能下訂單哦!
本篇文章為大家展示了從另一個角度理解Java中的動態(tài)代理機(jī)制,內(nèi)容簡明扼要并且容易理解,絕對能使你眼前一亮,通過這篇文章的詳細(xì)介紹希望你能有所收獲。
class文件簡介及加載
Java編譯器編譯好Java文件之后,產(chǎn)生.class 文件在磁盤中。這種class文件是二進(jìn)制文件,內(nèi)容是只有JVM虛擬機(jī)能夠識別的機(jī)器碼。JVM虛擬機(jī)讀取字節(jié)碼文件,取出二進(jìn)制數(shù)據(jù),加載到內(nèi)存中,解析.class 文件內(nèi)的信息,生成對應(yīng)的 Class對象:
class字節(jié)碼文件是根據(jù)JVM虛擬機(jī)規(guī)范中規(guī)定的字節(jié)碼組織規(guī)則生成的、具體class文件是怎樣組織類信息的,可以參考 此博文:深入理解Java Class文件格式系列?;蛘呤荍ava虛擬機(jī)規(guī)范。
下面通過一段代碼演示手動加載 class文件字節(jié)碼到系統(tǒng)內(nèi),轉(zhuǎn)換成class對象,然后再實(shí)例化的過程:
a. 定義一個 Programmer類:
package samples; /** * 程序猿類 * @author louluan */ public class Programmer { public void code() { System.out.println("I'm a Programmer,Just Coding....."); } }
b. 自定義一個類加載器:
package samples; /** * 自定義一個類加載器,用于將字節(jié)碼轉(zhuǎn)換為class對象 * @author louluan */ public class MyClassLoader extends ClassLoader { public Class<?> defineMyClass( byte[] b, int off, int len) { return super.defineClass(b, off, len); } }
c. 然后編譯成Programmer.class文件,在程序中讀取字節(jié)碼,然后轉(zhuǎn)換成相應(yīng)的class對象,再實(shí)例化:
package samples; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.net.URL; public class MyTest { public static void main(String[] args) throws IOException { //讀取本地的class文件內(nèi)的字節(jié)碼,轉(zhuǎn)換成字節(jié)碼數(shù)組 File file = new File("."); InputStream input = new FileInputStream(file.getCanonicalPath()+"\\bin\\samples\\Programmer.class"); byte[] result = new byte[1024]; int count = input.read(result); // 使用自定義的類加載器將 byte字節(jié)碼數(shù)組轉(zhuǎn)換為對應(yīng)的class對象 MyClassLoader loader = new MyClassLoader(); Class clazz = loader.defineMyClass( result, 0, count); //測試加載是否成功,打印class 對象的名稱 System.out.println(clazz.getCanonicalName()); //實(shí)例化一個Programmer對象 Object o= clazz.newInstance(); try { //調(diào)用Programmer的code方法 clazz.getMethod("code", null).invoke(o, null); } catch (IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) { e.printStackTrace(); } } }
以上代碼演示了,通過字節(jié)碼加載成class 對象的能力,下面看一下在代碼中如何生成class文件的字節(jié)碼。
在運(yùn)行期的代碼中生成二進(jìn)制字節(jié)碼
由于JVM通過字節(jié)碼的二進(jìn)制信息加載類的,那么,如果我們在運(yùn)行期系統(tǒng)中,遵循Java編譯系統(tǒng)組織.class文件的格式和結(jié)構(gòu),生成相應(yīng)的二進(jìn)制數(shù)據(jù),然后再把這個二進(jìn)制數(shù)據(jù)加載轉(zhuǎn)換成對應(yīng)的類,這樣,就完成了在代碼中,動態(tài)創(chuàng)建一個類的能力了。
在運(yùn)行時(shí)期可以按照J(rèn)ava虛擬機(jī)規(guī)范對class文件的組織規(guī)則生成對應(yīng)的二進(jìn)制字節(jié)碼。當(dāng)前有很多開源框架可以完成這些功能,如ASM,Javassist。
Java字節(jié)碼生成開源框架介紹--ASM:
ASM 是一個 Java 字節(jié)碼操控框架。它能夠以二進(jìn)制形式修改已有類或者動態(tài)生成類。ASM 可以直接產(chǎn)生二進(jìn)制 class 文件,也可以在類被加載入 Java 虛擬機(jī)之前動態(tài)改變類行為。ASM 從類文件中讀入信息后,能夠改變類行為,分析類信息,甚至能夠根據(jù)用戶要求生成新類。
不過ASM在創(chuàng)建class字節(jié)碼的過程中,操縱的級別是底層JVM的匯編指令級別,這要求ASM使用者要對class組織結(jié)構(gòu)和JVM匯編指令有一定的了解。
下面通過ASM 生成下面類Programmer的class字節(jié)碼:
package com.samples; import java.io.PrintStream; public class Programmer { public void code() { System.out.println("I'm a Programmer,Just Coding....."); } }
使用ASM框架提供了ClassWriter 接口,通過訪問者模式進(jìn)行動態(tài)創(chuàng)建class字節(jié)碼,看下面的例子:
package samples; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import org.objectweb.asm.ClassWriter; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; public class MyGenerator { public static void main(String[] args) throws IOException { System.out.println(); ClassWriter classWriter = new ClassWriter(0); // 通過visit方法確定類的頭部信息 classWriter.visit(Opcodes.V1_7,// java版本 Opcodes.ACC_PUBLIC,// 類修飾符 "Programmer", // 類的全限定名 null, "java/lang/Object", null); //創(chuàng)建構(gòu)造函數(shù) MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null); mv.visitCode(); mv.visitVarInsn(Opcodes.ALOAD, 0); mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>","()V"); mv.visitInsn(Opcodes.RETURN); mv.visitMaxs(1, 1); mv.visitEnd(); // 定義code方法 MethodVisitor methodVisitor = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "code", "()V", null, null); methodVisitor.visitCode(); methodVisitor.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); methodVisitor.visitLdcInsn("I'm a Programmer,Just Coding....."); methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V"); methodVisitor.visitInsn(Opcodes.RETURN); methodVisitor.visitMaxs(2, 2); methodVisitor.visitEnd(); classWriter.visitEnd(); // 使classWriter類已經(jīng)完成 // 將classWriter轉(zhuǎn)換成字節(jié)數(shù)組寫到文件里面去 byte[] data = classWriter.toByteArray(); File file = new File("D://Programmer.class"); FileOutputStream fout = new FileOutputStream(file); fout.write(data); fout.close(); } }
上述的代碼執(zhí)行過后,用Java反編譯工具(如JD_GUI)打開D盤下生成的Programmer.class,可以看到以下信息:
再用上面我們定義的類加載器將這個class文件加載到內(nèi)存中,然后 創(chuàng)建class對象,并且實(shí)例化一個對象,調(diào)用code方法,會看到下面的結(jié)果:
以上表明:在代碼里生成字節(jié)碼,并動態(tài)地加載成class對象、創(chuàng)建實(shí)例是完全可以實(shí)現(xiàn)的。
Java字節(jié)碼生成開源框架介紹--Javassist:
Javassist是一個開源的分析、編輯和創(chuàng)建Java字節(jié)碼的類庫。是由東京工業(yè)大學(xué)的數(shù)學(xué)和計(jì)算機(jī)科學(xué)系的 Shigeru Chiba (千葉 滋)所創(chuàng)建的。它已加入了開放源代碼JBoss 應(yīng)用服務(wù)器項(xiàng)目,通過使用Javassist對字節(jié)碼操作為JBoss實(shí)現(xiàn)動態(tài)AOP框架。javassist是jboss的一個子項(xiàng)目,其主要的優(yōu)點(diǎn),在于簡單,而且快速。直接使用java編碼的形式,而不需要了解虛擬機(jī)指令,就能動態(tài)改變類的結(jié)構(gòu),或者動態(tài)生成類。
下面通過Javassist創(chuàng)建上述的Programmer類:
import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.CtNewMethod; public class MyGenerator { public static void main(String[] args) throws Exception { ClassPool pool = ClassPool.getDefault(); //創(chuàng)建Programmer類 CtClass cc= pool.makeClass("com.samples.Programmer"); //定義code方法 CtMethod method = CtNewMethod.make("public void code(){}", cc); //插入方法代碼 method.insertBefore("System.out.println(\"I'm a Programmer,Just Coding.....\");"); cc.addMethod(method); //保存生成的字節(jié)碼 cc.writeFile("d://temp"); } }
通過JD-gui反編譯工具打開Programmer.class 可以看到以下代碼:
代理的基本構(gòu)成:
代理模式上,基本上有Subject角色,RealSubject角色,Proxy角色。其中:Subject角色負(fù)責(zé)定義RealSubject和Proxy角色應(yīng)該實(shí)現(xiàn)的接口;RealSubject角色用來真正完成業(yè)務(wù)服務(wù)功能;Proxy角色負(fù)責(zé)將自身的Request請求,調(diào)用realsubject 對應(yīng)的request功能來實(shí)現(xiàn)業(yè)務(wù)功能,自己不真正做業(yè)務(wù)。
上面的這幅代理結(jié)構(gòu)圖是典型的靜態(tài)的代理模式:
當(dāng)在代碼階段規(guī)定這種代理關(guān)系,Proxy類通過編譯器編譯成class文件,當(dāng)系統(tǒng)運(yùn)行時(shí),此class已經(jīng)存在了。這種靜態(tài)的代理模式固然在訪問無法訪問的資源,增強(qiáng)現(xiàn)有的接口業(yè)務(wù)功能方面有很大的優(yōu)點(diǎn),但是大量使用這種靜態(tài)代理,會使我們系統(tǒng)內(nèi)的類的規(guī)模增大,并且不易維護(hù);并且由于Proxy和RealSubject的功能 本質(zhì)上是相同的,Proxy只是起到了中介的作用,這種代理在系統(tǒng)中的存在,導(dǎo)致系統(tǒng)結(jié)構(gòu)比較臃腫和松散。
為了解決這個問題,就有了動態(tài)地創(chuàng)建Proxy的想法:在運(yùn)行狀態(tài)中,需要代理的地方,根據(jù)Subject 和RealSubject,動態(tài)地創(chuàng)建一個Proxy,用完之后,就會銷毀,這樣就可以避免了Proxy 角色的class在系統(tǒng)中冗雜的問題了。
下面以一個代理模式實(shí)例闡述這一問題:
將車站的售票服務(wù)抽象出一個接口TicketService,包含問詢,賣票,退票功能,車站類Station實(shí)現(xiàn)了TicketService接口,車票代售點(diǎn)StationProxy則實(shí)現(xiàn)了代理角色的功能,類圖如下所示。
對應(yīng)的靜態(tài)的代理模式代碼如下所示:
package com.foo.proxy; /** * 售票服務(wù)接口實(shí)現(xiàn)類,車站 * @author louluan */ public class Station implements TicketService { @Override public void sellTicket() { System.out.println("\n\t售票.....\n"); } @Override public void inquire() { System.out.println("\n\t問詢。。。。\n"); } @Override public void withdraw() { System.out.println("\n\t退票......\n"); } }
package com.foo.proxy; /** * 售票服務(wù)接口 * @author louluan */ public interface TicketService { //售票 public void sellTicket(); //問詢 public void inquire(); //退票 public void withdraw(); }
package com.foo.proxy; /** * 車票代售點(diǎn) * @author louluan * */ public class StationProxy implements TicketService { private Station station; public StationProxy(Station station){ this.station = station; } @Override public void sellTicket() { // 1.做真正業(yè)務(wù)前,提示信息 this.showAlertInfo("××××您正在使用車票代售點(diǎn)進(jìn)行購票,每張票將會收取5元手續(xù)費(fèi)!××××"); // 2.調(diào)用真實(shí)業(yè)務(wù)邏輯 station.sellTicket(); // 3.后處理 this.takeHandlingFee(); this.showAlertInfo("××××歡迎您的光臨,再見!××××\n"); } @Override public void inquire() { // 1做真正業(yè)務(wù)前,提示信息 this.showAlertInfo("××××歡迎光臨本代售點(diǎn),問詢服務(wù)不會收取任何費(fèi)用,本問詢信息僅供參考,具體信息以車站真實(shí)數(shù)據(jù)為準(zhǔn)!××××"); // 2.調(diào)用真實(shí)邏輯 station.inquire(); // 3。后處理 this.showAlertInfo("××××歡迎您的光臨,再見!××××\n"); } @Override public void withdraw() { // 1。真正業(yè)務(wù)前處理 this.showAlertInfo("××××歡迎光臨本代售點(diǎn),退票除了扣除票額的20%外,本代理處額外加收2元手續(xù)費(fèi)!××××"); // 2.調(diào)用真正業(yè)務(wù)邏輯 station.withdraw(); // 3.后處理 this.takeHandlingFee(); } /* * 展示額外信息 */ private void showAlertInfo(String info) { System.out.println(info); } /* * 收取手續(xù)費(fèi) */ private void takeHandlingFee() { System.out.println("收取手續(xù)費(fèi),打印發(fā)票。。。。。\n"); } }
由于我們現(xiàn)在不希望靜態(tài)地有StationProxy類存在,希望在代碼中,動態(tài)生成器二進(jìn)制代碼,加載進(jìn)來。為此,使用Javassist開源框架,在代碼中動態(tài)地生成StationProxy的字節(jié)碼:
package com.foo.proxy; import java.lang.reflect.Constructor; import javassist.*; public class Test { public static void main(String[] args) throws Exception { createProxy(); } /* * 手動創(chuàng)建字節(jié)碼 */ private static void createProxy() throws Exception { ClassPool pool = ClassPool.getDefault(); CtClass cc = pool.makeClass("com.foo.proxy.StationProxy"); //設(shè)置接口 CtClass interface1 = pool.get("com.foo.proxy.TicketService"); cc.setInterfaces(new CtClass[]{interface1}); //設(shè)置Field CtField field = CtField.make("private com.foo.proxy.Station station;", cc); cc.addField(field); CtClass stationClass = pool.get("com.foo.proxy.Station"); CtClass[] arrays = new CtClass[]{stationClass}; CtConstructor ctc = CtNewConstructor.make(arrays,null,CtNewConstructor.PASS_NONE,null,null, cc); //設(shè)置構(gòu)造函數(shù)內(nèi)部信息 ctc.setBody("{this.station=$1;}"); cc.addConstructor(ctc); //創(chuàng)建收取手續(xù) takeHandlingFee方法 CtMethod takeHandlingFee = CtMethod.make("private void takeHandlingFee() {}", cc); takeHandlingFee.setBody("System.out.println(\"收取手續(xù)費(fèi),打印發(fā)票。。。。。\");"); cc.addMethod(takeHandlingFee); //創(chuàng)建showAlertInfo 方法 CtMethod showInfo = CtMethod.make("private void showAlertInfo(String info) {}", cc); showInfo.setBody("System.out.println($1);"); cc.addMethod(showInfo); //sellTicket CtMethod sellTicket = CtMethod.make("public void sellTicket(){}", cc); sellTicket.setBody("{this.showAlertInfo(\"××××您正在使用車票代售點(diǎn)進(jìn)行購票,每張票將會收取5元手續(xù)費(fèi)!××××\");" + "station.sellTicket();" + "this.takeHandlingFee();" + "this.showAlertInfo(\"××××歡迎您的光臨,再見!××××\");}"); cc.addMethod(sellTicket); //添加inquire方法 CtMethod inquire = CtMethod.make("public void inquire() {}", cc); inquire.setBody("{this.showAlertInfo(\"××××歡迎光臨本代售點(diǎn),問詢服務(wù)不會收取任何費(fèi)用,本問詢信息僅供參考,具體信息以車站真實(shí)數(shù)據(jù)為準(zhǔn)!××××\");" + "station.inquire();" + "this.showAlertInfo(\"××××歡迎您的光臨,再見!××××\");}" ); cc.addMethod(inquire); //添加widthraw方法 CtMethod withdraw = CtMethod.make("public void withdraw() {}", cc); withdraw.setBody("{this.showAlertInfo(\"××××歡迎光臨本代售點(diǎn),退票除了扣除票額的20%外,本代理處額外加收2元手續(xù)費(fèi)!××××\");" + "station.withdraw();" + "this.takeHandlingFee();}" ); cc.addMethod(withdraw); //獲取動態(tài)生成的class Class c = cc.toClass(); //獲取構(gòu)造器 Constructor constructor= c.getConstructor(Station.class); //通過構(gòu)造器實(shí)例化 TicketService o = (TicketService)constructor.newInstance(new Station()); o.inquire(); cc.writeFile("D://test"); } }
上述代碼執(zhí)行過后,會產(chǎn)生StationProxy的字節(jié)碼,并且用生成字節(jié)碼加載如內(nèi)存創(chuàng)建對象,調(diào)用inquire()方法,會得到以下結(jié)果:
通過上面動態(tài)生成的代碼,我們發(fā)現(xiàn),其實(shí)現(xiàn)相當(dāng)?shù)芈闊┰趧?chuàng)造的過程中,含有太多的業(yè)務(wù)代碼。我們使用上述創(chuàng)建Proxy代理類的方式的初衷是減少系統(tǒng)代碼的冗雜度,但是上述做法卻增加了在動態(tài)創(chuàng)建代理類過程中的復(fù)雜度:手動地創(chuàng)建了太多的業(yè)務(wù)代碼,并且封裝性也不夠,完全不具有可拓展性和通用性。如果某個代理類的一些業(yè)務(wù)邏輯非常復(fù)雜,上述的動態(tài)創(chuàng)建代理的方式是非常不可取的!
InvocationHandler角色的由來
仔細(xì)思考代理模式中的代理Proxy角色。Proxy角色在執(zhí)行代理業(yè)務(wù)的時(shí)候,無非是在調(diào)用真正業(yè)務(wù)之前或者之后做一些“額外”業(yè)務(wù)。
有上圖可以看出,代理類處理的邏輯很簡單:在調(diào)用某個方法前及方法后做一些額外的業(yè)務(wù)。換一種思路就是:在觸發(fā)(invoke)真實(shí)角色的方法之前或者之后做一些額外的業(yè)務(wù)。那么,為了構(gòu)造出具有通用性和簡單性的代理類,可以將所有的觸發(fā)真實(shí)角色動作交給一個觸發(fā)的管理器,讓這個管理器統(tǒng)一地管理觸發(fā)。這種管理器就是Invocation Handler。
動態(tài)代理模式的結(jié)構(gòu)跟上面的靜態(tài)代理模式稍微有所不同,多引入了一個InvocationHandler角色。
先解釋一下InvocationHandler的作用:
在靜態(tài)代理中,代理Proxy中的方法,都指定了調(diào)用了特定的realSubject中的對應(yīng)的方法:
在上面的靜態(tài)代理模式下,Proxy所做的事情,無非是調(diào)用在不同的request時(shí),調(diào)用觸發(fā)realSubject對應(yīng)的方法;更抽象點(diǎn)看,Proxy所作的事情;在Java中 方法(Method)也是作為一個對象來看待了,動態(tài)代理工作的基本模式就是將自己的方法功能的實(shí)現(xiàn)交給 InvocationHandler角色,外界對Proxy角色中的每一個方法的調(diào)用,Proxy角色都會交給InvocationHandler來處理,而InvocationHandler則調(diào)用具體對象角色的方法。如下圖所示:
在這種模式之中:代理Proxy 和RealSubject 應(yīng)該實(shí)現(xiàn)相同的功能,這一點(diǎn)相當(dāng)重要。(我這里說的功能,可以理解為某個類的public方法)
在面向?qū)ο蟮木幊讨?,如果我們想要約定Proxy 和RealSubject可以實(shí)現(xiàn)相同的功能,有兩種方式:
a.一個比較直觀的方式,就是定義一個功能接口,然后讓Proxy 和RealSubject來實(shí)現(xiàn)這個接口。
b.還有比較隱晦的方式,就是通過繼承。因?yàn)槿绻鸓roxy 繼承自RealSubject,這樣Proxy則擁有了RealSubject的功能,Proxy還可以通過重寫RealSubject中的方法,來實(shí)現(xiàn)多態(tài)。
其中JDK中提供的創(chuàng)建動態(tài)代理的機(jī)制,是以a 這種思路設(shè)計(jì)的,而cglib 則是以b思路設(shè)計(jì)的。
JDK的動態(tài)代理創(chuàng)建機(jī)制----通過接口
比如現(xiàn)在想為RealSubject這個類創(chuàng)建一個動態(tài)代理對象,JDK主要會做以下工作:
1. 獲取 RealSubject上的所有接口列表;
2. 確定要生成的代理類的類名,默認(rèn)為:com.sun.proxy.$ProxyXXXX ;
3. 根據(jù)需要實(shí)現(xiàn)的接口信息,在代碼中動態(tài)創(chuàng)建 該P(yáng)roxy類的字節(jié)碼;
4 . 將對應(yīng)的字節(jié)碼轉(zhuǎn)換為對應(yīng)的class 對象;
5. 創(chuàng)建InvocationHandler 實(shí)例handler,用來處理Proxy所有方法調(diào)用;
6. Proxy 的class對象 以創(chuàng)建的handler對象為參數(shù),實(shí)例化一個proxy對象
JDK通過 java.lang.reflect.Proxy包來支持動態(tài)代理,一般情況下,我們使用下面的newProxyInstance方法
而對于InvocationHandler,我們需要實(shí)現(xiàn)下列的invoke方法:
在調(diào)用代理對象中的每一個方法時(shí),在代碼內(nèi)部,都是直接調(diào)用了InvocationHandler 的invoke方法,而invoke方法根據(jù)代理類傳遞給自己的method參數(shù)來區(qū)分是什么方法。
講的有點(diǎn)抽象,下面通過一個實(shí)例來演示一下吧:
JDK動態(tài)代理示例
現(xiàn)在定義兩個接口Vehicle和Rechargable,Vehicle表示交通工具類,有drive()方法;Rechargable接口表示可充電的(工具),有recharge() 方法;
定義一個實(shí)現(xiàn)兩個接口的類ElectricCar,類圖如下:
通過下面的代碼片段,來為ElectricCar創(chuàng)建動態(tài)代理類:
package com.foo.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; public class Test { public static void main(String[] args) { ElectricCar car = new ElectricCar(); // 1.獲取對應(yīng)的ClassLoader ClassLoader classLoader = car.getClass().getClassLoader(); // 2.獲取ElectricCar 所實(shí)現(xiàn)的所有接口 Class[] interfaces = car.getClass().getInterfaces(); // 3.設(shè)置一個來自代理傳過來的方法調(diào)用請求處理器,處理所有的代理對象上的方法調(diào)用 InvocationHandler handler = new InvocationHandlerImpl(car); /* 4.根據(jù)上面提供的信息,創(chuàng)建代理對象 在這個過程中, a.JDK會通過根據(jù)傳入的參數(shù)信息動態(tài)地在內(nèi)存中創(chuàng)建和.class 文件等同的字節(jié)碼 b.然后根據(jù)相應(yīng)的字節(jié)碼轉(zhuǎn)換成對應(yīng)的class, c.然后調(diào)用newInstance()創(chuàng)建實(shí)例 */ Object o = Proxy.newProxyInstance(classLoader, interfaces, handler); Vehicle vehicle = (Vehicle) o; vehicle.drive(); Rechargable rechargeable = (Rechargable) o; rechargeable.recharge(); } }
package com.foo.proxy; /** * 交通工具接口 * @author louluan */ public interface Vehicle { public void drive(); }
package com.foo.proxy; /** * 可充電設(shè)備接口 * @author louluan */ public interface Rechargable { public void recharge(); }
package com.foo.proxy; /** * 電能車類,實(shí)現(xiàn)Rechargable,Vehicle接口 * @author louluan */ public class ElectricCar implements Rechargable, Vehicle { @Override public void drive() { System.out.println("Electric Car is Moving silently..."); } @Override public void recharge() { System.out.println("Electric Car is Recharging..."); } }
package com.foo.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class InvocationHandlerImpl implements InvocationHandler { private ElectricCar car; public InvocationHandlerImpl(ElectricCar car) { this.car=car; } @Override public Object invoke(Object paramObject, Method paramMethod, Object[] paramArrayOfObject) throws Throwable { System.out.println("You are going to invoke "+paramMethod.getName()+" ..."); paramMethod.invoke(car, null); System.out.println(paramMethod.getName()+" invocation Has Been finished..."); return null; } }
來看一下代碼執(zhí)行后的結(jié)果:
生成動態(tài)代理類的字節(jié)碼并且保存到硬盤中:
JDK提供了sun.misc.ProxyGenerator.generateProxyClass(String proxyName,class[] interfaces) 底層方法來產(chǎn)生動態(tài)代理類的字節(jié)碼:
下面定義了一個工具類,用來將生成的動態(tài)代理類保存到硬盤中:
package com.foo.proxy; import java.io.FileOutputStream; import java.io.IOException; import java.lang.reflect.Proxy; import sun.misc.ProxyGenerator; public class ProxyUtils { /* * 將根據(jù)類信息 動態(tài)生成的二進(jìn)制字節(jié)碼保存到硬盤中, * 默認(rèn)的是clazz目錄下 * params :clazz 需要生成動態(tài)代理類的類 * proxyName : 為動態(tài)生成的代理類的名稱 */ public static void generateClassFile(Class clazz,String proxyName) { //根據(jù)類信息和提供的代理類名稱,生成字節(jié)碼 byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces()); String paths = clazz.getResource(".").getPath(); System.out.println(paths); FileOutputStream out = null; try { //保留到硬盤中 out = new FileOutputStream(paths+proxyName+".class"); out.write(classFile); out.flush(); } catch (Exception e) { e.printStackTrace(); } finally { try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } }
現(xiàn)在我們想將生成的代理類起名為“ElectricCarProxy”,并保存在硬盤,應(yīng)該使用以下語句:
ProxyUtils.generateClassFile(car.getClass(), "ElectricCarProxy");
這樣將在ElectricCar.class 同級目錄下產(chǎn)生 ElectricCarProxy.class文件。用反編譯工具如jd-gui.exe 打開,將會看到以下信息:
import com.foo.proxy.Rechargable; import com.foo.proxy.Vehicle; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; /** 生成的動態(tài)代理類的組織模式是繼承Proxy類,然后實(shí)現(xiàn)需要實(shí)現(xiàn)代理的類上的所有接口,而在實(shí)現(xiàn)的過程中,則是通過將所有的方法都交給了InvocationHandler來處理 */ public final class ElectricCarProxy extends Proxy implements Rechargable, Vehicle { private static Method m1; private static Method m3; private static Method m4; private static Method m0; private static Method m2; public ElectricCarProxy(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } public final boolean equals(Object paramObject) throws { try { // 方法功能實(shí)現(xiàn)交給InvocationHandler處理 return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue(); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final void recharge() throws { try { // 方法功能實(shí)現(xiàn)交給InvocationHandler處理 this.h.invoke(this, m3, null); return; } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final void drive() throws { try { // 方法功能實(shí)現(xiàn)交給InvocationHandler處理 this.h.invoke(this, m4, null); return; } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final int hashCode() throws { try { // 方法功能實(shí)現(xiàn)交給InvocationHandler處理 return ((Integer)this.h.invoke(this, m0, null)).intValue(); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final String toString() throws { try { // 方法功能實(shí)現(xiàn)交給InvocationHandler處理 return (String)this.h.invoke(this, m2, null); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } static { try { //為每一個需要方法對象,當(dāng)調(diào)用相應(yīng)的方法時(shí),分別將方法對象作為參數(shù)傳遞給InvocationHandler處理 m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("com.foo.proxy.Rechargable").getMethod("recharge", new Class[0]); m4 = Class.forName("com.foo.proxy.Vehicle").getMethod("drive", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } } }
仔細(xì)觀察可以看出生成的動態(tài)代理類有以下特點(diǎn):
1.繼承自 java.lang.reflect.Proxy,實(shí)現(xiàn)了 Rechargable,Vehicle 這兩個ElectricCar實(shí)現(xiàn)的接口;
2.類中的所有方法都是final 的;
3.所有的方法功能的實(shí)現(xiàn)都統(tǒng)一調(diào)用了InvocationHandler的invoke()方法。
cglib 生成動態(tài)代理類的機(jī)制----通過類繼承:
JDK中提供的生成動態(tài)代理類的機(jī)制有個鮮明的特點(diǎn)是: 某個類必須有實(shí)現(xiàn)的接口,而生成的代理類也只能代理某個類接口定義的方法,比如:如果上面例子的ElectricCar實(shí)現(xiàn)了繼承自兩個接口的方法外,另外實(shí)現(xiàn)了方法bee() ,則在產(chǎn)生的動態(tài)代理類中不會有這個方法了!更極端的情況是:如果某個類沒有實(shí)現(xiàn)接口,那么這個類就不能同JDK產(chǎn)生動態(tài)代理了!
幸好我們有cglib?!癈GLIB(Code Generation Library),是一個強(qiáng)大的,高性能,高質(zhì)量的Code生成類庫,它可以在運(yùn)行期擴(kuò)展Java類與實(shí)現(xiàn)Java接口?!?br/>cglib 創(chuàng)建某個類A的動態(tài)代理類的模式是:
1. 查找A上的所有非final 的public類型的方法定義;
2. 將這些方法的定義轉(zhuǎn)換成字節(jié)碼;
3. 將組成的字節(jié)碼轉(zhuǎn)換成相應(yīng)的代理的class對象;
4. 實(shí)現(xiàn) MethodInterceptor接口,用來處理 對代理類上所有方法的請求(這個接口和JDK動態(tài)代理InvocationHandler的功能和角色是一樣的)
一個有趣的例子:定義一個Programmer類,一個Hacker類
package samples; /** * 程序猿類 * @author louluan */ public class Programmer { public void code() { System.out.println("I'm a Programmer,Just Coding....."); } }
package samples; import java.lang.reflect.Method; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; /* * 實(shí)現(xiàn)了方法攔截器接口 */ public class Hacker implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("**** I am a hacker,Let's see what the poor programmer is doing Now..."); proxy.invokeSuper(obj, args); System.out.println("**** Oh,what a poor programmer....."); return null; } }
package samples; import net.sf.cglib.proxy.Enhancer; public class Test { public static void main(String[] args) { Programmer progammer = new Programmer(); Hacker hacker = new Hacker(); //cglib 中加強(qiáng)器,用來創(chuàng)建動態(tài)代理 Enhancer enhancer = new Enhancer(); //設(shè)置要創(chuàng)建動態(tài)代理的類 enhancer.setSuperclass(progammer.getClass()); // 設(shè)置回調(diào),這里相當(dāng)于是對于代理類上所有方法的調(diào)用,都會調(diào)用CallBack,而Callback則需要實(shí)行intercept()方法進(jìn)行攔截 enhancer.setCallback(hacker); Programmer proxy =(Programmer)enhancer.create(); proxy.code(); } }
程序執(zhí)行結(jié)果:
讓我們看看通過cglib生成的class文件內(nèi)容:
package samples; 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 Programmer EnhancerByCGLIB fa7aa2cd extends Programmer implements Factory { //......省略 private MethodInterceptor CGLIB$CALLBACK_0; // Enchaner傳入的methodInterceptor // ....省略 public final void code() { MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0; if (tmp4_1 == null) { tmp4_1; CGLIB$BIND_CALLBACKS(this);//若callback 不為空,則調(diào)用methodInterceptor 的intercept()方法 } if (this.CGLIB$CALLBACK_0 != null) return; //如果沒有設(shè)置callback回調(diào)函數(shù),則默認(rèn)執(zhí)行父類的方法 super.code(); } //....后續(xù)省略 }
上述內(nèi)容就是從另一個角度理解Java中的動態(tài)代理機(jī)制,你們學(xué)到知識或技能了嗎?如果還想學(xué)到更多技能或者豐富自己的知識儲備,歡迎關(guān)注億速云行業(yè)資訊頻道。
免責(zé)聲明:本站發(fā)布的內(nèi)容(圖片、視頻和文字)以原創(chuàng)、轉(zhuǎn)載和分享為主,文章觀點(diǎn)不代表本網(wǎng)站立場,如果涉及侵權(quán)請聯(lián)系站長郵箱:is@yisu.com進(jìn)行舉報(bào),并提供相關(guān)證據(jù),一經(jīng)查實(shí),將立刻刪除涉嫌侵權(quán)內(nèi)容。