2. 程式人生 > >Spring-AOP代理原理

Spring-AOP代理原理

阿新 • • 發佈：2018-12-16

原文出處： Listen  ---轉載請標明原文出處

AOP（Aspect Orient Programming），我們一般稱為面向方面（切面）程式設計，作為面向物件的一種補充，用於處理系統中分佈於各個模組的橫切關注點，比如事務管理、日誌、快取等等。AOP實現的關鍵在於AOP框架自動建立的AOP代理，AOP代理主要分為靜態代理和動態代理，靜態代理的代表為AspectJ；而動態代理則以Spring AOP為代表。本文會分別對AspectJ和Spring AOP的實現進行分析和介紹。

使用AspectJ的編譯時增強實現AOP

之前提到，AspectJ是靜態代理的增強，所謂的靜態代理就是AOP框架會在編譯階段生成AOP代理類，因此也稱為編譯時增強。

舉個例項的例子來說。首先我們有一個普通的Hello類

1

2

3

4

5

6

7

8

9

10

public class Hello {

public void sayHello() {

System.out.println("hello");

}

public static void main(String[] args) {

Hello h = new Hello();

h.sayHello();

}

}

使用AspectJ編寫一個Aspect

1

2

3

4

5

6

7

public aspect TxAspect {

void around():call(void Hello.sayHello()){

System.out.println("開始事務 ...");

proceed();

System.out.println("事務結束 ...");

}

}

這裡模擬了一個事務的場景，類似於Spring的宣告式事務。使用AspectJ的編譯器編譯

1

ajc -d . Hello.java TxAspect.aj

編譯完成之後再執行這個Hello類，可以看到以下輸出

1

2

3

開始事務 ...

hello

事務結束 ...

顯然，AOP已經生效了，那麼究竟AspectJ是如何在沒有修改Hello類的情況下為Hello類增加新功能的呢？

檢視一下編譯後的Hello.class

1

2

3

4

5

6

7

8

9

10

11

12

13

public class Hello {

public Hello() {

}

public void sayHello() {

System.out.println("hello");

}

public static void main(String[] args) {

Hello h = new Hello();

sayHello_aroundBody1$advice(h, TxAspect.aspectOf(), (AroundClosure)null);

}

}

可以看到，這個類比原來的Hello.java多了一些程式碼，這就是AspectJ的靜態代理，它會在編譯階段將Aspect織入Java位元組碼中， 執行的時候就是經過增強之後的AOP物件。

1

2

3

4

5

public void ajc$around$com_listenzhangbin_aop_TxAspect$1$f54fe983(AroundClosure ajc$aroundClosure) {

System.out.println("開始事務 ...");

ajc$around$com_listenzhangbin_aop_TxAspect$1$f54fe983proceed(ajc$aroundClosure);

System.out.println("事務結束 ...");

}

從Aspect編譯後的class檔案可以更明顯的看出執行的邏輯。proceed方法就是回撥執行被代理類中的方法。

使用Spring AOP

與AspectJ的靜態代理不同，Spring AOP使用的動態代理，所謂的動態代理就是說AOP框架不會去修改位元組碼，而是在記憶體中臨時為方法生成一個AOP物件，這個AOP物件包含了目標物件的全部方法，並且在特定的切點做了增強處理，並回調原物件的方法。

Spring AOP中的動態代理主要有兩種方式，JDK動態代理和CGLIB動態代理。JDK動態代理通過反射來接收被代理的類，並且要求被代理的類必須實現一個介面。JDK動態代理的核心是InvocationHandler介面和Proxy類。

如果目標類沒有實現介面，那麼Spring AOP會選擇使用CGLIB來動態代理目標類。CGLIB（Code Generation Library），是一個程式碼生成的類庫，可以在執行時動態的生成某個類的子類，注意，CGLIB是通過繼承的方式做的動態代理，因此如果某個類被標記為final，那麼它是無法使用CGLIB做動態代理的。

為了驗證以上的說法，可以做一個簡單的測試。首先測試實現介面的情況。

定義一個介面

1

2

3

public interface Person {

String sayHello(String name);

}

實現類

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

@Component

public class Chinese implements Person {

@Timer

@Override

public String sayHello(String name) {

System.out.println("-- sayHello() --");

return name + " hello, AOP";

}

public void eat(String food) {

System.out.println("我正在吃：" + food);

}

}

這裡的@Timer註解是我自己定義的一個普通註解，用來標記Pointcut。

定義Aspect

1

2

3

4

5

6

7

8

9

10

11

12

13

@Aspect

@Component

public class AdviceTest {

@Pointcut("@annotation(com.listenzhangbin.aop.Timer)")

public void pointcut() {

}

@Before("pointcut()")

public void before() {

System.out.println("before");

}

}

