java的代理機制

① java動態代理與靜態代理的定義與區別

JAVA的靜態代理與動態代理比較
一、概念
代理模式是常用的Java 設計模式，它的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理消息、過濾消息、把消息轉發給委託類，以及事後處理消息等。代理類與委託類之間通常會存在關聯關系，一個代理類的對象與一個委託類的對象關聯，代理類的對象本身並不真正實現服務，而是通過調用委託類的對象的相關方法，來提供特定的服務。按照代理類的創建時期，代理類可分為兩種。

靜態代理類：
由程序員創建或由特定工具自動生成源代碼，再對其編譯。在程序運行前，代理類的.class文件就已經存在了。動態代理類：在程序運行時，運用反射機制動態創建而成。

二、靜態代理類
如下， HelloServiceProxy 類是代理類，HelloServiceImpl類是委託類，這兩個類都實現了HelloService介面。其中HelloServiceImpl類是HelloService介面的真正實現者，而HelloServiceProxy類是通過調用HelloServiceImpl 類的相關方法來提供特定服務的。HelloServiceProxy類的echo()方法和getTime()方法會分別調用被代理的HelloServiceImpl 對象的echo()方法和getTime()方法，並且在方法調用前後都會執行一些簡單的列印操作。

由此可見，代理類可以為委託類預處理消息、把消息轉發給委託類和事後處理消息等。

常式1 HelloService.java
package proxy;
import java.util.Date;
public interface HelloService{
public String echo(String msg);
public Date getTime();
}
常式2 HelloServiceImpl.java
package proxy;
import java.util.Date;
public class HelloServiceImpl implements HelloService{
public String echo(String msg){
return "echo:"+msg;
}
public Date getTime(){
return new Date();
}
}
常式3 HelloServiceProxy.java
package proxy;
import java.util.Date;
public class HelloServiceProxy implements HelloService{
private HelloService helloService; //表示被代理的HelloService 實例
public HelloServiceProxy(HelloService helloService){
this.helloService=helloService;
}
public void setHelloServiceProxy(HelloService helloService){
this.helloService=helloService;
}
public String echo(String msg){
System.out.println("before calling echo()"); //預處理
String result=helloService.echo(msg); //調用被代理的HelloService 實例的echo()方法
System.out.println("after calling echo()"); //事後處理
return result;
}
public Date getTime(){
System.out.println("before calling getTime()"); //預處理
Date date=helloService.getTime(); //調用被代理的HelloService 實例的getTime()方法
System.out.println("after calling getTime()"); //事後處理
return date;
}
}
在Client1 類的main()方法中，先創建了一個HelloServiceImpl對象，又創建了一個HelloServiceProxy對象，最後調用HelloServiceProxy對象的echo()方法。
常式4 Client1.java
package proxy;
public class Client1{
public static void main(String args[]){
HelloService helloService=new HelloServiceImpl();
HelloService helloServiceProxy=new HelloServiceProxy(helloService);
System.out.println(helloServiceProxy.echo("hello"));
}
}
運行Client1 類，列印結果如下：
before calling echo()
after calling echo()
echo:hello
常式3 的HelloServiceProxy 類的源代碼是由程序員編寫的，在程序運行前，它的.class文件就已經存在了，這種代理類稱為靜態代理類。

三、動態代理類
與靜態代理類對照的是動態代理類，動態代理類的位元組碼在程序運行時由Java反射機制動態生成，無需程序員手工編寫它的源代碼。動態代理類不僅簡化了編程工作，而且提高了軟體系統的可擴展性，因為Java 反射機制可以生成任意類型的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。

Proxy類提供了創建動態代理類及其實例的靜態方法。
（1）getProxyClass()靜態方法負責創建動態代理類，它的完整定義如下：

public static Class<?> getProxyClass(ClassLoader loader, Class<?>[] interfaces) throws IllegalArgumentException

參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面。

