在軟體開發中，散佈於應用中多處的功能被稱為橫切關注點。通常來講，這些橫切關注點從概念上是與應用的業務邏輯相分離的。把這些橫切關注點與業務邏輯相分離正是面向切面程式設計所要解決的問題。

前面我們介紹瞭如何使用依賴注入管理和配置我們的應用物件。依賴注入有助於應用物件之間的解耦，而AOP可以實現橫切關注點與它們所影響的物件之間的解耦。

下面我們就來看Spring是如何實現切面的，先從AOP的基礎知識開始～

一、什麼是面向切面程式設計？

在之前的Java開發中，如果要重用通用功能，最常見的面向物件技術是繼承或委託。但是，如果整個應用中都使用相同的基類，繼承往往會導致一個脆弱的物件體系，而使用委託可能需要對委託物件進行復雜的呼叫。
現在，切面提供了取代繼承和委託的另一種可選方案，而且在很多場景下更清晰簡潔。在使用面向切面程式設計時，我們仍然在一個地方定義通用功能，但是可以通過宣告的方式定義這個功能要以何種方式在何處應用，而無需修改受影響的類。

橫切關注點可以被模組化為特殊的類，這些類被稱為切面。

定義AOP術語

AOP也形成了自己的術語：通知、切點和連線點。

接下來我們就來了解這些術語～

1）通知Advice

切面的工作被稱為通知，通知定義了切面是什麼以及何時使用。
Spring切面可以應用5種類型的通知：

• 前置通知：在目標方法被呼叫之前呼叫通知功能
• 後置通知：在目標方法完成以後呼叫通知，此時不會關心方法的輸出是什麼
• 返回通知：在目標方法成功執行之後呼叫通知
• 異常通知：在目標方法丟擲異常後呼叫通知
• 環繞通知：通知包裹了被通知的方法，在被通知的方法呼叫之前和呼叫之後執行自定義的行為

2）連線點Join point

我們的應用可能有數以千計的時機應用通知，這些時機被稱為連線點。連線點就是在應用執行過程中能夠插入切面的一個點，這個點可以是呼叫方法時、丟擲異常時、甚至修改一個欄位時。切面程式碼可以利用這些點插入到應用的正常流程之中，並新增新的行為。

3）切點Point

切點定義了切面的地點，即”何處“。切點的定義會匹配通知所要織入的一個或多個連線點。我們通常使用明確的類和方法名稱，或是利用正則表示式定義所匹配的類和方法名稱來指定這些切點。

4）切面Aspect

切面是通知和切點的結合。通知和切點共同定義了切面的全部內容——它是什麼，在何時和何處完成功能。

5）引入Introduction

引入允許我們向現有的類新增新方法或屬性。
簡單來說就是，現在我們可以通過AOP的引入機制，為當前的類引入新的屬性或者方法，而這些新的屬性和方法由是不屬於原有類的屬性和方法，它們不必在原有類中存在和實現就能被現有類使用。這可能聽起來有些神奇和不可思議，但是它確實是可以實現的，我們將在後面詳細說明並舉例。

6）織入Weaving

織入就是把切面應用到目標物件並建立新的代理物件的過程。切面在指定的連線點被織入到目標物件中。

我們瞭解了AOP術語，現在來看看AOP的核心概念是如何在Spring中實現的。

Spring對AOP的支援

Spring提供了4種類型的AOP支援：

• 基於代理的經典Spring AOP
• 純POJO切面
• @AspectJ註解驅動的切面
• 注入式AspectJ切面

前三種都是Spring AOP實現的變體，Spring AOP構建在動態代理基礎之上，因此Spring對AOP的支援僅限於方法攔截。

第一種經典的Spring AOP的程式設計模型在現在看來過於複雜，所以不推薦使用。
第二種純POJO雖然簡便，但是這種技術需要依賴XML配置。
第三種Spring借鑑了AspectJ的切面，以提供註解驅動的AOP。本質上，它仍然是Spring基於代理的AOP，但是程式設計模型幾乎與編寫成熟的ASpectJ註解切面完全一致，並且不需要XML來完成功能。
第四種就是如果你的AOP需求超過了簡單的方法呼叫(如構造器或者屬性攔截)，那麼就需要使用AspectJ來實現切面了。

在後面的例子中，我們會使用第三種類型的AOP，並且補充一點關於AspectJ的使用方式。

Spring通知是Java編寫的

