摘要：下圖展示了這些概念的關聯(lián)方式通知切面的工作被稱為通知。切面在指定的連接點被織入到目標對象中。該注解表明不僅僅是一個，還是一個切面。

在軟件開發(fā)中，散布于應用中多處的功能被稱為橫切關注點（crosscutting concern）。通常來講，這些橫切關注點從概念上是與應用的業(yè)務邏輯相分離的（但是往往會直接嵌入到應用的業(yè)務邏輯之中）。把這些橫切關注點與業(yè)務邏輯相分離正是面向切面編程（AOP）所要解決的問題

下圖展現(xiàn)了一個被劃分為模塊的典型應用。每個模塊的核心功能都是為特定業(yè)務領域提供服務，但是這些模塊都需要類似的輔助功能，例如安全和事務管理

切面提供了取代繼承和委托的方案，且在很多場景下更清晰簡潔。使用面向切面編程時，仍然在一個地方定義通用功能，但是可以通過聲明的方式定義這個功能要以何種方式在何處應用，而無需修改受影響的類。橫切關注點可以被模塊化為特殊的類，這些類被稱為切面（aspect）

這樣做有兩個好處：首先，現(xiàn)在每個關注點都集中于一個地方，而不是分散到多處代碼中；其次，服務模塊更簡潔，因為它們只包含主要關注點（或核心功能）的代碼，而次要關注點的代碼被轉移到切面中

描述切面的常用術語有通知（advice）、切點（pointcut）和連接點（join point）。下圖展示了這些概念的關聯(lián)方式

切面的工作被稱為通知。通知定義了切面是什么以及何時使用

Spring切面可以應用5種類型的通知：

前置通知（Before）：在目標方法被調(diào)用之前調(diào)用通知功能

后置通知（After）：在目標方法完成之后調(diào)用通知，此時不會關心方法的輸出是什么

返回通知（After-returning）：在目標方法成功執(zhí)行之后調(diào)用通知

異常通知（After-throwing）：在目標方法拋出異常后調(diào)用通知

環(huán)繞通知（Around）：通知包裹了被通知的方法，在被通知的方法調(diào)用之前和調(diào)用之后執(zhí)行自定義的行為

連接點是在應用執(zhí)行過程中能夠插入切面的一個點。這個點可以是調(diào)用方法時、拋出異常時、甚至修改一個字段時。切面代碼可以利用這些點插入到應用的正常流程之中，并添加新的行為

通知定義了切面的“什么”和“何時”的話，切點定義了“何處”。切點的定義會匹配通知所要織入的一個或多個連接點

通常使用明確的類和方法名稱，或是利用正則表達式定義所匹配的類和方法名稱來指定這些切點。有些AOP框架允許創(chuàng)建動態(tài)的切點，可以根據(jù)運行時的決策（比如方法的參數(shù)值）來決定是否應用通知

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

引入允許我們向現(xiàn)有的類添加新方法或?qū)傩浴＠纾覀兛梢詣?chuàng)建一個Auditable通知類，該類記錄了對象最后一次修改時的狀態(tài)。這很簡單，只需一個方法，setLastModified(Date)，和一個實例變量來保存這個狀態(tài)。然后，這個新方法和實例變量就可以被引入到現(xiàn)有的類中，從而可以在無需修改這些現(xiàn)有的類的情況下，讓它們具有新的行為和狀態(tài)

織入是把切面應用到目標對象并創(chuàng)建新的代理對象的過程。切面在指定的連接點被織入到目標對象中。在目標對象的生命周期里有多個點可以進行織入：

編譯期：切面在目標類編譯時被織入。這種方式需要特殊的編譯器。AspectJ的織入編譯器就是以這種方式織入切面的

類加載期：切面在目標類加載到JVM時被織入。這種方式需要特殊的類加載器（ClassLoader），它可以在目標類被引入應用之前增強該目標類的字節(jié)碼。AspectJ 5的加載時織入（load-time weaving，LTW）就支持以這種方式織入切面

運行期：切面在應用運行的某個時刻被織入。一般情況下，在織入切面時，AOP容器會為目標對象動態(tài)地創(chuàng)建一個代理對象。Spring AOP就是以這種方式織入切面的

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

基于代理的經(jīng)典Spring AOP

純POJO切面

@AspectJ注解驅(qū)動的切面

注入式AspectJ切面（適用于Spring各版本）

Spring所創(chuàng)建的通知都是用標準的Java類編寫的。而且，定義通知所應用的切點通常會使用注解或在Spring配置文件里采用XML來編寫

AspectJ與之相反。雖然AspectJ現(xiàn)在支持基于注解的切面，但AspectJ最初是以Java語言擴展的方式實現(xiàn)的。這種方式有優(yōu)點也有缺點。通過特有的AOP語言，我們可以獲得更強大和細粒度的控制，以及更豐富的AOP工具集，但是我們需要額外學習新的工具和語法