（2）newProxyInstance()靜態方法負責創建動態代理類的實例，它的完整定義如下：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws
IllegalArgumentException

參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面，參數handler 指定與動態代理類關聯的 InvocationHandler 對象。

以下兩種方式都創建了實現Foo介面的動態代理類的實例：
/**** 方式一 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);

//創建動態代理類
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });

//創建動態代理類的實例
Foo foo = (Foo) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });

/**** 方式二 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);

//直接創建動態代理類的實例
Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[] { Foo.class }, handler);

由Proxy類的靜態方法創建的動態代理類具有以下特點：
動態代理類是public、final和非抽象類型的；
動態代理類繼承了java.lang.reflect.Proxy類；
動態代理類的名字以「$Proxy」開頭；
動態代理類實現getProxyClass()和newProxyInstance()方法中參數interfaces指定的所有介面；

Proxy 類的isProxyClass(Class<?> cl)靜態方法可用來判斷參數指定的類是否為動態代理類。只有通過Proxy類創建的類才是動態代理類；

動態代理類都具有一個public 類型的構造方法，該構造方法有一個InvocationHandler 類型的參數。

由Proxy類的靜態方法創建的動態代理類的實例具有以下特點：
1. 假定變數foo 是一個動態代理類的實例，並且這個動態代理類實現了Foo 介面，那麼「foo instanceof Foo」的值為true。把變數foo強制轉換為Foo類型是合法的：
(Foo) foo //合法

2.每個動態代理類實例都和一個InvocationHandler 實例關聯。Proxy 類的getInvocationHandler(Object proxy)靜態方法返回與參數proxy指定的代理類實例所關聯的InvocationHandler 對象。

3.假定Foo介面有一個amethod()方法，那麼當程序調用動態代理類實例foo的amethod()方法時，該方法會調用與它關聯的InvocationHandler 對象的invoke()方法。

InvocationHandler 介面為方法調用介面，它聲明了負責調用任意一個方法的invoke()方法：
Object invoke(Object proxy,Method method,Object[] args) throws Throwable

參數proxy指定動態代理類實例，參數method指定被調用的方法，參數args 指定向被調用方法傳遞的參數，invoke()方法的返回值表示被調用方法的返回值。

四、最後看一個實例：
HelloServiceProxyFactory 類的getHelloServiceProxy()靜態方法負責創建實現了HelloService介面的動態代理類的實例。

常式5 HelloServiceProxyFactory.java
package proxy;
import java.lang.reflect.*;
public class HelloServiceProxyFactory {
/** 創建一個實現了HelloService 介面的動態代理類的實例
* 參數helloService 引用被代理的HelloService 實例
*/
public static HelloService getHelloServiceProxy(final HelloService helloService){
//創建一個實現了InvocationHandler介面的匿名類的實例
InvocationHandler handler=new InvocationHandler(){
public Object invoke(Object proxy,Method method,Object args[])throws Exception{
System.out.println("before calling "+method); //預處理
Object result=method.invoke(helloService,args);
//調用被代理的HelloService 實例的方法
System.out.println("after calling "+method); //事後處理
return result;
}
};
Class classType=HelloService.class;
return (HelloService)Proxy.newProxyInstance(classType.getClassLoader(),
new Class[]{classType},
handler);
}
}
如下所示的Client2 類先創建了一個HelloServiceImpl 實例，然後創建了一個動態代理類實例helloServiceProxy，最後調用動態代理類實例的echo()方法。
常式6 Client2.java
package proxy;
public class Client2{
public static void main(String args[]){
HelloService helloService=new HelloServiceImpl();
HelloService helloServiceProxy=HelloServiceProxyFactory.getHelloServiceProxy(helloService);
System.out.println("動態代理類的名字為"+helloServiceProxy.getClass().getName());
System.out.println(helloServiceProxy.echo("Hello"));
}
}
運行Client2，列印結果如下：
動態代理類的名字為$Proxy0
before calling public abstract java.lang.String proxy.HelloService.echo(java.lang.String)
after calling public abstract java.lang.String proxy.HelloService.echo(java.lang.String)
echo:Hello
從結果看出，動態代理類的名字為$Proxy0。