執行

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

@SpringBootApplication

@RestController

public class SpringBootDemoApplication {

//這裡必須使用Person介面做注入

@Autowired

private Person chinese;

@RequestMapping("/test")

public void test() {

chinese.sayHello("listen");

System.out.println(chinese.getClass());

}

public static void main(String[] args) {

SpringApplication.run(SpringBootDemoApplication.class, args);

}

}

輸出

1

2

3

before

-- sayHello() --

class com.sun.proxy.$Proxy53

可以看到型別是com.sun.proxy.$Proxy53，也就是前面提到的Proxy類，因此這裡Spring AOP使用了JDK的動態代理。

再來看看不實現介面的情況，修改Chinese類

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

@Component

public class Chinese {

@Timer

//    @Override

public String sayHello(String name) {

System.out.println("-- sayHello() --");

return name + " hello, AOP";

}

public void eat(String food) {

System.out.println("我正在吃：" + food);

}

}

執行

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

@SpringBootApplication

@RestController

public class SpringBootDemoApplication {

//直接用Chinese類注入

@Autowired

private Chinese chinese;

@RequestMapping("/test")

public void test() {

chinese.sayHello("listen");

System.out.println(chinese.getClass());

}

public static void main(String[] args) {

SpringApplication.run(SpringBootDemoApplication.class, args);

}

}

輸出

1

2

3

before

-- sayHello() --

class com.listenzhangbin.aop.Chinese$$EnhancerBySpringCGLIB$$56b89168

可以看到類被CGLIB增強了，也就是動態代理。這裡的CGLIB代理就是Spring AOP的代理，這個類也就是所謂的AOP代理，AOP代理類在切點動態地織入了增強處理。

小結

AspectJ在編譯時就增強了目標物件，Spring AOP的動態代理則是在每次執行時動態的增強，生成AOP代理物件，區別在於生成AOP代理物件的時機不同，相對來說AspectJ的靜態代理方式具有更好的效能，但是AspectJ需要特定的編譯器進行處理，而Spring AOP則無需特定的編譯器處理。

參考：

相關推薦

Spring-AOP代理原理

原文出處： Listen  ---轉載請標明原文出處 AOP（Aspect Orient Programming），我們一般稱為面向方面（切面）程式設計，作為面向物件的一種補充，用於處理系統中分佈於各個模組的橫切關注點，比如事務管理、日誌、快取等等。AOP實現的關鍵在於AO

java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總 Spring中AOP的兩種代理方式（Java動態代理和CGLIB代理）

若代理類在程式執行前就已經存在，那麼這種代理方式被成為 靜態代理 ，這種情況下的代理類通常都是我們在Java程式碼中定義的。 通常情況下， 靜態代理中的代理類和委託類會實現同一介面或是派生自相同的父類。 一、概述1. 什麼是代理我們大家都知道微商代理，簡單地說就是代替廠家賣商品，廠家“委託”代理為

Spring裡的aop實現方式和原始碼分析 java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總

使用"橫切"技術，AOP把軟體系統分為兩個部分：核心關注點和橫切關注點。業務處理的主要流程是核心關注點，與之關係不大的部分是橫切關注點。橫切關注點的一個特點是，他們經常發生在核心關注點的多處，而各處基本相似，比如許可權認證、日誌、事務。AOP的作用在於分離系統中的各種關注點，將核心關注點和橫切關注點分離開來。

Mybatis(四)：MyBatis核心元件介紹原理解析和原始碼解讀 java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總

Mybatis核心成員 Configuration        MyBatis所有的配置資訊都儲存在Configuration物件之中，配置檔案中的大部分配置都會儲存到該類中 SqlSession         &

Spring AOP實現原理-動態代理

目錄 代理模式 靜態代理 動態代理 代理模式 我們知道，Spring AOP的主要作用就是不通過修改原始碼的方式、將非核心功能程式碼織入來實現對方法的增強。那麼Spring AOP的底層如何實現對方法的增強？實現的關鍵在於使用了代理模式 代理模式的作用就是為其它物件提供一種代理，以控制

Spring-AOP的原理-動態代理-IOC-註解配置

一：概念的介紹：     什麼叫AOP？           關鍵：  橫向重複，縱向提取；         AOP能為容器中管理的物件動態生成代理物件，AOP是指程式設計不是針對某一個物件，而是針對一群物件，打個比方：就像一個一個個圓柱形，這一個個圓柱形就是一個個

Spring AOP 實現原理

pri ack more .net style 實現原理 cor http details Spring AOP 實現原理Spring AOP 實現原理

Spring AOP實現原理

