class转java_java动态代理实现与原理详细分析
關(guān)于Java中的動態(tài)代理，我們首先需要了解的是一種常用的設(shè)計模式--代理模式，而對于代理，根據(jù)創(chuàng)建代理類的時間點，又可以分為靜態(tài)代理和動態(tài)代理。
?一、代理模式
? ?代理模式是常用的java設(shè)計模式，他的特征是代理類與委托類有同樣的接口，代理類主要負責(zé)為委托類預(yù)處理消息、過濾消息、把消息轉(zhuǎn)發(fā)給委托類，以及事后處理消息等。代理類與委托類之間通常會存在關(guān)聯(lián)關(guān)系，一個代理類的對象與一個委托類的對象關(guān)聯(lián)，代理類的對象本身并不真正實現(xiàn)服務(wù)，而是通過調(diào)用委托類的對象的相關(guān)方法，來提供特定的服務(wù)。簡單的說就是，我們在訪問實際對象時，是通過代理對象來訪問的，代理模式就是在訪問實際對象時引入一定程度的間接性，因為這種間接性，可以附加多種用途。在后面我會
解釋這種間接性帶來的好處。代理模式結(jié)構(gòu)圖(圖片來自《大話設(shè)計模式》)：
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??
二、靜態(tài)代理
? ??1、靜態(tài)代理
靜態(tài)代理：由程序員創(chuàng)建或特定工具自動生成源代碼，也就是在編譯時就已經(jīng)將接口，被代理類，代理類等確定下來。在程序運行之前，代理類的.class文件就已經(jīng)生成。
? ??2、靜態(tài)代理簡單實現(xiàn)
? 根據(jù)上面代理模式的類圖，來寫一個簡單的靜態(tài)代理的例子。我這兒舉一個比較粗糙的例子，假如一個班的同學(xué)要向老師交班費，但是都是通過班長把自己的錢轉(zhuǎn)交給老師。這里，班長就是代理學(xué)生上交班費，
班長就是學(xué)生的代理。
? ? 首先，我們創(chuàng)建一個Person接口。這個接口就是學(xué)生(被代理類)，和班長(代理類)的公共接口，他們都有上交班費的行為。這樣，學(xué)生上交班費就可以讓班長來代理執(zhí)行。/**
* 創(chuàng)建Person接口 * @author Gonjan */public interface Person { //上交班費 void giveMoney();}Student類實現(xiàn)Person接口。Student可以具體實施上交班費的動作。
public class Student implements Person { private String name; public Student(String name) { this.name = name; } @Override public void giveMoney() { System.out.println(name + "上交班費50元"); }}StudentsProxy類，這個類也實現(xiàn)了Person接口，但是還另外持有一個學(xué)生類對象，由于實現(xiàn)了Peson接口，同時持有一個學(xué)生對象，那么他可以代理學(xué)生類對象執(zhí)行上交班費(執(zhí)行g(shù)iveMoney()方法)行為。
/** * 學(xué)生代理類，也實現(xiàn)了Person接口，保存一個學(xué)生實體，這樣既可以代理學(xué)生產(chǎn)生行為 * @author Gonjan * */public class StudentsProxy implements Person{ //被代理的學(xué)生 Student stu; public StudentsProxy(Person stu) { // 只代理學(xué)生對象 if(stu.getClass() == Student.class) { this.stu = (Student)stu; } } //代理上交班費，調(diào)用被代理學(xué)生的上交班費行為 public void giveMoney() { stu.giveMoney(); }}下面測試一下，看如何使用代理模式：public class StaticProxyTest { public static void main(String[] args) { //被代理的學(xué)生張三，他的班費上交有代理對象monitor(班長)完成 Person zhangsan = new Student("張三"); //生成代理對象，并將張三傳給代理對象 Person monitor = new StudentsProxy(zhangsan); //班長代理上交班費 monitor.giveMoney(); }}運行結(jié)果：
這里并沒有直接通過張三(被代理對象)來執(zhí)行上交班費的行為，而是通過班長(代理對象)來代理執(zhí)行了。這就是代理模式。
代理模式最主要的就是有一個公共接口(Person)，一個具體的類(Student)，一個代理類(StudentsProxy),代理類持有具體類的實例，代為執(zhí)行具體類實例方法。上面說到，代理模式就是在訪問實際對象時引入一定程度的間接性，因為這種間接性，可以附加多種用途。這里的間接性就是指不直接調(diào)用實際對象的方法，那么我們在代理過程中就可以加上一些其他用途。就這個例子來說，加入班長在幫張三上交班費之前想要先反映一下張三最近學(xué)習(xí)有很大進步，通過代理模式很輕松就能辦到：
public class StudentsProxy implements Person{ //被代理的學(xué)生 Student stu; public StudentsProxy(Person stu) { // 只代理學(xué)生對象 if(stu.getClass() == Student.class) { this.stu = (Student)stu; } } //代理上交班費，調(diào)用被代理學(xué)生的上交班費行為 public void giveMoney() { System.out.println("張三最近學(xué)習(xí)有進步！"); stu.giveMoney(); }}運行結(jié)果：
可以看到，只需要在代理類中幫張三上交班費之前，執(zhí)行其他操作就可以了。這種操作，也是使用代理模式的一個很大的優(yōu)點。最直白的就是在Spring中的面向切面編程(AOP)，我們能在一個切點之前執(zhí)行一些操作，在一個切點之后執(zhí)行一些操作，這個切點就是一個個方法。這些方法所在類肯定就是被代理了，在代理過程中切入了一些其他操作。
三、動態(tài)代理
? ???1.動態(tài)代理
? ??代理類在程序運行時創(chuàng)建的代理方式被成為動態(tài)代理。我們上面靜態(tài)代理的例子中，代理類(studentProxy)是自己定義好的，在程序運行之前就已經(jīng)編譯完成。然而動態(tài)代理，代理類并不是在Java代碼中定義的，而是在運行時根據(jù)我們在Java代碼中的“指示”動態(tài)生成的。相比于靜態(tài)代理， 動態(tài)代理的優(yōu)勢在于可以很方便的對代理類的函數(shù)進行統(tǒng)一的處理，而不用修改每個代理類中的方法。比如說，想要在每個代理的方法前都加上一個處理方法：
public void giveMoney() { //調(diào)用被代理方法前加入處理方法 beforeMethod(); stu.giveMoney(); }?這里只有一個giveMoney方法，就寫一次beforeMethod方法，但是如果出了giveMonney還有很多其他的方法，那就需要寫很多次beforeMethod方法，麻煩。那看看下面動態(tài)代理如何實現(xiàn)。
? ? ?2、動態(tài)代理簡單實現(xiàn)
在java的java.lang.reflect包下提供了一個Proxy類和一個InvocationHandler接口，通過這個類和這個接口可以生成JDK動態(tài)代理類和動態(tài)代理對象。
創(chuàng)建一個動態(tài)代理對象步驟，具體代碼見后面：
創(chuàng)建一個InvocationHandler對象
到這里肯定都會很疑惑，這動態(tài)代理到底是如何執(zhí)行的，是如何通過代理對象來執(zhí)行被代理對象的方法的，先不急，我們先看看一個簡單的完整的動態(tài)代理的例子。還是上面靜態(tài)代理的例子，班長需要幫學(xué)生代交班費。首先是定義一個Person接口:
/** * 創(chuàng)建Person接口 * @author Gonjan */public interface Person { //上交班費 void giveMoney();}創(chuàng)建需要被代理的實際類：
public class Student implements Person { private String name; public Student(String name) { this.name = name; } @Override public void giveMoney() { try { //假設(shè)數(shù)錢花了一秒時間 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(name + "上交班費50元"); }}再定義一個檢測方法執(zhí)行時間的工具類，在任何方法執(zhí)行前先調(diào)用start方法，執(zhí)行后調(diào)用finsh方法，就可以計算出該方法的運行時間，這也是一個最簡單的方法執(zhí)行時間檢測工具。
public class MonitorUtil { private static ThreadLocal tl = new ThreadLocal<>(); public static void start() { tl.set(System.currentTimeMillis()); } //結(jié)束時打印耗時 public static void finish(String methodName) { long finishTime = System.currentTimeMillis(); System.out.println(methodName + "方法耗時" + (finishTime - tl.get()) + "ms"); }}創(chuàng)建StuInvocationHandler類，實現(xiàn)InvocationHandler接口，這個類中持有一個被代理對象的實例target。InvocationHandler中有一個invoke方法，所有執(zhí)行代理對象的方法都會被替換成執(zhí)行invoke方法。
再再invoke方法中執(zhí)行被代理對象target的相應(yīng)方法。當(dāng)然，在代理過程中，我們在真正執(zhí)行被代理對象的方法前加入自己其他處理。這也是Spring中的AOP實現(xiàn)的主要原理，這里還涉及到一個很重要的關(guān)于java反射方面的基礎(chǔ)知識。
public class StuInvocationHandler<T> implements InvocationHandler { //invocationHandler持有的被代理對象 T target; public StuInvocationHandler(T target) { this.target = target; } /** * proxy:代表動態(tài)代理對象 * method：代表正在執(zhí)行的方法 * args：代表調(diào)用目標方法時傳入的實參 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("代理執(zhí)行" +method.getName() + "方法"); */ //代理過程中插入監(jiān)測方法,計算該方法耗時 MonitorUtil.start(); Object result = method.invoke(target, args); MonitorUtil.finish(method.getName()); return result; }}做完上面的工作后，我們就可以具體來創(chuàng)建動態(tài)代理對象了，上面簡單介紹了如何創(chuàng)建動態(tài)代理對象，我們使用簡化的方式創(chuàng)建動態(tài)代理對象：
public class ProxyTest { public static void main(String[] args) { //創(chuàng)建一個實例對象，這個對象是被代理的對象 Person zhangsan = new Student("張三"); //創(chuàng)建一個與代理對象相關(guān)聯(lián)的InvocationHandler InvocationHandler stuHandler = new StuInvocationHandler(zhangsan); //創(chuàng)建一個代理對象stuProxy來代理zhangsan，代理對象的每個執(zhí)行方法都會替換執(zhí)行Invocation中的invoke方法 Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class>[]{Person.class}, stuHandler)； //代理執(zhí)行上交班費的方法 stuProxy.giveMoney(); }}我們執(zhí)行這個ProxyTest類，先想一下，我們創(chuàng)建了一個需要被代理的學(xué)生張三，將zhangsan對象傳給了stuHandler中，我們在創(chuàng)建代理對象stuProxy時，將stuHandler作為參數(shù)了的，上面也有說到所有執(zhí)行代理對象的方法都會被替換成執(zhí)行invoke方法，也就是說，最后執(zhí)行的是StuInvocationHandler中的invoke方法。所以在看到下面的運行結(jié)果也就理所當(dāng)然了。
運行結(jié)果：
上面說到，動態(tài)代理的優(yōu)勢在于可以很方便的對代理類的函數(shù)進行統(tǒng)一的處理，而不用修改每個代理類中的方法。是因為所有被代理執(zhí)行的方法，都是通過在InvocationHandler中的invoke方法調(diào)用的，所以我們只要在invoke方法中統(tǒng)一處理，就可以對所有被代理的方法進行相同的操作了。例如，這里的方法計時，所有的被代理對象執(zhí)行的方法都會被計時，然而我只做了很少的代碼量。
動態(tài)代理的過程，代理對象和被代理對象的關(guān)系不像靜態(tài)代理那樣一目了然，清晰明了。因為動態(tài)代理的過程中，我們并沒有實際看到代理類，也沒有很清晰地的看到代理類的具體樣子，而且動態(tài)代理中被代理對象和代理對象是通過InvocationHandler來完成的代理過程的，其中具體是怎樣操作的，為什么代理對象執(zhí)行的方法都會通過InvocationHandler中的invoke方法來執(zhí)行。帶著這些問題，我們就需要對java動態(tài)代理的源碼進行簡要的分析，弄清楚其中緣由。
四、動態(tài)代理原理分析
? ? 1、Java動態(tài)代理創(chuàng)建出來的動態(tài)代理類
上面我們利用Proxy類的newProxyInstance方法創(chuàng)建了一個動態(tài)代理對象，查看該方法的源碼，發(fā)現(xiàn)它只是封裝了創(chuàng)建動態(tài)代理類的步驟(紅色標準部分)：
public static Object newProxyInstance(ClassLoader loader, Class>[] interfaces, InvocationHandler h) throws IllegalArgumentException{ Objects.requireNonNull(h); final Class>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } /* * Look up or generate the designated proxy class. */ Class> cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } final Constructor> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction() { public Void run() { cons.setAccessible(true); return null; } }); } return cons.newInstance(new Object[]{h}); } catch (IllegalAccessException|InstantiationException e) { throw new InternalError(e.toString(), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalError(t.toString(), t); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString(), e); } }其實，我們最應(yīng)該關(guān)注的是 Class> cl = getProxyClass0(loader, intfs);這句，這里產(chǎn)生了代理類，后面代碼中的構(gòu)造器也是通過這里產(chǎn)生的類來獲得，可以看出，這個類的產(chǎn)生就是整個動態(tài)代理的關(guān)鍵，由于是動態(tài)生成的類文件，我這里不具體進入分析如何產(chǎn)生的這個類文件，只需要知道這個類文件時緩存在java虛擬機中的，我們可以通過下面的方法將其打印到文件里面，一睹真容：
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Student.class.getInterfaces()); String path = "G:/javacode/javase/Test/bin/proxy/StuProxy.class"; try(FileOutputStream fos = new FileOutputStream(path)) { fos.write(classFile); fos.flush(); System.out.println("代理類class文件寫入成功"); } catch (Exception e) { System.out.println("寫文件錯誤"); }對這個class文件進行反編譯，我們看看jdk為我們生成了什么樣的內(nèi)容：
import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;import proxy.Person;public final class $Proxy0 extends Proxy implements Person{ private static Method m1; private static Method m2; private static Method m3; private static Method m0; /** *注意這里是生成代理類的構(gòu)造方法，方法參數(shù)為InvocationHandler類型，看到這，是不是就有點明白 *為何代理對象調(diào)用方法都是執(zhí)行InvocationHandler中的invoke方法，而InvocationHandler又持有一個 *被代理對象的實例，不禁會想難道是....？沒錯，就是你想的那樣。 * *super(paramInvocationHandler)，是調(diào)用父類Proxy的構(gòu)造方法。 *父類持有：protected InvocationHandler h; *Proxy構(gòu)造方法： * protected Proxy(InvocationHandler h) { * Objects.requireNonNull(h); * this.h = h; * } * */ public $Proxy0(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } //這個靜態(tài)塊本來是在最后的，我把它拿到前面來，方便描述 static { try { //看看這兒靜態(tài)塊兒里面有什么，是不是找到了giveMoney方法。請記住giveMoney通過反射得到的名字m3，其他的先不管 m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m3 = Class.forName("proxy.Person").getMethod("giveMoney", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } } /** * *這里調(diào)用代理對象的giveMoney方法，直接就調(diào)用了InvocationHandler中的invoke方法，并把m3傳了進去。 *this.h.invoke(this, m3, null);這里簡單，明了。 *來，再想想，代理對象持有一個InvocationHandler對象，InvocationHandler對象持有一個被代理的對象， *再聯(lián)系到InvacationHandler中的invoke方法。嗯，就是這樣。 */ public final void giveMoney() throws { try { this.h.invoke(this, m3, null); return; } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } //注意，這里為了節(jié)省篇幅，省去了toString，hashCode、equals方法的內(nèi)容。原理和giveMoney方法一毛一樣。}jdk為我們的生成了一個叫$Proxy0(這個名字后面的0是編號，有多個代理類會一次遞增)的代理類，這個類文件時放在內(nèi)存中的，我們在創(chuàng)建代理對象時，就是通過反射獲得這個類的構(gòu)造方法，然后創(chuàng)建的代理實例。通過對這個生成的代理類源碼的查看，我們很容易能看出，動態(tài)代理實現(xiàn)的具體過程。
我們可以對InvocationHandler看做一個中介類，中介類持有一個被代理對象，在invoke方法中調(diào)用了被代理對象的相應(yīng)方法。通過聚合方式持有被代理對象的引用，把外部對invoke的調(diào)用最終都轉(zhuǎn)為對被代理對象的調(diào)用。
代理類調(diào)用自己方法時，通過自身持有的中介類對象來調(diào)用中介類對象的invoke方法，從而達到代理執(zhí)行被代理對象的方法。也就是說，動態(tài)代理通過中介類實現(xiàn)了具體的代理功能。
五、總結(jié)
生成的代理類：$Proxy0 extends Proxy implements Person，我們看到代理類繼承了Proxy類，所以也就決定了java動態(tài)代理只能對接口進行代理，Java的繼承機制注定了這些動態(tài)代理類們無法實現(xiàn)對class的動態(tài)代理。
上面的動態(tài)代理的例子，其實就是AOP的一個簡單實現(xiàn)了，在目標對象的方法執(zhí)行之前和執(zhí)行之后進行了處理，對方法耗時統(tǒng)計。Spring的AOP實現(xiàn)其實也是用了Proxy和InvocationHandler這兩個東西的。
后面補充，知其然，還要知其所以然。
總結(jié)
以上是生活随笔為你收集整理的class转java_java动态代理实现与原理详细分析的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： vue为p标签_通过vue.js几个基本
- 下一篇： 网络安全等保定级_差异：关键信息基础设施