② 想用java編寫個代理伺服器，求具體一些思路，詳細一些，謝謝

在編寫代理伺服器之前，首先應該明白一點，Java的代理機制，如圖所示：

那麼Java就處於中間這層代理伺服器，代理伺服器所作的事情如下：
1、接收客戶端請求，進行處理，然後發送給服務端
2、接收服務端響應，進行處理，然後發送給客戶端
這樣，就更清晰了，Java提供了代理的API為，java.net.Proxy類。此類表示代理設置，通常為類型（http、socks）和套接字地址。Proxy 是不可變對象。

也就是說Java可以製作高級協議的代理，如 HTTP 或 FTP。也可以製作SOCKS（V4 或 V5）代理。
首先，使用到了URL類，HttpURLConnection類及其我們的代理類Proxy類。他們都位於java.net包中。

第一步：生成代理，指定埠為8888：

第二步：使用URLConnection類進行連接www.moonsos.com

第三步：打開URL，並且讀取HTML源碼

③ java中提供了兩種動態機制分別是

反射機制和動態代理
反射機制： 運行時信息(RunTime Type Information,RTTI)使得可以在程序運行時發現和使用類型信息。RTTI主要用來運行時獲取向上轉型之後的對象到底是什麼具體的類型。
動態代理： 所謂Dynamic Proxy是這樣一種class：它是在運行時生成的class，在生成它時必須提供一組interface給它，然後該class就宣稱它實現了這些 interface。當然可以把該class的實例當作這些interface中的任何一個來用。當然啦，這個Dynamic Proxy其實就是一個Proxy，它不會替你作實質性的工作，在生成它的實例時必須提供一個handler，由它接管實際的工作
JAVA自帶的動態代理是基於java.lang.reflect.Proxy、java.lang.reflect.InvocationHandler兩個類來完成的，使用JAVA反射機制

④ java 動態代理是基於什麼原理

反射機制是java語言提供的一種基礎功能，賦予程序在運行時自省的能力。通過反射我們可以直接操作類或者對象，比如獲取某個對象的類定義，獲取類聲明的屬性和方法，調用方法或者構造對象，甚至可以運行時修改類定義。
動態代理是一種方便運行時動態構建代理、動態處理代理方法調用的機制，很多場景都是利用類似機製做到的，比如用來包裝RPC調用、面向切面的編程。
實現動態代理的方式很多，比如JDK自身提供的動態代理，就是主要利用了上面提到的反射機制。還有其他的實現方式，比如利用傳說中更高性能的位元組碼操作機制，類似ASM、aglib、Javassist等。

⑤ java靜態代理與動態代理的區別

JAVA的靜態代理與動態代理比較
1.靜態代理類：
由程序員創建或由特定工具自動生成源代碼，再對其編譯。在程序運行前，代理類的.class文件就已經存在了。動態代理類：在程序運行時，運用反射機制動態創建而成。
由此可見，代理類可以為委託類預處理消息、把消息轉發給委託類和事後處理消息等。
常式1 HelloService.java
package proxy;
import java.util.Date;
public interface HelloService{
public String echo(String msg);
public Date getTime();
}
2.動態代理類
與靜態代理類對照的是動態代理類，動態代理類的位元組碼在程序運行時由Java反射機制動態生成，無需程序員手工編寫它的源代碼。動態代理類不僅簡化了編程工作，而且提高了軟體系統的可擴展性，因為Java 反射機制可以生成任意類型的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 介面提供了生成動態代理類的能力。