通過在代理類中包裹切面，Spring在運行期把切面織入到Spring管理的bean中。如圖所示，代理類封裝了目標類，并攔截被通知方法的調(diào)用，再把調(diào)用轉發(fā)給真正的目標bean。當代理攔截到方法調(diào)用時，在調(diào)用目標bean方法之前，會執(zhí)行切面邏輯

Spring的切面由包裹了目標對象的代理類實現(xiàn)。代理類處理方法的調(diào)用，執(zhí)行額外的切面邏輯，并調(diào)用目標方法

直到應用需要被代理的bean時，Spring才創(chuàng)建代理對象。如果使用的是ApplicationContext的話，在ApplicationContext從BeanFactory中加載所有bean的時候，Spring才會創(chuàng)建被代理的對象。因為Spring運行時才創(chuàng)建代理對象，所以我們不需要特殊的編譯器來織入Spring AOP的切面

通過使用各種AOP方案可以支持多種連接點模型。因為Spring基于動態(tài)代理，所以Spring只支持方法連接點。Spring缺少對字段連接點的支持，無法讓我們創(chuàng)建細粒度的通知，例如攔截對象字段的修改。而且它不支持構造器連接點，我們就無法在bean創(chuàng)建時應用通知。但是方法攔截可以滿足絕大部分的需求。如果需要方法攔截之外的連接點攔截功能，那么可以利用Aspect來補充Spring AOP的功能

關于Spring AOP的AspectJ切點，Spring僅支持AspectJ切點指示器（pointcut designator）的一個子集。下表列出了Spring AOP所支持的AspectJ切點指示器：

在Spring中嘗試使用AspectJ其他指示器時，將會拋出IllegalArgument-Exception異常

注：只有execution指示器是實際執(zhí)行匹配的，而其他的指示器都是用來限制匹配的。說明execution指示器是在編寫切點定義時最主要使用的指示器

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

Performance可以代表任何類型的現(xiàn)場表演，如舞臺劇、電影或音樂會。設想編寫Performance的perform()方法觸發(fā)的通知。下圖展現(xiàn)了一個切點表達式，這個表達式能夠設置當perform()方法執(zhí)行時觸發(fā)通知的調(diào)用

使用AspectJ切點表達式來選擇Performance的perform()方法：

使用execution()指示器選擇Performance的perform()方法。方法表達式以“*”號開始，表明了不關心方法返回值的類型。然后指定全限定類名和方法名。對于方法參數(shù)列表，使用兩個點號（..）表明切點要選擇任意的perform()方法，無論該方法的入?yún)⑹鞘裁?/p>

設現(xiàn)需配置的切點僅匹配concert包。在此場景下，可以使用within()指示器限制切點范圍：

and代替“&&”，or代替“||”，not代替“!”

Spring引入新的bean()指示器，它允許在切點表達式中使用bean的ID來標識bean。bean()使用bean ID或bean名稱作為參數(shù)來限制切點只匹配特定的bean

執(zhí)行Performance的perform()方法時應用通知，但限定bean的ID為woodstock:

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

使用非操作為除了特定ID以外的其他bean應用通知：

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

//Audience類：觀看演出的切面

package concert;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@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 demandRefound()
    {
        System.out.println("Demanding a refund");
    }
}    

Audience類使用@AspectJ注解進行了標注。該注解表明Audience不僅僅是一個POJO，還是一個切面。Audience類中的方法都使用注解來定義切面的具體行為

Spring使用AspectJ注解來聲明通知方法：

為@Pointcut注解設置的值是一個切點表達式，就像之前在通知注解上所設置的那樣。通過在performance()方法上添加@Pointcut注解，實際上擴展了切點表達式語言，這樣就可以在任何的切點表達式中使用performance()了，如果不這樣做的話，需要在這些地方使用那個更長的切點表達式

現(xiàn)在把所有通知注解中的長表達式都替換成了performance()，該方法的實際內(nèi)容并不重要，在這里實際上是空的。其實該方法本身只是一個標識，供@Pointcut注解依附

// 通過@Pointcut注解聲明頻繁使用的切點表達式

package concert;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.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("execution(** concert.Performance.perform(..))")        // 表演之前
    public void takeSeats()
    {
        System.out.println("Taking seats");
    }        
    @AfterReturning("performance()")        // 表演之后
    public void applause()
    {
        System.out.println("CLAP CLAP CLAP!!!");
    }
    @AfterThrowing("performance()")        // 表演失敗之后
    public void demandRefound()
    {
        System.out.println("Demanding a refund");
    }
}       

像其他的Java類一樣，它可以裝配為Spring中的bean：

@Bean 
public Audience audience()
{
    return new Audience();
}

