Spring(4)——面向切面編程（AOP模塊）

時間  2019-11-13
標籤 spring 面向 切面 編程 aop 模塊 欄目 Spring 简体版
原文   原文鏈接

Spring AOP 簡介

若是說 IoC 是 Spring 的核心，那麼面向切面編程就是 Spring 最爲重要的功能之一了，在數據庫事務中切面編程被普遍使用。java

AOP 即 Aspect Oriented Program 面向切面編程

首先，在面向切面編程的思想裏面，把功能分爲核心業務功能，和周邊功能。git

  • 所謂的核心業務，好比登錄，增長數據，刪除數據都叫核心業務
  • 所謂的周邊功能，好比性能統計，日誌，事務管理等等

周邊功能在 Spring 的面向切面編程AOP思想裏，即被定義爲切面github

在面向切面編程AOP的思想裏面，核心業務功能和切面功能分別獨立進行開發，而後把切面功能和核心業務功能 "編織" 在一塊兒，這就叫AOPweb

AOP 的目的

AOP可以將那些與業務無關，卻爲業務模塊所共同調用的邏輯或責任（例如事務處理、日誌管理、權限控制等）封裝起來，便於減小系統的重複代碼，下降模塊間的耦合度，並有利於將來的可拓展性和可維護性。正則表達式

AOP 當中的概念：

  • 切入點（Pointcut）
    在哪些類，哪些方法上切入（where）
  • 通知（Advice）
    在方法執行的什麼實際（when:方法前/方法後/方法先後）作什麼（what:加強的功能）
  • 切面（Aspect）
    切面 = 切入點 + 通知，通俗點就是：在什麼時機，什麼地方，作什麼加強！
  • 織入（Weaving）
    把切面加入到對象，並建立出代理對象的過程。（由 Spring 來完成）

一個例子

爲了更好的說明 AOP 的概念，咱們來舉一個實際中的例子來講明：spring

在上面的例子中，包租婆的核心業務就是籤合同，收房租，那麼這就夠了，灰色框起來的部分都是重複且邊緣的事，交給中介商就行了，這就是 AOP 的一個思想：讓關注點代碼與業務代碼分離！數據庫

實際的代碼

咱們來實際的用代碼感覺一下express

1.在 Package【pojo】下新建一個【Landlord】類（我百度翻譯的包租婆的英文）：編程

package pojo;

import org.springframework.stereotype.Component;

@Component("landlord")
public class Landlord {

    public void service() {
        // 僅僅只是實現了核心的業務功能
        System.out.println("籤合同");
        System.out.println("收房租");
    }
}

2.在 Package【aspect】下新建一箇中介商【Broker】類（我仍是用的翻譯...）：微信

package aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

    @Before("execution(* pojo.Landlord.service())")
    public void before(){
        System.out.println("帶租客看房");
        System.out.println("談價格");
    }

    @After("execution(* pojo.Landlord.service())")
    public void after(){
        System.out.println("交鑰匙");
    }
}

3.在 applicationContext.xml 中配置自動注入，並告訴 Spring IoC 容器去哪裏掃描這兩個 Bean：

<?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="aspect" />
    <context:component-scan base-package="pojo" />

    <aop:aspectj-autoproxy/>
</beans>

4.在 Package【test】下編寫測試代碼：

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Landlord;

public class TestSpring {

    public static void main(String[] args) {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Landlord landlord = (Landlord) context.getBean("landlord", Landlord.class);
        landlord.service();

    }
}

5.執行看到效果：

這個例子使用了一些註解，如今看不懂沒有關係，但咱們能夠從上面能夠看到，咱們在 Landlord 的 service() 方法中僅僅實現了核心的業務代碼，其他的關注點功能是根據咱們設置的切面自動補全的。

使用註解來開發 Spring AOP

使用註解的方式已經逐漸成爲了主流，因此咱們利用上面的例子來講明如何用註解來開發 Spring AOP

第一步：選擇鏈接點

Spring 是方法級別的 AOP 框架，咱們主要也是以某個類額某個方法做爲鏈接點，另外一種說法就是：選擇哪個類的哪一方法用以加強功能。

....
    public void service() {
        // 僅僅只是實現了核心的業務功能
        System.out.println("籤合同");
        System.out.println("收房租");
    }
    ....

咱們在這裏就選擇上述 Landlord 類中的 service() 方法做爲鏈接點。

第二步：建立切面

選擇好了鏈接點就能夠建立切面了，咱們能夠把切面理解爲一個攔截器，當程序運行到鏈接點的時候，被攔截下來，在開頭加入了初始化的方法，在結尾也加入了銷燬的方法而已，在 Spring 中只要使用 @Aspect 註解一個類，那麼 Spring IoC 容器就會認爲這是一個切面了：

package aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

    @Before("execution(* pojo.Landlord.service())")
    public void before(){
        System.out.println("帶租客看房");
        System.out.println("談價格");
    }

    @After("execution(* pojo.Landlord.service())")
    public void after(){
        System.out.println("交鑰匙");
    }
}
  • 注意： 被定義爲切面的類仍然是一個 Bean ，須要 @Component 註解標註