Proxy類提供了創建動態代理類及其實例的靜態方法。
（1）getProxyClass()靜態方法負責創建動態代理類，它的完整定義如下：
public static Class<?> getProxyClass(ClassLoader loader, Class<?>[] interfaces) throws IllegalArgumentException
參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面。
（2）newProxyInstance()靜態方法負責創建動態代理類的實例，它的完整定義如下：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws
IllegalArgumentException
參數loader 指定動態代理類的類載入器，參數interfaces 指定動態代理類需要實現的所有介面，參數handler 指定與動態代理類關聯的 InvocationHandler 對象。
以下兩種方式都創建了實現Foo介面的動態代理類的實例：
/**** 方式一 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);
//創建動態代理類
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });
//創建動態代理類的實例
Foo foo = (Foo) proxyClass.getConstructor(new Class[] { InvocationHandler.class }).
newInstance(new Object[] { handler });
/**** 方式二 ****/
//創建InvocationHandler對象
InvocationHandler handler = new MyInvocationHandler(...);
//直接創建動態代理類的實例
Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[] { Foo.class }, handler);
由Proxy類的靜態方法創建的動態代理類具有以下特點：
動態代理類是public、final和非抽象類型的；
動態代理類繼承了java.lang.reflect.Proxy類；
動態代理類的名字以「$Proxy」開頭；
動態代理類實現getProxyClass()和newProxyInstance()方法中參數interfaces指定的所有介面；

⑥ java的代理模式有何用，直接調用用實現類不就行了嗎，幹嘛多此一舉呢。。。。

使用代理類可以在實現類的基礎上進行擴展，可以在方法中動態加入代碼。這里要理解的是，實現類和代理類都是繼承了同一個介面的(必須的)舉個例子，如果你要通過一個實現類，將文本控制項中輸入的數字，做 加減乘除(也許還有很多運算) 法的運算，你發現這樣會有一些問題存在，字元串如果不能轉換成數字，就會報錯。那麼，你必須在方法的開頭加入驗證判斷。但是，你又發現每個方法都要寫驗證是很麻煩的，而且代碼量也會很多。於是你將驗證抽取出來，成為一個方法。 每個運算方法都在開頭調用這個驗證就行了。這樣是沒有問題的。然而，如果這個實現類不是你寫的，是A程序員寫的，而A程序員覺得他無法知道，使用這個實現類的程序員是否希望驗證這個字元串，所以，他把字元串的驗證工作交給了調用的程序員。而你在使用這個實現類的時候，你不能修改這個實現類，給他的每個方法開頭加入字元串的驗證。那麼怎麼去讓這個實現類的每個運算方法都在調用前都去驗證一下呢？代理就可以動態的在每個方法前加入驗證，比如add(int，int)方法，如果調用代理類的方法，代理類將先做驗證，然後再去調用實現類的方法。這個是有必要的，因為代理的動態的加入驗證代碼，不需要每個方法錢都加入驗證。最後總結一下，代理的作用大多是實現類的實現，對於調用者特定功能來說，做的還不夠，這代理，可以加入那些還不夠的代碼，然後再去調用實現類。

⑦ JAVA動態代理設計原理及如何實現

Java動態代理機制的出現，使得Java開發人員不用手工編寫代理類，只要簡單地制定一組介面及委託類對象，便能動態地獲得代理類。代理類會負責將所有的方法調用分配到委託對象上反射執行，配置執行過程中，開發人員還可以進行修改

代理設計模式

代理是一種常用的設計模式，其目的就是為其他對象提供一個代理以控制對某個對象的訪問。代理類負責為委託類預處理消息、過濾消息並轉發消息，以及進行消息被委託類執行後的後續處理。

1. 為了保持行為的一致性，代理類和委託類通常會實現相同的介面

2. 引入代理能夠控制對委託對象的直接訪問，可以很好的隱藏和保護委託對象，也更加具有靈活性

代理機制及其特點

首先讓我們來了解一下如何使用 Java 動態代理。具體有如下四步驟：