Spring所建立的通知都是使用標準的Java類編寫的。這樣我們就可以使用與普通Java開發一樣的IDE來開發切面。而且，定義通知所應用的切點通常會使用註解或者XML來編寫。

而AspectJ與之相反，雖然AspectJ現在也支援基於註解的切面，但是AspectJ最初是以Java語言擴充套件的方式實現的，也就是有特定的AOP語言。這種方式有好也有壞，好處就是我們可以使用AOP工具集來簡化AOP開發，但是壞處就是需要額外學習AOP語言。

Spring在執行時通知物件

通過在代理類中包裹切面，Spring在執行期間把切面織入到Spring管理的Bean中。如下圖所示：

直到應用需要被代理的Bean時，Spring才建立代理物件。如果使用的是ApplicationContext的話，在ApplicationContext從BeanFactory中載入所有Bean的時候，Spring才會建立被代理的物件。因為Spring執行時才建立代理物件，所以我們不需要特殊的編譯器來織入Spring AOP的切面。

Spring只支援方法級別的連線點

Spring基於動態代理，所以Spring只支援方法連線點。這與其它的一些AOP框架是不同的，比如AspectJ，除了方法切點，還提供了欄位和構造器接入點。但是方法攔截可以滿足大多數的需求，如果需要方法攔截之外的連線點攔截功能，我們可以使用AspectJ來補充Spring AOP的功能。

二、通過切點來選擇連線點

通知和切點是切面的最基本元素，因此瞭解如何編寫切點非常重要。在Spring AOP中，要使用AspectJ的切點表示式語言來定義切點。關於Spring AOP的AspectJ切點，最重要的一點就是Spring僅支援AspectJ切點指示器的一個子集。

Spring是基於代理的，而某些切點表示式是與基於代理的AOP無關的，下表是Spring AOP所支援的AspectJ切點指示器：

AspectJ指示器	描述
arg()	限制連線點匹配引數為指定型別的執行方法
@arg()	限制連線點匹配引數由指定註解標註的執行方法
execution()	用於匹配是連線點的執行方法
this()	限制連線點匹配AOP代理的Bean引用為指定型別的類
target	限制連線點匹配目標物件為指定型別的類
@target()	限制連線點匹配特定的執行物件，這些物件對應的類具有指定型別的註解
within()	限制連線點匹配指定的型別
@within()	限制連線點匹配指定註解所標註的型別（當使用Spring AOP時，方法定義在由指定的註解所標註的型別）
@annotation	限制匹配帶有指定註解的連線點

在Spring中嘗試使用AspectJ其他指示器時，將會丟擲IllegalArgumentException異常。
以上指示器只有excution指示器是實際執行匹配的，而其他指示器都是用來限制匹配的。這說明execution指示器是我們在編寫切點定義時最主要使用的指示器。

編寫切點

為了闡述Spring中的切面，我們需要一個主題來定義切面的切點，所以我們定義一個Performance介面：

public concert;
public interface Performance {
    public void perform();
}

Performance可以代表任何型別的現場表演，如舞臺劇、電影或音樂會。為了處理在表演過程中的一些事情，我們將切點定義為當perform()方法執行時觸發通知，執行切面邏輯。

那麼這個切點表示式應該這樣寫：

execution(* concert.Performance.perform(..))

解釋這個切點表示式：

• 使用execution()指示器選擇Performance的perform()方法
• 方法表示式以*開始，表明我們不關心方法返回值的型別
• 指定了全限定類名和方法名
• 在方法引數列表中使用兩個點號(. .)表明了切點要選擇具有任意引數的perform()方法

這個切點表示式僅僅是在perform()方法被執行時觸發通知，這也就說我們可以在其他的包裡來實現Performance介面的perform()方法，從而觸發通知。如果設計一個場景，限制只能匹配concert包，要使用&&操作符：

execution(* concert.Performance.perform(..)) && within(concert.*)

因為&在XML中有特殊含義，所以XML中切點表示式的”&&”為and，”||”為or，”!”為not

在切點中選擇Bean

除了AspectJ指示器，Spring還引入了一個新的bean()指示器，它允許我們在切點表示式中使用bean的ID來標識Bean。bean()使用Bean ID或Bean的名稱作為引數來限制切點只匹配特定的Bean：

execution(* concert.Performance.perform()) and bean('woodstock')

還可以使用非操作，除了特定ID以外的其他Bean應用通知：

