原本地址：SpringMVC乾貨系列：從零搭建SpringMVC+mybatis（四）：Spring兩大核心之AOP學習
部落格地址：tengj.top/

前言

上一篇我們介紹了Spring的核心概念DI,DI有助與應用物件之間的解耦。今天我們就來介紹下另一個非常核心的概念，面向切面程式設計AOP。

正文

在軟體開發中，散佈於應用中多處的功能被稱為橫切關注點（cross-cutting concern）。通常來講，這些橫切關注點從概念上是與應用的業務邏輯相分離的。比如：日誌、宣告式事物、安全和快取。這些東西都不是我們平時寫程式碼的核心功能，但許多地方都要用到。

把這些橫切關注點與業務相分離正是面向切面程式設計（AOP）索要解決的問題。

簡單的說就是把這些許多地方都要用到，但又不是核心業務的功能，單獨剝離出來封裝，通過配置指定要切入到指定的方法中去。

什麼是面向切面程式設計

如上圖所示，這就是橫切關注點的概念，水平的是核心業務，這些切入的箭頭就是我們的橫切關注點。
橫切關注點可以被模組化為特殊的類，這些類被稱為切面（aspect）。這樣做有兩個好處：

• 首先，現在每個關注點都集中於一個地方，而不是分割到多處程式碼中
• 其次，服務模組更簡潔，因為它們只包含主要關注點（或核心功能）的程式碼，而次要關注點的程式碼被轉移到切面中了。

定義AOP術語

為了理解AOP，我們必須先了解AOP的相關術語，很簡單不難:

通知（Advice）：
在AOP中，切面的工作被稱為通知。通知定義了切面“是什麼”以及“何時”使用。除了描述切面要完成的工作，通知還解決了何時執行這個工作的問題。

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

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

連線點（Join point）：
連線點是在應用執行過程中能夠插入切面的一個點。這個點可以是呼叫方法時、丟擲異常時、甚至修改一個欄位時。切面程式碼可以利用這些點插入到應用的正常流程之中，並新增行為。

切點（Pointcut）:
如果說通知定義了切面“是什麼”和“何時”的話，那麼切點就定義了“何處”。比如我想把日誌引入到某個具體的方法中，這個方法就是所謂的切點。

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