1. 通過實現 InvocationHandler 介面創建自己的調用處理器；

2. 通過為 Proxy 類指定 ClassLoader 對象和一組 interface 來創建動態代理類；

3. 通過反射機制獲得動態代理類的構造函數，其唯一參數類型是調用處理器介面類型；

4. 通過構造函數創建動態代理類實例，構造時調用處理器對象作為參數被傳入。

代理類實例的一些特點

1. 每個實例都會關聯一個InvocationHandler(調用處理器對象)，在代理類實例上調用其代理介面中聲明的方法時，最終都會由InvocationHandler的invoke方法執行；

2. java.lang.Object中有三個方法也同樣會被分派到調用處理器的 invoke 方法執行，它們是 hashCode，equals 和 toString；

代碼示例

最後以一個簡單的動態代理例子結束

⑧ Java代理的作用和實現

JDK 動態代理

動態代理的核心其實就是代理對象的生成，即 Proxy.newProxyInstance(classLoader, proxyInterface, handler)。

讓我們進入newProxyInstance方法觀摩下，核心代碼其實就三行。

這個方法需要三個參數：

• ClassLoader，用於載入代理類的 Loader 類，通常這個 Loader 和被代理的類是同一個 Loader 類。

• Interfaces，是要被代理的那些那些介面。

• InvocationHandler，就是用於執行除了被代理介面中方法之外的用戶自定義的操作，也是用戶需要代理的最終目的。用戶調用目標方法都被代理到 InvocationHandler 類中定義的唯一方法 invoke 中。

• //獲取代理類 Class cl = getProxyClass(loader, interfaces);


• //獲取帶有InvocationHandler參數的構造方法 Constructor cons = cl.getConstructor(constructorParams);


• //把handler傳入構造方法生成實例 return (Object) cons.newInstance(new Object[] { h });



一個典型的動態代理創建對象過程可分為以下四個步驟：

1、通過實現InvocationHandler介面創建調用處理器

• IvocationHandler handler = new InvocationHandlerImpl(...);



2、通過為Proxy類指定ClassLoader對象和一組interface創建動態代理類

• Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});



3、通過反射機制獲取動態代理類的構造函數，其參數類型是調用處理器介面類型

• Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});



4、通過構造函數創建代理類實例，此時需將調用處理器對象作為參數被傳入

• Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));



為了簡化對象創建過程，Proxy類中的newProxyInstance方法封裝了2~4，只需兩步即可完成代理對象的創建。

• Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),


• new Class[]{Subject.class}, new InvocationHandlerImpl (real));



生成的proxySubject繼承Proxy類實現Subject介面。實現的Subject的方法實際是調用處理器的invoke方法，而invoke方法利用反射調用的是被代理對象的方法（Object result=method.invoke(proxied,args)）；
重點Proxy.newProxyInstance，源碼分析，會在其他文檔中單獨總結記錄。類Proxy的getProxyClass方法調用ProxyGenerator的 generateProxyClass方法產生ProxySubject.class的二進制數據。

創建代理對象時序圖



獲取代理類

getProxyClass(loader, interfaces)方法用於獲取代理類，它主要做了三件事情：

在當前類載入器的緩存里搜索是否有代理類，沒有則生成代理類並緩存在本地JVM里。

• // 緩存的key使用介面名稱生成的List Object key = Arrays.asList(interfaceNames);


• synchronized (cache) {


• do {


• Object value = cache.get(key);


• // 緩存里保存了代理類的引用 if (value instanceof Reference) {


• proxyClass = (Class) ((Reference) value).get();


• }


• if (proxyClass != null) {


• // 代理類已經存在則返回


• return proxyClass;


• } else if (value == pendingGenerationMarker) {


• // 如果代理類正在產生，則等待


• try {


• cache.wait();


• } catch (InterruptedException e) {


• }


• continue;


• } else {


• //沒有代理類，則標記代理准備生成


• cache.put(key, pendingGenerationMarker);


• break;


• }


• } while (true);