execution(* concert.Performance.perform()) and !bean('woodstock')

三、使用註解建立切面

我們已經定義了Performance介面，它是切面中切點的目標物件。現在，讓我們使用AspectJ註解來定義切面。

定義切面

一場演出需要觀眾，我們將觀眾定義為切面，在後面將其應用到演出上～
下面我們來看一下抽象為切面的觀眾類Audience：

@Aspect
public class Audience {

    @Before("execution(** concert.Performance.perform(..))")
    public void silenceCellPhones() {
        System.out.println("Silencing cell phones");
    }

    @Before("execution(** concert.Performance.perform(..))")
    public void takeSeats() {
        System.out.println("Taking seats");
    }

    @AfterReturning("execution(** concert.Performance.perform(..))")
    public void applause() {
        System.out.println("ClAP CLAP CLAP!!!");
    }

    @AfterThrowing("execution(** concert.Performance.perform(..))")
    public void demandRefund() {
        System.out.println("Demanding a refund");
    }
}

Audience有四個方法，定義了一個觀眾在觀看演出時可能會做的事情。在演出前要就做並將手機靜音。演出精彩觀眾會鼓掌，演出沒達到預期觀眾會要求退款。
我們發現，Aspect提供了五個註解來定義通知：

註解	通知
@Before	通知方法會在目標方法呼叫之前執行
@After	通知方法會在目標方法返回或丟擲異常後呼叫
@AfterReturning	通知方法會在目標方法返回後呼叫
@AfterThrowing	通知方法會在目標方法丟擲異常後呼叫
@Around	通知方法會將目標方法封裝起來

上面的這五種註解都需要給定一個切點表示式作為它的值。
而在Audience這個切面中，四個通知方法的註解都使用了同一個切點表示式，這是令我們不太滿意的地方，所以我們來優化一下，只定義一次這個切點，然後在每次需要的時候引用它就可以了。
在一個切面裡面使用@Pointcut來定義可重用的切點。

@Aspect
public class Audience {

    @Pointcut("execution(** concert.Performance.perform(..))")
    public void performance() {}

    @Before("performance()")
    public void silenceCellPhones() {
        System.out.println("Silencing cell phones");
    }

    @Before("performance()")
    public void takeSeats() {
        System.out.println("Taking seats");
    }

    @AfterReturning("performance()")
    public void applause() {
        System.out.println("ClAP CLAP CLAP!!!");
    }

    @AfterThrowing("performance()")
    public void demandRefund() {
        System.out.println("Demanding a refund");
    }
}

performance()方法的實際內容並不重要，這個方法本身只是一個標識，供@Pointcut註解依附。
我們還觀察到，除了註解和沒有實際操作的performance()方法，Audience仍然是一個普通的POJO，只不過它通過註解表明會作為切面使用而已。我們可以像使用其它普通的Java類一樣去使用它，這也體現出Spring的最小侵略性程式設計的特點。

到目前，Audience只會是容器的一個Bean，即使使用了AspectJ註解，但它並不會被視為切面，這些註解不會解析，也不會建立將其轉換為切面的代理。
我們可以在JavaConfig中使用@EnableAspectJAutoProxy註解啟用自動代理功能。

@Configuration
@EnableAspectJAutoProxy
@ComponentScan
public class ConcertConfig {
    @Bean
    public Audience audience() {
        return new Audience();
    }
}

也可以在XML中使用Spring aop名稱空間中的< aop:aspectJ-autoproxy>元素：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--開啟自動掃描-->
    <context:component-scan base-package="concert" />

    <!--啟用AspectJ自動代理-->
    <aop:aspectj-autoproxy />

    <!--宣告Audience Bean-->
    <bean class="concert.Audience" />

</beans>

不管是使用JavaConfig還是XML，AspectJ自動代理都會為使用@Aspect註解的Bean建立一個代理，這個代理會圍繞著所有該切面的切點所匹配的Bean。
我們需要記住的是，Spring的AspectJ自動代理僅僅是使用@AspectJ作為建立切面的指導，但是本質上它仍然是Spring基於代理的切面，這一點很重要，因為這意味著儘管我們使用的@AspectJ註解，但是我們仍然受限於代理方法的呼叫，如果我們想利用AspectJ的所有能力，就必須使用AspectJ並且不依賴於Spring來建立切面。

建立環繞通知