代碼部分中在方法上面的註解看名字也能猜出個大概，下面來列舉一下 Spring 中的 AspectJ 註解：

註解 說明
@Before 前置通知，在鏈接點方法前調用
@Around 環繞通知，它將覆蓋原有方法，可是容許你經過反射調用原有方法，後面會講
@After 後置通知，在鏈接點方法後調用
@AfterReturning 返回通知，在鏈接點方法執行並正常返回後調用，要求鏈接點方法在執行過程當中沒有發生異常
@AfterThrowing 異常通知，當鏈接點方法異常時調用

有了上表，咱們就知道 before() 方法是鏈接點方法調用前調用的方法，而 after() 方法則相反，這些註解中間使用了定義切點的正則式，也就是告訴 Spring AOP 須要攔截什麼對象的什麼方法，下面講到。

第三步：定義切點

在上面的註解中定義了 execution 的正則表達式，Spring 經過這個正則表達式判斷具體要攔截的是哪個類的哪個方法：

execution(* pojo.Landlord.service())

依次對這個表達式做出分析：

  • execution：表明執行方法的時候會觸發
  • * ：表明任意返回類型的方法
  • pojo.Landlord：表明類的全限定名
  • service()：被攔截的方法名稱

經過上面的表達式，Spring 就會知道應該攔截 pojo.Lnadlord 類下的 service() 方法。上面的演示類還好，若是多出都須要寫這樣的表達式不免會有些複雜，咱們能夠經過使用 @Pointcut 註解來定義一個切點來避免這樣的麻煩：

package aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

    @Pointcut("execution(* pojo.Landlord.service())")
    public void lService() {
    }

    @Before("lService()")
    public void before() {
        System.out.println("帶租客看房");
        System.out.println("談價格");
    }

    @After("lService()")
    public void after() {
        System.out.println("交鑰匙");
    }
}

第四步：測試 AOP

編寫測試代碼，可是我這裏由於 JDK 版本不兼容出現了 BUG....（尷尬...）

這就告訴咱們：環境配置很重要...否則莫名其妙的 BUG 讓你崩潰...

環繞通知

咱們來探討一下環繞通知，這是 Spring AOP 中最強大的通知，由於它集成了前置通知和後置通知，它保留了鏈接點原有的方法的功能，因此它及強大又靈活，讓咱們來看看：

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Component
@Aspect
class Broker {

//  註釋掉以前的 @Before 和 @After 註解以及對應的方法
//  @Before("execution(* pojo.Landlord.service())")
//  public void before() {
//      System.out.println("帶租客看房");
//      System.out.println("談價格");
//  }
//
//  @After("execution(* pojo.Landlord.service())")
//  public void after() {
//      System.out.println("交鑰匙");
//  }

    //  使用 @Around 註解來同時完成前置和後置通知
    @Around("execution(* pojo.Landlord.service())")
    public void around(ProceedingJoinPoint joinPoint) {
        System.out.println("帶租客看房");
        System.out.println("談價格");

        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        System.out.println("交鑰匙");
    }
}

運行測試代碼，結果仍然正確：

使用 XML 配置開發 Spring AOP

註解是很強大的東西，但基於 XML 的開發咱們仍然須要瞭解，咱們先來了解一下 AOP 中能夠配置的元素：

AOP 配置元素 用途 備註
aop:advisor 定義 AOP 的通知其 一種很古老的方式，不多使用
aop:aspect 定義一個切面 ——
aop:before 定義前置通知 ——
aop:after 定義後置通知 ——
aop:around 定義環繞通知 ——
aop:after-returning 定義返回通知 ——
aop:after-throwing 定義異常通知 ——
aop:config 頂層的 AOP 配置元素 AOP 的配置是以它爲開始的
aop:declare-parents 給通知引入新的額外接口，加強功能 ——
aop:pointcut 定義切點 ——

有了以前經過註解來編寫的經驗，而且有了上面的表，咱們將上面的例子改寫成 XML 配置很容易（去掉全部的註解）：

<!-- 裝配 Bean-->
<bean name="landlord" class="pojo.Landlord"/>
<bean id="broker" class="aspect.Broker"/>

<!-- 配置AOP -->
<aop:config>
    <!-- where：在哪些地方（包.類.方法）作增長 -->
    <aop:pointcut id="landlordPoint"
                  expression="execution(* pojo.Landlord.service())"/>
    <!-- what:作什麼加強 -->
    <aop:aspect id="logAspect" ref="broker">
        <!-- when:在什麼時機（方法前/後/先後） -->
        <aop:around pointcut-ref="landlordPoint" method="around"/>
    </aop:aspect>
</aop:config>

運行測試程序，看到正確結果：

擴展閱讀：Spring【AOP模塊】就這麼簡單 、 關於 Spring AOP(AspectJ)你該知曉的一切（慎獨讀，有些深度...）

參考資料：

  • 《Java EE 互聯網輕量級框架整合開發》
  • 《Java 實戰（第四版）》
  • 萬能的百度 and 萬能的大腦

歡迎轉載，轉載請註明出處！
簡書ID：@我沒有三顆心臟
github：wmyskxz 歡迎關注公衆微信號：wmyskxz_javaweb 分享本身的Java Web學習之路以及各類Java學習資料

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程