• }



生成並載入代理類

代理類的生成主要是以下這兩行代碼：

• //生成代理類的位元組碼文件並保存到硬碟中(默認不保存到硬碟) proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);


• //使用類載入器將位元組碼載入到內存中 proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);



代理類的生成過程


ProxyGenerator.generateProxyClass()方法屬於sun.misc包下，Oracle並沒有提供源代碼，但是我們可以使用
JD-GUI這樣的反編譯軟體打開jrelib t.jar來一探究竟，以下是其核心代碼的分析。

• //添加介面中定義的方法，此時方法體為空 for (int i = 0; i < this.interfaces.length; i++) {


• localObject1 = this.interfaces[i].getMethods();


• for (int k = 0; k < localObject1.length; k++) {


• addProxyMethod(localObject1[k], this.interfaces[i]);


• }


• }


• //添加一個帶有InvocationHandler的構造方法 MethodInfo localMethodInfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);


• //循環生成方法體代碼（省略） //方法體里生成調用InvocationHandler的invoke方法代碼。（此處有所省略） this.cp.getInterfaceMethodRef("InvocationHandler", "invoke", "Object; Method; Object;")


• //將生成的位元組碼，寫入硬碟，前面有個if判斷，默認情況下不保存到硬碟。 localFileOutputStream = new FileOutputStream(ProxyGenerator.access$000(this.val$name) + ".class");


• localFileOutputStream.write(this.val$classFile);



生成的代理類源碼

那麼通過以上分析，我們可以推出動態代理為我們生成了一個這樣的代理類。把方法doSomeThing的方法體修改為調用LogInvocationHandler的invoke方法。

• public class ProxyBusiness extends Proxy implements IBusiness, IBusiness2 {


• private LogInvocationHandler h;


• @Override public void doSomeThing2() {


• try {


• Method m = (h.target).getClass().getMethod("doSomeThing2",null);


• h.invoke(this, m, null);


• } catch (Throwable e) {


• // 異常處理（略）


• }


• }


• @Override public boolean doSomeThing() {


• try {


• Method m = (h.target).getClass().getMethod("doSomeThing", null);


• return (Boolean) h.invoke(this, m, null);


• } catch (Throwable e) {


• // 異常處理（略）


• }


• return false;


• }


• public ProxyBusiness(LogInvocationHandler h) {


• this.h = h;


• }



測試代理的代碼如下：

• //測試public static void main(String[] args) {


• //構建AOP的Advice


• LogInvocationHandler handler = new LogInvocationHandler(new Business());


• new ProxyBusiness(handler).doSomeThing();


• new ProxyBusiness(handler).doSomeThing2();


• }



下面看一個自定義代理的實現。

被代理類介面

• public interface Subject {


• public void doSomething();


• }



被代理類

• //目標對象public class RealSubject implements Subject{ public void doSomething() {


• System.out.println( "call doSomething()" );


• }


• }



調用處理器(切面)

• public class ProxyHandler implements InvocationHandler {


• private Object proxied;


• public ProxyHandler( Object proxied ) {


• this.proxied = proxied;


• }


• public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable {


• //在轉調具體目標對象之前，可以執行一些功能處理System.out.println( "doSomething before" ); //轉調具體目標對象的方法


• return method.invoke( proxied, args);


• //在轉調具體目標對象之後，可以執行一些功能處理System.out.println( "doSomething after" );


• }


• }



測試我們的代理實現

• public class DynamicProxy {


• public static void main( String args[] ) {


• RealSubject real = new RealSubject();


• Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),


• new Class[]{Subject.class}, new ProxyHandler(real));


• proxySubject.doSomething(); //write proxySubject class binary data to file


• createProxyClassFile();


• }