通過上述操作，Audience只會是Spring容器中的一個bean。即便使用了AspectJ注解，但它并不會被視為切面，這些注解不會解析，也不會創(chuàng)建將其轉換為切面的代理

使用JavaConfig可以在配置類的類級別上通過使用EnableAspectJ-AutoProxy注解啟用自動代理功能：

package concert;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

// 啟動AspectJ自動代理
@Configuration                
@EnableAspectJAutoProxy
@ComponentScan

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

使用XML來裝配bean需要使用Springaop命名空間中的元素

// 在XML中，通過Spring的aop命名空間啟用AspectJ自動代理



    
                    // 啟動AspectJ自動代理
            // 聲明Audience bean

JavaConfig和XML配置，AspectJ自動代理都會為使用@Aspect注解的bean創(chuàng)建一個代理，這個代理會圍繞著所有該切面的切點所匹配的bean。在這種情況下，將會為Concert bean創(chuàng)建一個代理，Audience類中的通知方法將會在perform()調(diào)用前后執(zhí)行

Spring的AspectJ自動代理僅僅使用@AspectJ作為創(chuàng)建切面的指導，切面依然是基于代理的。在本質(zhì)上，它依然是
Spring基于代理的切面。這一點非常重要，因為這意味著盡管使用的是@AspectJ注解，但我們?nèi)匀幌抻诖矸椒ǖ恼{(diào)用。如果想利用AspectJ的所有能力，我們必須在運行時使用AspectJ并且不依賴Spring來創(chuàng)建基于代理的切面

環(huán)繞通知是最為強大的通知類型。能夠讓所編寫的邏輯被通知的目標方法完全包裝起來。實際上就像在一個通知方法中同時編寫前置通知和后置通知

// 使用環(huán)繞通知重新實現(xiàn)Audience切面
package concert;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

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

@Around注解表明watchPerformance()方法會作為performance()切點的環(huán)繞通知。首先接受ProceedingJoinPoint作為參數(shù)。這個對象是必須要有的，因為在通知中需要通過它來調(diào)用被通知的方法。通知方法中可以做任何的事情，當要將控制權交給被通知的方法時，它需要調(diào)用ProceedingJoinPoint的proceed()方法

注：調(diào)用proceed()方法。如不調(diào)該方法，那么通知實際上會阻塞對被通知方法的調(diào)用；若不調(diào)用proceed()方法，會阻塞對被通知方法的訪問，與之類似，也可以在通知中對它進行多次調(diào)用

創(chuàng)建TrackCounter類，用來記錄每個磁道所播放的次數(shù)，是通知playTrack()方法的一個切面。下面的程序清單展示了這個切面：

// 使用參數(shù)化的通知來記錄磁道播放的次數(shù)
package soundsystem;
import java.util.HashMap;
import java.util.Map;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class TrackCounter
{
    private Map TrackCounts = new HashMap();
    
    // 通知playTrack()方法
    @Pointcut(
        "execution(* soundsystem.CompactDisc.playTrack(int))" +
        "&& args(trackNumber)" )
    public void trackPlayed(int trackNumber){}
    
    @Before("trackPlayed(trackNumber)")            // 在播放前，為該磁道計數(shù)
    public void countTrack(int trackNumber)
    {
        int currentCount = getPlayCount(trackNumber);
        trackCounts.put(trackNumber, currentCount + 1);
    }
    
    public int getPlayCount(int trackNumber)
    {
        return trackCounts.containsKey(trackNumber) ? trackCounts.get(trackNumber) : 0;
    }
}

在切點表達式中聲明參數(shù)，這個參數(shù)傳入到通知方法中：

切點表達式中的args(trackNumber)限定符。表明傳遞給playTrack()方法的int類型參數(shù)也會傳遞到通知中去。參數(shù)的名稱trackNumber也與切點方法簽名中的參數(shù)相匹配

這個參數(shù)會傳遞到通知方法中，這個通知方法是通過@Before注解和命名切點trackPlayed(trackNumber)定義的。切點定義中的參數(shù)與切點方法中的參數(shù)名稱是一樣的，這樣就完成了從命名切點到通知方法的參數(shù)轉移

// 配置TrackCount記錄每個磁道播放的次數(shù)
package soundsystem;
import java.util.ArrayList;
import java.List;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy                    // 啟用AspectJ自動代理
public class TrackCounterConfig
{
    @Bean
    public CompactDisc sgtPeppers()        // CompactDisc bean
    {
        BlankDisc cd = new BlankDisc();
        cd.setTitle("Sgt. Pepper"s Lonely Hearts Club Band");
        cd.setArtist("The Beales");
        List tracks = new ArrayList();
        tracks.add("Sgt. Pepper"s Lonely Hearts Club Band");
        tracks.add("With a Little Help from My Friends");
        tracks.add("Lucy in the Sky with Diamonds");
        tracks.add("Getting Better");
        tracks.add("Fixing a Hole");
        
        // ...other tracks omitted for brevity...
        cd.setTracks(tracks);
        return cd;
    }
    
    @Bean
    public TrackCounter trackCounter()        // TrackCounter bean
    {
        return new TrackCounter();
    }
}

使用Spring AOP，我們可以為bean引入新的方法。代理攔截調(diào)用并委托給實現(xiàn)該方法的其他對象

為示例中的所有的Performance實現(xiàn)引入下面的Encoreable接口：

package concert;
public interface Encoreable
{
    void performEncore();
}

借助于AOP的引入功能，不必在設計上妥協(xié)或者侵入性地改變現(xiàn)有的實現(xiàn)。為了實現(xiàn)該功能，創(chuàng)建一個新
的切面：

package concert;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;

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

EncoreableIntroducer是一個切面。但是它與之前所創(chuàng)建的切面不同，并沒有提供前置、后置或環(huán)繞通知，而是
通過@DeclareParents注解，將Encoreable接口引入到Performance bean中

@DeclareParents注解由三部分組成：

value屬性指定了哪種類型的bean要引入該接口。在本例中，也就是所有實現(xiàn)Performance的類型。（標記符后面的加號表示是Performance的所有子類型，而不是Performance本身。）

defaultImpl屬性指定了為引入功能提供實現(xiàn)的類。這里指定的是DefaultEncoreable提供實現(xiàn)

@DeclareParents注解所標注的靜態(tài)屬性指明了要引入了接口。這里所引入的是Encoreable接口

和其他的切面一樣，需要在Spring應用中將EncoreableIntroducer聲明為一個bean：

Spring的自動代理機制將會獲取到它的聲明，當Spring發(fā)現(xiàn)一個bean使用了@Aspect注解時，Spring就會創(chuàng)建一個代理，然后將調(diào)用委托給被代理的bean或被引入的實現(xiàn)，這取決于調(diào)用的方法屬于被代理的bean還是屬于被引入的接口

為演出創(chuàng)建一個新切面。具體來講，以切面的方式創(chuàng)建一個評論員的角色，他會觀看演出并且會在演出之后提供一些批評意見

// 使用AspectJ實現(xiàn)表演的評論員
package concert;
public aspect CriticAspect{
    public CriticAspect(){}
    
    pointcut performance() : execution(* perform(..));
    afterReturning() : performance()
    {
        System.out.println(criticismEngine.getCriticism());
    }
    private CriticismEngine criticismEngine;
    
    public void setCriticismEngine(CriticismEngine criticismEngine)        // 注入CriticismEngine
    {
        this.criticismEngine = criticismEngine;
    }
}

上述程序中的performance()切點匹配perform()方法。當它與afterReturning()通知一起配合使用時，可以讓該切面在表演結束時起作用

實際上，CriticAspect與一個CriticismEngine對象相協(xié)作，在表演結束時，調(diào)用該對象的getCriticism()方法來發(fā)表一個苛刻的評論。為了避免CriticAspect和CriticismEngine之間產(chǎn)生不必要的耦合，我們通過Setter依賴注入為CriticAspect設置CriticismEngine。此關系如下圖所示：

切面也需要注入。像其他的bean一樣，Spring可以為AspectJ切面注入依賴

 要注入到CriticAspect中的CriticismEngine實現(xiàn)
package com.springinaction.springidol;
public class CriticismEngineImpl implements CriticismEngine
{
    public CriticismEngineImpl(){}
    
    public String getCriticism()
    {
        int i = (int) (Math.random() * criticismPool.length)
        return criticismPool[i];
    }
    
    // injected
    private String[] criticismPool;
    public void setCriticismPool(String[] criticismPool)
    {
        this.criticismPool = criticismPool;
    }
}

CriticismEngineImpl實現(xiàn)了CriticismEngine接口，通過從注入的評論池中隨機選擇一個苛刻的評論

使用XML聲明Spring bean：

    
        
            Worst performance ever!
            I laughed, I cried, then I realized I was at the wrong show.
            A must see show! 
        
    

現(xiàn)在有了一個要賦予CriticAspect的Criticism-Engine實現(xiàn)。剩下的就是為CriticAspect裝配CriticismEngineImple。在展示如何實現(xiàn)注入之前，必須清楚AspectJ切面根本不需要Spring就可以織入到我們的應用中。如果想使用Spring的依賴注入為AspectJ切面注入?yún)f(xié)作者，那我們就需要在Spring配置中把切面聲明為一個Spring配置中的。如下的聲明會把criticismEnginebean注入到CriticAspect中：

Spring需要通過aspectOf()工廠方法獲得切面的引用，然后像元素規(guī)定的那樣在該對象上執(zhí)行依賴注入