java代理模式

A. java 代理模式和裝飾者模式的區別

您好！
代理模式與裝飾者模式看起來很像，都實現基礎對象實現的介面，在其自身對象中都保存著對被代理/被裝飾者的對象引用。
先來看看裝飾者模式的定義：動態的將責任附加到被裝飾者對象上，用於擴展對象的功能。比繼承的靈活性大。典型的如Java IO的設計即是裝飾者模式的典型應用。
代理模式模式的定義：對其他對象進行代理，以控制對被代理對象的訪問。Spring的為業務邏輯層方法生成的代理類，主要進行一些事務控制等。
由定義可以看出裝飾的責任是擴展功能 ，而代理主要控制訪問。
具體例子可參看Java IO裝飾/Spring的動態代理/Hibernate的代理等。
望採納

B. 什麼是java代理模式，具體相關的動態代理和靜態代理分別是什麼舉例更好啦~

簡單的例子: HelloSpeaker.java

import java.util.logging.*;

public class HelloSpeaker {
private Logger logger = Logger.getLogger(this.getClass().getName());

public void hello(String name) {

logger.log(Level.INFO, "hello method starts...."); //日誌記錄
System.out.println("Hello, " + name); //!!!!!!!!!!!

logger.log(Level.INFO, "hello method ends...."); //日誌記錄
}
}

HelloSpeaker在執行hello()方法時，我們希望能記錄該方法已經執行以及結束，
最簡單的作法就是如上在執行的前後加上記錄動作，然而Logger介入了HelloSpeaker中，
記錄這個動作並不屬於HelloSpeaker，這使得HelloSpeaker的職責加重。

------------------------------------------------------------------------------------------
怎麼辦，用下面的方法或許好一些:

先定義一個介面:

public interface IHello {
public void hello(String name);
}
------------------------------------------------------------------------------------------
實現該介面

public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("Hello, " + name);
}
}

public class Greeting implements IHello{
public void hello(String name){
System.out.println("Greeting, " + name);
}
}
------------------------------------------------------------------------------------------
實現一個代理對象: HelloProxy

import java.util.logging.*;
public class HelloProxy implements IHello {
private Logger logger = Logger.getLogger(this.getClass().getName());
private IHello helloObject; //被代理對象

public HelloProxy(){}

public HelloProxy(IHello helloObject) {
this.helloObject = helloObject; //把被代理對象傳入
}

public void setHelloObject(IHello helloObject){
this.helloObject = helloObject;
}

public IHello getHelloObject(){
return this.helloObject;
}

public void hello(String name) {
logger.log(Level.INFO, "hello method starts...."); //日誌記錄

helloObject.hello(name); //!!!!!!!!調用被代理對象的方法

logger.log(Level.INFO, "hello method ends...."); //日誌記錄
}
}

-----------------------------------------------------------------------------------------------------
執行:

IHello helloProxy = new HelloProxy(new HelloSpeaker()); //生成代理對象, 並給它傳入一個被代理的對象
helloProxy.hello("world");

//IHello h=factory.getBean("hello"); // IoC
//h.hello("world");

IHello helloProxy = new HelloProxy(new Greeting()); //生成代理對象, 並給它傳入一個被代理的對象
helloProxy.hello("world");

-----------------------------------------------------------------------------------------------------

代理對象HelloProxy將代理真正的HelloSpeaker來執行hello()，並在其前後加上記錄的動作，
這使得我們的HelloSpeaker在寫時不必介入記錄動作，HelloSpeaker可以專心於它的職責。

這是靜態代理的基本範例，然而，代理對象的一個介面只服務於一種類的對象，而且如果要代理的方法很多，
我們勢必要為每個方法進行代理，靜態代理在程序規模稍大時就必定無法勝任.

Java在JDK 1.3之後加入協助開發動態代理功能的類，我們不必為特定對象與方法寫特定的代理，使用動態代理，
可以使得一個handler服務於各個對象，首先，一個handler必須實現java.lang.reflect.InvocationHandler：