• public static void createProxyClassFile() {


• String name = "ProxySubject";


• byte[] data = ProxyGenerator.generateProxyClass( name, new Class[] { Subject.class } );


• try{


• FileOutputStream out = new FileOutputStream( name + ".class" );


• out.write( data );


• out.close();


• }catch( Exception e ) {


• e.printStackTrace();


• }


• }


• }



運行結果：

• doSomething beforecall doSomething()doSomething after



Proxy 介面

Proxy 的主要靜態變數

• // 映射表：用於維護類裝載器對象到其對應的代理類緩存private static Map loaderToCache = new WeakHashMap();// 標記：用於標記一個動態代理類正在被創建中private static Object pendingGenerationMarker = new Object();// 同步表：記錄已經被創建的動態代理類類型，主要被方法 isProxyClass 進行相關的判斷private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());// 關聯的調用處理器引用protected InvocationHandler h;


• Proxy的構造方法// 由於 Proxy 內部從不直接調用構造函數，所以 private 類型意味著禁止任何調用private Proxy() {}// 由於 Proxy 內部從不直接調用構造函數，所以 protected 意味著只有子類可以調用protected Proxy(InvocationHandler h) {this.h = h;}



ProxySubject 源碼

創建的代理類 ProxySubject.class

• import java.lang.reflect.*;


• public final class ProxySubject extends Proxy implements Subject{


• private static Method m1;


• private static Method m0;


• private static Method m3;


• private static Method m2;


• public ProxySubject(InvocationHandler invocationhandler){


• super(invocationhandler);


• }


• public final boolean equals(Object obj){


• try {


• return ((Boolean)super.h.invoke(this, m1, new Object[] {


• obj


• })).booleanValue();


• }catch(Error _ex) {


• }catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• public final int hashCode() {


• try {


• return ((Integer)super.h.invoke(this, m0, null)).intValue();


• }catch(Error _ex) {


• }catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• /*關鍵部分*/


• public final void doSomething() {


• try {


• // Proxy類中protected InvocationHandler h;關聯的調用處理器引用


• super.h.invoke(this, m3, null);


• return;


• }catch(Error _ex) {


• }catch(Throwable throwable) {


• throw new UndeclaredThrowableException(throwable);


• }


• }


• public final String toString() {


• try {


• return (String)super.h.invoke(this, m2, null);


• } catch(Error _ex) {


• } catch(Throwable throwable){


• throw new UndeclaredThrowableException(throwable);


• }


• }


• static{


• try {


• 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]);


• m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);


• m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);


• }catch(NoSuchMethodException nosuchmethodexception) {


• throw new NoSuchMethodError(nosuchmethodexception.getMessage());


• }catch(ClassNotFoundException classnotfoundexception){


• throw new NoClassDefFoundError(classnotfoundexception.getMessage());


• }


• }


• }



CGLib 動態代理

動態位元組碼生成。使用動態位元組碼生成技術實現AOP原理是在運行期間目標位元組碼載入後，生成目標類的子類，將切面邏輯加入到子類中，所以使用Cglib實現AOP不需要基於介面。

• public static void main(String[] args) {


• byteCodeGe();


• }


• public static void byteCodeGe() {


• //創建一個織入器


• Enhancer enhancer = new Enhancer();


• //設置父類


• enhancer.setSuperclass(Business.class);


• //設置需要織入的邏輯


• enhancer.setCallback(new LogIntercept());


• //使用織入器創建子類


• IBusiness2 newBusiness = (IBusiness2) enhancer.create();


• newBusiness.doSomeThing2();


• }


• /**


• * 記錄日誌


• */ public static class LogIntercept implements MethodInterceptor {


• @Override


• public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {


• //執行原有邏輯，注意這里是invokeSuper


• Object rev = proxy.invokeSuper(target, args);


• //執行織入的日誌


• if (method.getName().equals("doSomeThing2")) {


• System.out.println("記錄日誌");


• }


• return rev;


• }


• }