Spring AOP的實現原理

AOP（Aspect Orient Programming），咱們通常稱爲面向方面（切面）編程，做爲面向對象的一種補充，用於處理系統中分佈於各個模塊的橫切關注點，好比事務管理、日誌、緩存等等。AOP實現的關鍵在於AOP框架自動建立的AOP代理，AOP代理主要分爲靜態代理和動態代理，靜態代理的表明爲AspectJ；而動態代理則以Spring AOP爲表明。本文會分別對AspectJ和Spring AOP的實現進行分析和介紹。

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

以前提到，AspectJ是靜態代理的加強，所謂的靜態代理就是AOP框架會在編譯階段生成AOP代理類，所以也稱爲編譯時加強。

舉個實例的例子來講。首先咱們有一個普通的Hello類

public class Hello {
    public void sayHello() {
        System.out.println("hello");
    }

    public static void main(String[] args) {
        Hello h = new Hello();
        h.sayHello();
    }
}

使用AspectJ編寫一個Aspect

public aspect TxAspect {
    void around():call(void Hello.sayHello()){
        System.out.println("開始事務 ...");
        proceed();
        System.out.println("事務結束 ...");
    }
}

這裏模擬了一個事務的場景，相似於Spring的聲明式事務。使用AspectJ的編譯器編譯

ajc -d . Hello.java TxAspect.aj

編譯完成以後再運行這個Hello類，能夠看到如下輸出

開始事務 ...
hello
事務結束 ...

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

查看一下編譯後的Hello.class

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對象。

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作動態代理的。

爲了驗證以上的說法，能夠作一個簡單的測試。首先測試實現接口的狀況。

定義一個接口

public interface Person {
    String sayHello(String name);
}

實現類

@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

@Aspect
@Component
public class AdviceTest {

    @Pointcut("@annotation(com.listenzhangbin.aop.Timer)")
    public void pointcut() {
    }

    @Before("pointcut()")
    public void before() {
        System.out.println("before");
    }
}

運行

@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);
    }
}

輸出

before
-- sayHello() --
class com.sun.proxy.$Proxy53

能夠看到類型是com.sun.proxy.$Proxy53，也就是前面提到的Proxy類，所以這裏Spring AOP使用了JDK的動態代理。

再來看看不實現接口的狀況，修改Chinese類

@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);
    }

}

運行

@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);
    }
}

輸出

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 實現原理與 CGLIB 應用》

《Spring 容器AOP的實現原理——動態代理》

《AOP的底層實現-CGLIB動態代理和JDK動態代理》

個人我的博客原文。