import java.util.logging.*;
import java.lang.reflect.*;

public class LogHandler implements InvocationHandler { //
private Logger logger = Logger.getLogger(this.getClass().getName());
private Object delegate; //被代理的對象

public Object bind(Object delegate) { //自定義的一個方法，用來綁定被代理對象的，返回值為被代理方法的返回值
this.delegate = delegate;
return Proxy.newProxyInstance(
delegate.getClass().getClassLoader(),
delegate.getClass().getInterfaces(),
this); //通過被代理的對象生成它的代理對象, 並同handler綁定在一起
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
logger.log(Level.INFO, "method starts..." + method); //日誌記錄
result = method.invoke(delegate, args); //!!!!!!!!調用被代理對象的方法
logger.log(Level.INFO, "method ends..." + method); //日誌記錄
} catch (Exception e){
logger.log(Level.INFO, e.toString());
}
return result;
}
}
InvocationHandler的invoke()方法會傳入被代理對象的方法名稱與參數, 實際上要執行的方法交由method.invoke()，
並在其前後加上記錄動作，method.invoke()返回的對象是實際方法執行過後的回傳結果。

動態代理必須有介面:
public interface IHello {
public void hello(String name);
}

實現該介面:
public class HelloSpeaker implements IHello {
public void hello(String name) {
System.out.println("Hello, " + name);
}
}

執行:
LogHandler logHandler = new LogHandler();
IHello helloProxy = (IHello) logHandler.bind(new HelloSpeaker()); //傳入被代理對象, 傳回代理對象
helloProxy.hello("Justin");

C. java中的代理是什麼意思

動態代理在Java中是很重要的一部分，在很多框架中都會用到，如Spring中的AOP、Hadoop中的RPC等。為此在這把我對Java中的動態代理的理解分享給大家，同時寫了一個模擬AOP編程的實例。

有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
如果要對第三方提供的JAR包中的某個類中的某個方法的前後加上自己的邏輯，比如打LOG，注意此時我們只有第三方提供的CLASS文件，因此根本不可能去修改別人的源代碼，那該怎麼辦？
有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
如果要對第三方提供的JAR包中的某個類中的某個方法的前後加上自己的邏輯，比如打LOG，注意此時我們只有第三方提供的CLASS文件，因此根本不可能去修改別人的源代碼，那該怎麼辦？
有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
分析動態代理過程
1.根據輸入的介面，利用反射機制，肯定可以拿到有哪些方法；
2.根據輸入的被代理類，同樣利用反射機制，肯定去調用其實現的方法。
到了這里，好像少了一點東西，就是少了對某個方法的前後的加強的邏輯。

D. java動態代理是什麼

主要用來做方法的增強，讓你可以在不修改源碼的情況下，增強一些方法，在方法執行前後做任何你想做的事情（甚至根本不去執行這個方法），因為在InvocationHandler的invoke方法中，你可以直接獲取正在調用方法對應的Method對象，具體應用的話，比如可以添加調用日誌，做事務控制等。

E. 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。

F. Java靜態代理和iOS代理模式這兩個概念的理解上的疑惑

看了JAVA版的設計模式的 代理模式 和IOS @protrol 比較，java 的看了都暈了。不完全一致，委託和代理 稱呼上就好像反的。用JAVA 的中介面 在view中實現方法，就要把介面中所有的方法都復寫一下，這個不太好用， 還不知道其它什麼模式來實現像Ios @protrol 的功能。

G. 什麼是代理模式（java中的）

為其他對象提供一種代理以控制對這個對象的訪問.
代理是比較有用途的一種模式,而且變種較多,應用場合覆蓋從小結構到整個系統的大結構,我們也許有代理伺服器等概念,代理概念可以解釋為:在出發點到目的地之間有一道中間層,意為代理.
詳細可參考java設計模式手冊

H. 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;


• }


• }