引入（Introduction）：
引入允許我們向現有的類新增新的方法和屬性(Spring提供了一個方法注入的功能）。

織入(Weaving)：
把切面應用到目標物件來建立新的代理物件的過程，織入一般發生在如下幾個時機:

• 編譯時：當一個類檔案被編譯時進行織入，這需要特殊的編譯器才可以做的到，例如AspectJ的織入編譯器
• 類載入時：使用特殊的ClassLoader在目標類被載入到程式之前增強類的位元組程式碼
• 執行時：切面在執行的某個時刻被織入,SpringAOP就是以這種方式織入切面的，原理應該是使用了JDK的動態代理技術

Spring對AOP的支援

建立切入點來定義切面所織入的連線點是AOP框架的基本功能。
Spring提供了4種型別的AOP支援：

• 基於代理的經典Spring AOP
• 純POJO切面
• @AspectJ註解驅動的切面
• 注入式AspectJ切面（使用與Spring各版本）

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

這裡我不準備介紹經典Spring AOP，因為引入了簡單的宣告式AOP和基於直接的AOP後，Spring經典的AOP看起來就顯得非常笨重和過於複雜。

對於新手入門來說，我們不需要知道這麼多，在這裡我也只介紹2,3兩種方式，簡單的說就是一個基於xml配置，一個基於註解。

下面就直接開始舉兩個例子分別來介紹下這兩種AOP方式，我們就拿簡單的日誌來說明。

基於註解的方式

首先基於註解的方式需要引入這些包，對用的pom.xml如下：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.1.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.8</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.8</version>
</dependency>複製程式碼

我們還是舉前面用到的UserController來說明，下面方法很簡單，執行進入這個方法的時候會列印“進來了”資訊，現在我打算給這個方法加日誌，在執行該方法前列印“進來前”，在執行完方法後執行“進來後”。

package com.tengj.demo.controller;

@Controller
@RequestMapping(value="/test")
public class UserController {
    @Autowired
    UserService userService;

    @RequestMapping(value="/view",method = RequestMethod.GET)
    public String index(){
        userService.sayHello("tengj");
        return "index";
    }
}複製程式碼

servie層程式碼：

package com.tengj.demo.service
public interface UserService {
    public void sayHello(String name);
}複製程式碼

servie實現類程式碼：

package com.tengj.demo.service.impl;
@Service("userService")
public class UserServiceImpl implements UserService{
    @Override
    public void sayHello(String name) {
        System.out.println("hello，"+name);
    }
}複製程式碼

上面方法index()其實就是我們之前定義的切點，表示在哪裡切入AOP。

如圖所示，我們使用execution()指示器選擇UserServiceImpl的sayHello方法。方法表示式以“*”號開始，表明了我們不關心方法返回值的型別。然後，我們指定了全限定類名和方法名。對於方法引數列表，我們使用兩個點號（..）表明切點要選擇任意的sayHello()方法，無論該方法的入參是什麼。

接下來我們要定義個切面，也就是所謂的日誌功能的類。

package com.tengj.demo.aspect;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component //注入依賴
@Aspect //該註解標示該類為切面類
public class LogAspect {
    @Pointcut("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
    public void logAop(){}

    @Before("logAop() && args(name)")
    public void logBefore(String name){
        System.out.println(name+"前置通知Before");
    }

    @AfterReturning("logAop()")
    public void logAfterReturning(){
        System.out.println("返回通知AfterReturning");
    }

    @After("logAop() && args(name)")
    public void logAfter(String name){
        System.out.println(name+"後置通知After");
    }

    @AfterThrowing("logAop()")
    public void logAfterThrow(){
        System.out.println("異常通知AfterThrowing");
    }
}複製程式碼

上面就是切面類的程式碼，很簡單，這裡用到了前面提的通知的幾種型別。
這樣就能實現切入功能了

@Pointcut("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
public void logAop(){}複製程式碼

這裡的@Pointcut註解是為了定義切面內重用的切點，也就是說把公共的東西抽出來，定義了任意的方法名稱logAop，這樣下面用到的各種型別通知就只要寫成

@Before("logAop() && args(name)")
@AfterReturning("logAop()")
@AfterThrowing("logAop()")複製程式碼

這樣既可，否則就要寫成

@Before("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
@AfterReturning("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")
@AfterThrowing("execution(* com.tengj.demo.service.impl.UserServiceImpl.*(..))")複製程式碼

大家是否注意到了@Before("logAop() && args(name)")這裡多出來個&& args(name),這個是用來傳遞引數的，定義只要跟sayHello引數名稱一樣就可以。

如果就此止步的話，LogAspect只會是Spring容器中的一個Bean,即便使用了AspectJ註解，但它並不會被視為切面，這些註解不會解析，也不會建立將其轉換為切面的代理。

所以需要在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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-4.1.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd"
       default-lazy-init="true">
    <context:component-scan base-package="com.tengj.demo"/>
    <mvc:resources location="/WEB-INF/pages/" mapping="/pages/**"/>
    <!-- 預設的註解對映的支援 -->
    <mvc:annotation-driven/>
    <!--啟用AspectJ自動代理-->
    <aop:aspectj-autoproxy/>
    <!-- 檢視解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>複製程式碼

接著就可以啟動工程，訪問index這個方法，http://localhost:8080/SpringMVCMybatis/test/view
執行結果：

tengj前置通知Before
hello，tengj
tengj後置通知After
返回通知AfterReturning複製程式碼

根據前面學的我們知道，除了上面提到的通知外，還有一個更強大通知型別，就是環繞通知。可以自定義我們需要切入的位置，可以替代上面提到的所有通知。看例子：

@Around("logAop()")
public void logAround(ProceedingJoinPoint jp){
    try {
        System.out.println("自定義前置通知Before");
        jp.proceed();//將控制權交給被通知的方法，也就是執行sayHello方法
        System.out.println("自定義後置通知After");
    } catch (Throwable throwable) {
        System.out.println("異常處理~");
        throwable.printStackTrace();
    }
}複製程式碼

執行結果：

自定義前置通知Before
hello，tengj
自定義後置通知After複製程式碼

這裡主要是通過ProceedingJoinPoint這個引數。其中裡面的proceed()方法就是將控制權交給被通知的方法。如果你忘記呼叫這個方法，那麼你的通知實際上會阻塞對被通知方法的呼叫。

有意思的是，你可以不呼叫proceed()方法，從而阻塞堆被通知方法的訪問，與之類似，你也可以在通知中對它進行多次呼叫。要這樣做的一個場景就是實現重試邏輯，也就是在被通知方法失敗後，進行重複嘗試。

基於XML配置的方式

這裡介紹使用XML配置的方式來實現，在Spring的aop名稱空間中，提供了多個元素用來在XML中宣告切面。

AOP配置元素	用 途
<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:aspectj-autoproxy/>元素，它能夠自動代理AspectJ註解的通知類。aop名稱空間的其他元素能夠讓我們直接在Spring配置中宣告切面，而不需要使用註解。
所以，我們重新來看看一下這個LogAspect類，這次我們將它所有的AspectJ註解全部移除掉：

package com.tengj.demo.aspect;

public class LogAspect {
    public void logBefore(String name){
        System.out.println(name+"前置通知Before");
    }

    public void logAfterReturning(String name){
        System.out.println("返回通知AfterReturning");
    }

    public void logAfter(String name){
        System.out.println(name+"後置通知After");
    }

    public void logAfterThrow(String name){
        System.out.println("異常通知AfterThrowing");
    }
}複製程式碼

然後在xml配置檔案中使用Spring aop名稱空間中的一些元素，詳細基本配置參考上面註解方式中的xml配置，這裡是貼出來關鍵的程式碼：

<bean id="logAspect" class="com.tengj.demo.aspect.LogAspect" />
<aop:config>
        <aop:aspect id="log"  ref="logAspect">
            <aop:pointcut id="logAop" expression="execution(* com.tengj.demo.service.impl.UserServiceImpl.sayHello(..)) and args(name)"/>
            <aop:before method="logBefore" pointcut-ref="logAop"/>
            <aop:after method="logAfter"  pointcut-ref="logAop"/>
            <aop:after-returning method="logAfterReturning"  pointcut-ref="logAop"/>
            <aop:after-throwing method="logAfterThrow" pointcut-ref="logAop"/>
            <!--<aop:around method="logAfterThrow"  pointcut-ref="logAop"/>-->
        </aop:aspect>
</aop:config>複製程式碼

配置也 很好理解

• xml裡面配置aop，都是放在<aop:config>裡面
• 然後使用<aop:aspect>一個切面，指向具體的bean類。
• 使用<aop:pointcut>定義切點，基本跟註解的很像，其中要注意的是xml配置裡面如果要帶引數的，用的不再是&&，要使用and關鍵字才行（因為在XML中，“&”符號會被解析為實體的開始）
• 然後就是使用各種通知標籤了，簡單。

執行效果如下：

tengj前置通知Before
hello，tengj
tengj後置通知After
返回通知AfterReturning複製程式碼

環繞通知也很簡單，直接貼程式碼：
xml配置：

<aop:around method="logAround"  pointcut-ref="logAop"/>複製程式碼

切面方法：

public void logAround(ProceedingJoinPoint jp,String name){
    try {
        System.out.println(name+"自定義前置通知Before");
        jp.proceed();
        System.out.println(name+"自定義後置通知After");
    } catch (Throwable throwable) {
        System.out.println("異常處理~");
        throwable.printStackTrace();
    }
}複製程式碼

執行結果：

tengj自定義前置通知Before
hello，tengj
tengj自定義後置通知After複製程式碼

總結

Spring AOP是Spring學習中最關鍵的，我總結的這2種寫法也是開發中最常用的。也不知道大家能不能理解~看得時候如果有不懂的地方可以提出來，我好修改一下，讓更多的人理解並掌握AOP，希望對你有所幫助。

---

一直覺得自己寫的不是技術，而是情懷，一篇篇文章是自己這一路走來的痕跡。靠專業技能的成功是最具可複製性的，希望我的這條路能讓你少走彎路，希望我能幫你抹去知識的蒙塵，希望我能幫你理清知識的脈絡，希望未來技術之巔上有你也有我。

訂閱博主微信公眾號：嘟爺java超神學堂（javaLearn）三大好處：

• 獲取最新博主部落格更新資訊，首發公眾號
• 獲取大量視訊，電子書，精品破解軟體資源
• 可以跟博主聊天，歡迎程式媛妹妹來撩我

掘金技術徵文第三期：聊聊你的最佳實踐