動態代理為什麼需要介面數組

『壹』 java的動態代理為什麼要用介面

其實java 的規范就是根據JDK來規范的。java也必須在虛擬機來運行。至於java的動態代理可以不使用JDK的介面，而可以用spring 的AOP 動態代理。！
如果又什麼疑問可以到我空間去看！

http://hi..com/2512149/blog/item/83fa889431716c027af48077.html

1.其實spring中的AOP的動態代理就是默認JDK中的動態代理機制來實現。
(思想:我們要把橫切（散布）的東西給拿出來，成一個模塊)
2.AOP應該是一個OOP的技術上一個補充！

接下來我們下一個動態代理 ，通過代碼我們來了解下!

1.首先呢，我們上節講的static代理的代理類將不會存在了我們將在運行期
生成。

2.我們建一個類動態安全檢查（SecurityHandler）然後實現介面：InvocationHandler

3.聲明目標對象，進行代理。

4.然後提供一個方法，返回代理對象。

5.我們把橫切的問題全部給模塊化了，都放在一個類裡面!

6.在調Object newProxy（）方法之前，它會先默認調用Object invoke（）方法
所以我們把安全性檢查方法放在裡面就行了.跟著它會繼續調用目標對象的真實調用。
*目標實現對象有返回值的有沒有返回值的所以我們這里要注意。
*

『貳』 java 動態代理實例

1. 代理模式
代理模式的作用是：為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個客戶不想或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。
代理模式一般涉及到三個角色：
抽象角色：聲明真實對象和代理對象的共同介面；
代理角色：代理對象角色內部含有對真實對象的引用，從而可以操作真實對象，同時代理對象提供與真實對象相同的介面以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當於對真實對象進行封裝。
真實角色：代理角色所代表的真實對象，是我們最終要引用的對象。

以下以《Java與模式》中的示例為例：

抽象角色：
abstract public class Subject {
abstract public void request();
}

真實角色：實現了Subject的request()方法。
public class RealSubject extends Subject {
public RealSubject() { }

public void request() {
System.out.println( " From real subject. " );
}
}

代理角色：
public class ProxySubject extends Subject {
private RealSubject realSubject; // 以真實角色作為代理角色的屬性

public ProxySubject() { }

public void request() { // 該方法封裝了真實對象的request方法
preRequest();

if ( realSubject == null ) {

realSubject = new RealSubject();
}

realSubject.request(); // 此處執行真實對象的request方法

postRequest();
}

客戶端調用：
Subject sub = new ProxySubject();
Sub.request();

由以上代碼可以看出，客戶實際需要調用的是RealSubject類的request()方法，現在用ProxySubject來代理 RealSubject類，同樣達到目的，同時還封裝了其他方法(preRequest(),postRequest())，可以處理一些其他問題。

另外，如果要按照上述的方法使用代理模式，那麼真實角色必須是事先已經存在的，並將其作為代理對象的內部屬性。但是實際使用時，一個真實角色必須對應一個 代理角色，如果大量使用會導致類的急劇膨脹；此外，如果事先並不知道真實角色，該如何使用代理呢？這個問題可以通過Java的動態代理類來解決。

2.動態代理類

Java動態代理類位於Java.lang.reflect包下，一般主要涉及到以下兩個類：

(1). Interface InvocationHandler：該介面中僅定義了一個方法Object：invoke(Object obj,Method method, Object[] args)。在實際使用時，第一個參數obj一般是指代理類，method是被代理的方法，如上例中的request()，args為該方法的參數數組。 這個抽象方法在代理類中動態實現。

(2).Proxy：該類即為動態代理類，作用類似於上例中的ProxySubject，其中主要包含以下內容：

Protected Proxy(InvocationHandler h)：構造函數，估計用於給內部的h賦值。

Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：獲得一個代理類，其中loader是類裝載器，interfaces是真實類所擁有的全部介面的數組。

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理類的一個實例，返回後的代理類可以當作被代理類使用(可使用被代理類的在Subject介面中聲明過的方法)。

所謂Dynamic Proxy是這樣一種class：它是在運行時生成的class，在生成它時你必須提供一組interface給它，然後該class就宣稱它實現了這些 interface。你當然可以把該class的實例當作這些interface中的任何一個來用。當然啦，這個Dynamic Proxy其實就是一個Proxy，它不會替你作實質性的工作，在生成它的實例時你必須提供一個handler，由它接管實際的工作。

在使用動態代理類時，我們必須實現InvocationHandler介面，以第一節中的示例為例：

抽象角色(之前是抽象類，此處應改為介面)：

public interface Subject {
abstract public void request();
}

具體角色RealSubject：
public class RealSubject implements Subject {

public RealSubject() {}

public void request() {
System.out.println( " From real subject. " );
}

}

代理處理器：
import java.lang.reflect.Method;

import java.lang.reflect.InvocationHandler;

public class DynamicSubject implements InvocationHandler {
private Object sub;
public DynamicSubject() {}

public DynamicSubject(Object obj) {
sub = obj;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println( " before calling " + method);
method.invoke(sub,args);

System.out.println( " after calling " + method);
return null ;
}

}

該代理類的內部屬性為Object類，實際使用時通過該類的構造函數DynamicSubject(Object obj)對其賦值；此外，在該類還實現了invoke方法，該方法中的

method.invoke(sub,args);

其實就是調用被代理對象的將要被執行的方法，方法參數sub是實際的被代理對象，args為執行被代理對象相應操作所需的參數。通過動態代理類，我們可以在調用之前或之後執行一些相關操作。

客戶端：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Client {

static public void main(String[] args) throws Throwable {

RealSubject rs = new RealSubject(); // 在這里指定被代理類
InvocationHandler ds = new DynamicSubject(rs);
Class cls = rs.getClass();

// 以下是一次性生成代理
Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );
subject.request();

}

程序運行結果：
before calling public abstract void Subject.request()
From real subject.
after calling public abstract void Subject.request()

通過這種方式，被代理的對象(RealSubject)可以在運行時動態改變，需要控制的介面(Subject介面)可以在運行時改變，控制的方式(DynamicSubject類)也可以動態改變，從而實現了非常靈活的動態代理關系。

『叄』 JDK的動態代理為什麼要用介面

介面是不可以去直接實例化一個對象的，iUser介面內有需要實現的介面方法，需先實現這些介面方法才可以用它實例化一個對象。
InvocationHandlerProxyClas 也是一個介面，但被實現了所有介面方法，所以可以用它實例化對象。

『肆』 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；

代碼示例

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