java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總 Spring中AOP的兩種代理方式（Java動態代理和CGLIB代理）
若代理類在程式執行前就已經存在，那麼這種代理方式被成為 靜態代理 ，這種情況下的代理類通常都是我們在Java程式碼中定義的。 通常情況下， 靜態代理中的代理類和委託類會實現同一介面或是派生自相同的父類。
一、概述
1. 什麼是代理
我們大家都知道微商代理，簡單地說就是代替廠家賣商品，廠家“委託”代理為其銷售商品。關於微商代理，首先我們從他們那裡買東西時通常不知道背後的廠家究竟是誰，也就是說，“委託者”對我們來說是不可見的;其次，微商代理主要以朋友圈的人為目標客戶，這就相當於為廠家做了一次對客戶群體的“過濾”。我們把微商代理和廠家進一步抽象，前者可抽象為代理類，後者可抽象為委託類(被代理類)。通過使用代理，通常有兩個優點，並且能夠分別與我們提到的微商代理的兩個特點對應起來：
優點一：可以隱藏委託類的實現;
優點二：可以實現客戶與委託類間的解耦，在不修改委託類程式碼的情況下能夠做一些額外的處理。
2. 靜態代理
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public
interface
Sell {
void
sell();
void
ad();
}
Vendor類的定義如下：
publicclass
Vendor
implements
Sell {
public
void
sell() {
System.out.println(
"In sell method"
);
}
public
void
ad() {
System,out.println(
"ad method"
)
}
}
|
從BusinessAgent類的定義我們可以瞭解到，靜態代理可以通過聚合來實現，讓代理類持有一個委託類的引用即可。
下面我們考慮一下這個需求：給Vendor類增加一個過濾功能，只賣貨給大學生。通過靜態代理，我們無需修改Vendor類的程式碼就可以實現，只需在BusinessAgent類中的sell方法中新增一個判斷即可如下所示：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
public
class
BusinessAgent
implements
Sell {
...
public
void
sell() {
if
(isCollegeStudent()) {
vendor.sell();
}
}
...
}
|
這對應著我們上面提到的使用代理的第二個優點：可以實現客戶與委託類間的解耦，在不修改委託類程式碼的情況下能夠做一些額外的處理。靜態代理的侷限在於執行前必須編寫好代理類，下面我們重點來介紹下執行時生成代理類的動態代理方式。
二、動態代理
1. 什麼是動態代理
代理類在程式執行時建立的代理方式被成為 動態代理。 也就是說，這種情況下，代理類並不是在Java程式碼中定義的，而是在執行時根據我們在Java程式碼中的“指示”動態生成的。相比於靜態代理， 動態代理的優勢在於可以很方便的對代理類的函式進行統一的處理，而不用修改每個代理類的函式。 這麼說比較抽象，下面我們結合一個例項來介紹一下動態代理的這個優勢是怎麼體現的。
現在，假設我們要實現這樣一個需求：在執行委託類中的方法之前輸出“before”，在執行完畢後輸出“after”。我們還是以上面例子中的Vendor類作為委託類，BusinessAgent類作為代理類來進行介紹。首先我們來使用靜態代理來實現這一需求，相關程式碼如下：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
public
class
BusinessAgent
implements
Sell {
private
Vendor mVendor;
public
BusinessAgent(Vendor vendor) {
this
.mVendor = vendor;
}
public
void
sell() {
System.out.println(
"before"
);
mVendor.sell();
System.out.println(
"after"
);
}
public
void
ad() {
System.out.println(
"before"
);
mVendor.ad();
System.out.println(
"after"
);
}
}
|
從以上程式碼中我們可以瞭解到，通過靜態代理實現我們的需求需要我們在每個方法中都新增相應的邏輯，這裡只存在兩個方法所以工作量還不算大，假如Sell介面中包含上百個方法呢?這時候使用靜態代理就會編寫許多冗餘程式碼。通過使用動態代理，我們可以做一個“統一指示”，從而對所有代理類的方法進行統一處理，而不用逐一修改每個方法。下面我們來具體介紹下如何使用動態代理方式實現我們的需求。
2. 使用動態代理
(1)InvocationHandler介面
在使用動態代理時，我們需要定義一個位於代理類與委託類之間的中介類，這個中介類被要求實現InvocationHandler介面，這個介面的定義如下：
| 1 2 3 4 5 |
public
interface
InvocationHandler {
Object invoke(Object proxy, Method method, Object[] args);
}
|
從InvocationHandler這個名稱我們就可以知道，實現了這個介面的中介類用做“呼叫處理器”。當我們呼叫代理類物件的方法時，這個“呼叫”會轉送到invoke方法中，代理類物件作為proxy引數傳入，引數method標識了我們具體呼叫的是代理類的哪個方法，args為這個方法的引數。這樣一來，我們對代理類中的所有方法的呼叫都會變為對invoke的呼叫，這樣我們可以在invoke方法中新增統一的處理邏輯(也可以根據method引數對不同的代理類方法做不同的處理)。因此我們只需在中介類的invoke方法實現中輸出“before”，然後呼叫委託類的invoke方法，再輸出“after”。下面我們來一步一步具體實現它。
(2)委託類的定義
動態代理方式下，要求委託類必須實現某個介面，這裡我們實現的是Sell介面。委託類Vendor類的定義如下：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public
class
Vendor
implements
Sell {
public
void
sell() {
System.out.println(
"In sell method"
);
}
public
void
ad() {
System,out.println(
"ad method"
)
}
}
|
(3)中介類
上面我們提到過，中介類必須實現InvocationHandler介面，作為呼叫處理器”攔截“對代理類方法的呼叫。中介類的定義如下：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
public
class
DynamicProxy
implements
InvocationHandler {
private
Object obj;
//obj為委託類物件;
public
DynamicProxy(Object obj) {
this
.obj = obj;
}
@Override
public
Object invoke(Object proxy, Method method, Object[] args)
throws
Throwable {
System.out.println(
"before"
);
Object result = method.invoke(obj, args);
System.out.println(
"after"
);
return
result;
}
}
|
從以上程式碼中我們可以看到，中介類持有一個委託類物件引用，在invoke方法中呼叫了委託類物件的相應方法(第11行)，看到這裡是不是覺得似曾相識?通過聚合方式持有委託類物件引用，把外部對invoke的呼叫最終都轉為對委託類物件的呼叫。這不就是我們上面介紹的靜態代理的一種實現方式嗎?實際上，中介類與委託類構成了靜態代理關係，在這個關係中，中介類是代理類，委託類就是委託類; 代理類與中介類也構成一個靜態代理關係，在這個關係中，中介類是委託類，代理類是代理類。也就是說，動態代理關係由兩組靜態代理關係組成，這就是動態代理的原理。下面我們來介紹一下如何”指示“以動態生成代理類。
(4)動態生成代理類
動態生成代理類的相關程式碼如下：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
public
class
Main {
public
static
void
main(String[] args) {
//建立中介類例項
DynamicProxy inter =
new
DynamicProxy(
new
Vendor());
//獲取代理類例項sell
Sell sell = (Sell)(Proxy.newProxyInstance(Sell.
class
.getClassLoader(),
new
Class[] {Sell.
class
}, inter));
//通過代理類物件呼叫代理類方法，實際上會轉到invoke方法呼叫
sell.sell();
sell.ad();
}
}
|
在以上程式碼中，我們呼叫Proxy類的newProxyInstance方法來獲取一個代理類例項。這個代理類實現了我們指定的介面並且會把方法呼叫分發到指定的呼叫處理器。這個方法的宣告如下：
複製程式碼程式碼如下: public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
方法的三個引數含義分別如下：
loader：定義了代理類的ClassLoder;
interfaces：代理類實現的介面列表
h：呼叫處理器，也就是我們上面定義的實現了InvocationHandler介面的類例項
我們執行一下，看看我們的動態代理是否能正常工作。我這裡執行後的輸出為：
說明我們的動態代理確實奏效了。
上面我們已經簡單提到過動態代理的原理，這裡再簡單的總結下：首先通過newProxyInstance方法獲取代理類例項，而後我們便可以通過這個代理類例項呼叫代理類的方法，對代理類的方法的呼叫實際上都會呼叫中介類(呼叫處理器)的invoke方法，在invoke方法中我們呼叫委託類的相應方法，並且可以新增自己的處理邏輯。
Spring中AOP的兩種代理方式（Java動態代理和CGLIB代理）
原理區別：
java動態代理是利用反射機制生成一個實現代理介面的匿名類，在呼叫具體方法前呼叫InvokeHandler來處理。而cglib動態代理是利用asm開源包，對代理物件類的class檔案載入進來，通過修改其位元組碼生成子類來處理。
1、如果目標物件實現了介面，預設情況下會採用JDK的動態代理實現AOP
2、如果目標物件實現了介面，可以強制使用CGLIB實現AOP
3、如果目標物件沒有實現了介面，必須採用CGLIB庫，spring會自動在JDK動態代理和CGLIB之間轉換
如何強制使用CGLIB實現AOP？
* 新增CGLIB庫，SPRING_HOME/cglib/*.jar
* 在spring配置檔案中加入<aop:aspectj-autoproxy proxy-target-class="true"/>
JDK動態代理和CGLIB位元組碼生成的區別？
* JDK動態代理只能對實現了介面的類生成代理，而不能針對類
* CGLIB是針對類實現代理，主要是對指定的類生成一個子類，覆蓋其中的方法
因為是繼承，所以該類或方法最好不要宣告成final
Spring AOP裡面的代理實現方式
spring用代理類包裹切面，把他們織入到Spring管理的bean中。也就是說代理類偽裝成目標類，它會擷取對目標類中方法的呼叫，讓呼叫者對目標類的呼叫都先變成呼叫偽裝類，偽裝類中就先執行了切面，再把呼叫轉發給真正的目標bean。
現在可以自己想一想，怎麼搞出來這個偽裝類，才不會被呼叫者發現（過JVM的檢查，JAVA是強型別檢查，哪裡都要檢查型別）。
1.實現和目標類相同的介面，我也實現和你一樣的介面，反正上層都是介面級別的呼叫，這樣我就偽裝成了和目標類一樣的類（實現了同一介面，咱是兄弟了），也就逃過了型別檢查，到java執行期的時候，利用多型的後期繫結（所以spring採用執行時），偽裝類（代理類）就變成了介面的真正實現，而他裡面包裹了真實的那個目標類，最後實現具體功能的還是目標類，只不過偽裝類在之前幹了點事情（寫日誌，安全檢查，事物等）。
2.生成子類呼叫，這次用子類來做為偽裝類，當然這樣也能逃過JVM的強型別檢查，我繼承的嗎，當然查不出來了，子類重寫了目標類的所有方法，當然在這些重寫的方法中，不僅實現了目標類的功能，還在這些功能之前，實現了一些其他的（寫日誌，安全檢查，事物等）。
前一種兄弟模式，spring會使用JDK的java.lang.reflect.Proxy類，它允許Spring動態生成一個新類來實現必要的介面，織入通知，並且把對這些介面的任何呼叫都轉發到目標類。
後一種父子模式，spring使用CGLIB庫生成目標類的一個子類，在建立這個子類的時候，spring織入通知，並且把對這個子類的呼叫委託到目標類。
相比之下，還是兄弟模式好些，他能更好的實現鬆耦合，尤其在今天都高喊著面向介面程式設計的情況下，父子模式只是在沒有實現介面的時候，也能織入通知，應當做一種例外。
spring aop的使用方式：
使用aop的目的：
1就是為了方便，看一個國外很有名的大師說，程式設計的人都是“懶人”，因為他把自己做的事情都讓程式做了。用了aop能讓你少寫很多程式碼，這點就夠充分了吧
2就是為了更清晰的邏輯，可以讓你的業務邏輯去關注自己本身的業務，而不去想一些其他的事情，這些其他的事情包括：安全，事物，日誌等。
使用方式1：使用AspectJ提供的註解package test.mine.spring.bean;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class SleepHelper {
public SleepHelper(){
}
@Pointcut("execution(* *.sleep())")
public void sleeppoint(){}
@Before("sleeppoint()")
public void beforeSleep(){
System.out.println("睡覺前要脫衣服!");
}
@AfterReturning("sleeppoint()")
public void afterSleep(){
System.out.println("睡醒了要穿衣服！");
}
}
用@Aspect的註解來標識切面,注意不要把它漏了，否則Spring建立代理的時候會找不到它,@Pointcut註解指定了切點，@Before和@AfterReturning指定了執行時的通知，注
意的是要在註解中傳入切點的名稱。
然後我們在Spring配置檔案上下點功夫,首先是增加AOP的XML名稱空間和宣告相關schema
名稱空間:
xmlns:aop="http://www.springframework.org/schema/aop"
schema宣告:
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
然後加上這個標籤:
<aop:aspectj-autoproxy/> 有了這個Spring就能夠自動掃描被@Aspect標註的切面了
最後是執行，很簡單方便了：
public class Test {
public static void main(String[] args){
ApplicationContext appCtx = new ClassPathXmlApplicationContext("applicationContext.xml");
Sleepable human = (Sleepable)appCtx.getBean("human");
human.sleep();
}
}
第二種使用方式：
<bean id="sleepHelper" class="test.spring.aop.bean.SleepHelper">
<aop:config>
<aop:aspect ref="sleepHelper">
<aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))"/>
<aop:after method="afterSleep" pointcut="execution(* *.sleep(..))"/>
</aop:aspect>
</aop:config>