環繞通知是最為強大的通知型別。它能將你所編寫的邏輯將被通知的目標方法完全包裝，實際上相當於在一個通知方法中同時編寫前置通知和後置通知。
為了闡述環繞通知，我們重寫Audience切面：

@Aspect
public class Audience {

    @Pointcut("execution(** concert.Performance.perform(..))")
    public void performance() {}

    @Around("performance()")
    public void watchPerformance(ProceedingJoinPoint jp) {
        try {
            System.out.println("Silencing cell phones");
            System.out.println("Taking seats");
            jp.proceed();
            System.out.println("CLAP CLAP CLAP!!!")；
        } catch (Throwable e) {
            System.out.println("Demanding a refund");
        }
    }
}       

處理通知中的引數

目前為止我們的切面都很簡單，沒有任何引數。但是如果切面所通知的方法確實有引數怎麼辦呢？切面能訪問和使用傳遞給被通知方法的引數嗎？

execution(* soundsystem.CompactDisc.playTrack(int)) && args(trackNumber)

我們需要關注的是切點表示式中的args(trackNumber)限定符。它表明傳遞給playTrack()方法的int型別引數也會傳遞到通知中去。引數的名稱trackNumber也與切點方法簽名中的引數相匹配。
這個引數會傳遞到通知方法中，這個通知方法是通過@Before註解和命名切點trackPlayed(trackNumber)定義的。切點定義中的引數與切點方法中的引數名稱是一樣的，這樣就完成了從命名切點到通知方法的引數轉移。

方法包裝僅僅是切面能實現的功能之一，下面看看如何通過編寫切面，為被通知的物件引入全新的功能。

通過註解引入新功能

public intereface Encoreable {
    void performEncore();
}

@Aspect class EncoreableIntroducer {
    @DeclareParents(value="concert.performance+",
                    defaultImpl=DefaultEncoreable.class)
    public static Encoreable encoreable;
}

可以看到，EncoreableIntroducer是一個切面，但是它與我們之前所建立的切面不同，它並沒有提供前置、後置、環繞通知，而是通過@DeclareParents註解，將Encoreable介面引入到Performance Bean中。
@DeclareParents註解由三部分組成：

• value：指明瞭哪種型別的Bean要引入該介面
• defaultImpl：指明瞭為引入功能提供實現的類
• @DeclareParents註解所標註的靜態屬性指明瞭要引入介面

和其他切面一樣，需要在Spring應用中將EncoreableIntroducer宣告為一個Bean：

<bean class="concert.EncoreableIntorducer" />

Spring的自動代理機制將會獲取到它的宣告，當Spring發現一個Bean使用了@Aspect註解時，Spring就會建立一個代理，然後將呼叫委託給被代理的Bean或被引入的實現，這取決於呼叫的方法屬於被代理的Bean還是屬於被引用的介面。

如果沒有原始碼，或者不想將AspectJ註解放到程式碼中，Spring也提供了在XML配置檔案中宣告切面的方案。

四、在XML中宣告切面

Spring的aop名稱空間中，提供了多個元素用來在XML中宣告切面：

<aop:advisor> 定義AOP通知器
<aop:after>   定義AOP後置通知（無論被通知方法是否執行成功）
<aop:after-returning> 定義AOP返回通知
<aop:after-throwing>  定義AOP異常通知
<aop:around>  定義AOP環繞通知
<aop:aspect>  定義一個切面
<aop:aspectj-autoproxy> 啟用@AspectJ註解驅動的切面  
<aop:before>  定義一個AOP前置通知  
<aop:config>  頂層的AOP配置元素，大多數的<aop:*>元素必須包含在<aop:config>元素內
<aop:declare-parents>  以透明的方式為被通知的物件引入額外的介面
<aop:pointcut>  定義一個切點

宣告前置、後置、環繞通知

<aop:config>
    <aop:aspect ref="audience">
        <aop:pointcut
            id="performance"
            expression="execution(** concert.Performance.perform(..))" />
        <aop:before
            pointcut-ref="performance"
            method="silenceCellPhones" />
        <aop:after-returning
            ... />
        <aop:after-throwing>
            ... />
    </aop:aspect>
</aop:config>

<aop:config>
    <aop:aspect ref="audience">
        <aop:pointcut
            id="performance"
            expression="execution(** concert.Performance.perform(..))" />
        <aop:around
            pointcut-ref="performance"
            method="watchPerformance" />
    </aop:aspect>
</aop:config>

為通知傳遞引數