asp 默認 RR force HERE 針對 解決 之前 中介 基於代理(Proxy)的AOP實現 首先，這是一種基於代理(Proxy)的實現方式。下面這張圖很好地表達了這層關系： 這張圖反映了參與到AOP過程中的幾個關鍵組件(以@Before Advice為例)：

Spring AOP代理類生成錯誤

在整合的ssh時出現一個Spring  AOP代理類生成的錯誤，問題出現在配置事務的時候，切面表示式寫的範圍太大，導致執行Spring事務時候生成代理類時出現了一個錯誤 專案目錄 配置檔案 <!-- 匯入外部檔案 --> <context

Spring Aop底層原理詳解（利用spring後置處理器實現AOP）

寫在前面：對於一個java程式設計師來說，相信絕大多數都有這樣的面試經歷，面試官問：你知道什麼是aop嗎？談談你是怎麼理解aop的？等等諸如此類關於aop的問題。當然對於一些小白可能會一臉懵逼；對於一些工作一兩年的，可能知道，哦！aop就是面向切面變成，列印日誌啊，什麼什麼的，要是有點學

Spring AOP：原理、 通知、連線點、切點、切面、表示式

0：Spring AOP 原理 簡單說說 AOP 的設計： 每個 Bean 都會被 JDK 或者 Cglib 代理。取決於是否有介面。 每個 Bean 會有多個“方法攔截器”。注意：攔截器分為兩層，外層由 Spring 核心控制流程，內層攔截器是使用者設定，也就是 AOP。

Spring AOP實現原理筆記（二） -- 原始碼分析

1、註冊AnnotationAwareAspectJAutoProxyCreator 首先要了解Spring解析XML配置檔案時，遇到自定義節點是如何解析的。可以參考Spring自定義XML標籤解析及其原理分析 當Spring遇到這個標籤的時候，它會

spring AOP 代理（靜態與動態+使用cglib實現）

一、沒有代理模式 缺點： 1、工作量特別大，如果專案中有多個類，多個方法，則要修改多次。 2、違背了設計原則：開閉原則（OCP），對擴充套件開放，對修改關閉，而為了增加功能把每個方法都修改了，也不便於維護。 3、違背了設計原則：單一職責（SRP），每個方法除了要完成自己本身的功能，還要計算耗時、延時；

Spring AOP 代理實現的兩種方式： JDK動態代理 和 Cglib框架動態代理

1.JDK動態代理 JDK API 內建 ---- 通過 Proxy類，為目標物件建立代理 （必須面向介面代理 ），此文中介面為UserDao,實現類為UserDaoImpl. public class UserDaoImpl implements UserDao {

spring aop底層原理ProxyFactoryBean的具體使用過程--FactoryBean深入理解

實際的spring使用aop的過程，配置好ProxyFactoryBean，給ProxyFactoryBean設定一個bean id 然後通過ac.getBean(bean id),就取得被ProxyFactoryBean代理的物件，不是ProxyFactory

Spring Aop技術原理分析

本篇文章從Aop xml元素的解析開始，分析了Aop在Spring中所使用到的技術。包括Aop各元素在容器中的表示方式、Aop自動代理的技術、代理物件的生成及Aop攔截鏈的呼叫等等。將這些技術串聯起來，就能勾勒出Aop在Spring中的使用脈絡。 一、Spring Ao

Spring aop（原理）

上次總結了Spring的重點之一IOC，這次總結一下Spring的aop，aop嗯面向切面程式設計，先談談aop在Sping框架中的應用吧，最經典的莫過於Sping aop實現宣告式事務管理了，在xml檔案中配置 <beans xmlns="http://www.springframework.org/

反射..獲取spring aop代理類 的目標類方法

背景： 在專案開發過程中(注：專案用的SpringMvc)，有這麼一種需求，系統所有的表格查詢都有統一的查詢介面，通過通用的Controller類組裝查詢條件以及呼叫查詢介面返回查詢資料。         但是在實際開發中碰到了這麼一個問題，由於專案中用到了sprin

Spring AOP代理controller類

1、兩種動態代理方式： java動態代理是利用反射機制生成一個實現代理介面的匿名類，在呼叫具體方法前呼叫InvokeHandler來處理。 cglib動態代理是利用asm開源包，對代理物件類的class檔案載入進來，通過修改其位元組碼生成子類來處理。 java動態代理要求目

spring Aop實現原理（原始碼）

        前文《spring Aop前傳》講解了Aop程式設計正規化的來歷與工作原理，接下來將會介紹spring Aop作為一個aop的實現。在介紹spring Aop底層工作方式之前，我們拋開spring Aop真正實現，基於當前對spring的認識做一個大膽的假設