...
...
...
<aop:config>
    <aop:aspect ref="trackNumber">
        <aop:pointcut
            id="trackplayed"
            expression="execution(** soundsystem.CompactDisc.playTrack(int)) and args(trackNumber)" />
        <aop:before
            pointcut-ref="trackplayed"
            method="countTrack" />
    </aop:aspect>
</aop:config>

通過切面引入新的功能

<aop:aspect>
    <aop:declare-parents
        types-matching="concert.Performance+"
        implement-interface="concert.Encoreable"
        default-impl="concert.DefaultEncoreable" />
</aop:aspect>

五、注入AspectJ切面

雖然Spring AOP能夠滿足許多應用的切面需求，但是與AspectJ相比，Spring AOP是一個功能比較弱的AOP解決方案。AspectJ提供了Spring AOP所不能支援的許多型別的切點。
例如我們需要在建立物件的時候應用通知，構造器切點就會很方便。但是由於Java的構造方法與普通方法是不同的，使得AOP無法將通知應用於物件的建立過程。所以我們就可以使用AspectJ切面來完成這部分的功能，並藉助Spring的依賴注入機制將Bean注入到AspectJ切面中。

舉個例子，現在需要給每場演出都建立一個評論員的角色，他會觀看演出並且會在演出結束之後提供一些意見。那麼下面的CriticAspect就是這樣一個評論員的切面：

使用AspectJ實現表演的評論員

//這是一個AspectJ檔案，並不是普通的Java檔案
public aspect CriticAspect {
    public CriticAspect(){ }

    //定義切點, 並且使得切點匹配perform()方法
    pointcut performamce() : execution(* perform(..));

    //定義通知型別, 並且匹配通知方法
    after() : performance() {
        System.out.println(criticismEngine.getCriticism());
    }

    //依賴注入
    //這裡並不是評論員這個類本身來發表評論,發表評論是由CriticismEngine這個介面的實現類提供的.
    //為了避免CriticAspect於CriticismEngine之間產生的不必要的耦合, 
    //我們通過Setter依賴注入為CriticAspect設定CriticismEngine.
    private CriticismEngine criticismEngine;

    public void setCriticismEngine(CriticismEngine criticismEngine){
        this.criticismEngine = criticismEngine;
    }
 }

CriticismEngine介面：

public interface CriticismEngine {
    String getCriticism();
}

CriticismEngineImpl類：

//CriticismEngineImpl類實現了CriticismEngine, 通過從注入的評論池中隨機選擇一個苛刻的評論
public class CriticismEngineImpl implements CriticismEngine {
    public CriticismEngineImpl(){ }

    public String getCriticism() {
        int i = (int) (Math.random() * criticismPool.length);
        return criticismPool[i];
    }

    private String[] criticismPool;
    public void setCriticismPool(String[] criticismPool){
        this.criticismPool =criticismPool;
    }
}

現在我們已經有了評論員切面CriticAspect，也有了評論類的實現CriticismEngineImpl，現在要做的事情就是在XML中宣告CriticismEngineImpl，然後再將CriticismEngine Bean注入到CriticAspect切面中：

    <!--在XML中裝配ASpectJ切面-->
    <bean id="criticismEngine" class="Concert.CriticismEngineImpl">
        <property name="criticismPool">
            <list>
                <value>個別演員的表情需要更豐富一點!</value>
                <value>背景音樂太難聽了!</value>
                <value>演員肢體動作太僵硬!</value>
                <value>服裝太醜了!</value>
            </list>
        </property>
    </bean>

    <bean class="Concert.CriticAspect" factory-method="aspectOf">
        <property name="criticismEngine" ref="criticismEngine" />
    </bean>

在上面的程式碼中，可以看到最大的不同就是使用了factory-method屬性。這是因為在通常情況下，Spring Bean由Spring容器初始化，但是AspectJ切面是由AspectJ在執行期建立的。也就是說，等到Spring有機會為CriticAspect注入criticismEngine時，CriticAspect已經被例項化了。所以Spring需要通過aspectOf()工廠方法獲得切面的引用，然後像< bean>元素規定的那樣在該物件上執行依賴注入。

aspectOf()方法是所有的AspectJ切面都會提供的一個靜態方法，該方法返回切面的一個單例。

現在我們已經覆蓋了Spring框架的基礎知識，瞭解到如何配置Spring容器以及如何為Spring管理的物件應用切面。下一章我們開始使用Spring構建真實的應用～