Spring學習筆記 - 第三章 - AOP與Spring事務

Dandelion_000發表於2022-12-28

原文地址:Spring學習筆記 - 第三章 - AOP與Spring事務

Spring 學習筆記全系列傳送門:

目錄


1、AOP 簡介

AOP是在不改原有程式碼的前提下對其進行增強

1.1 什麼是 AOP

  • AOP(Aspect Oriented Programming)面向切面程式設計,一種程式設計正規化,指導開發者如何組織程式結構。

    根據 Java 學習路線的內容,要區別於 OOP(Object Oriented Programming)物件導向程式設計,它們兩個是不同的程式設計正規化

1.2 AOP 的作用

  • 在不驚動原始設計的基礎上為其進行功能增強(無侵入式程式設計 / 無入侵式程式設計)

    前面的內容中有技術就可以實現這樣的功能,如代理模式

1.3 AOP 核心概念

AOP的核心概念包含:連線點、切入點、通知、通知類、切面

  • 案例:測試程式碼的執行效率(執行案例,呼叫不同方法,觀察輸出結果)

    • 依賴

      <dependencies>
              <dependency>
                  <groupId>org.springframework</groupId>
                  <artifactId>spring-context</artifactId>
                  <version>5.2.10.RELEASE</version>
                  <scope>compile</scope>
              </dependency>
              <dependency>
                  <groupId>org.aspectj</groupId>
                  <artifactId>aspectjweaver</artifactId>
                  <version>1.9.4</version>
              </dependency>
          </dependencies>
      
    • Dao 實現類(介面不表)

      @Repository
      public class BookDaoImpl implements BookDao {
          public void save() {
              //記錄程式當前執行執行(開始時間)
              Long startTime = System.currentTimeMillis();
              //業務執行萬次
              for (int i = 0;i<10000;i++) {
                  System.out.println("book dao save ...");
              }
              //記錄程式當前執行時間(結束時間)
              Long endTime = System.currentTimeMillis();
              //計算時間差
              Long totalTime = endTime-startTime;
              //輸出資訊
              System.out.println("執行萬次消耗時間:" + totalTime + "ms");
          }
          public void update(){
              System.out.println("book dao update ...");
          }
          public void delete(){
              System.out.println("book dao delete ...");
          }
          public void select(){
              System.out.println("book dao select ...");
          }
      }
      
    • Spring 配置類

      @Configuration
      @ComponentScan("priv.dandelion")
      @EnableAspectJAutoProxy
      public class SpringConfig {
      }
      
    • aop

      package priv.dandelion.aop;
      
      import org.aspectj.lang.ProceedingJoinPoint;
      import org.aspectj.lang.annotation.Around;
      import org.aspectj.lang.annotation.Aspect;
      import org.aspectj.lang.annotation.Pointcut;
      import org.springframework.stereotype.Component;
      
      @Component
      @Aspect
      public class MyAdvice {
          @Pointcut("execution(void priv.dandelion.dao.BookDao.*te())")
          private void pt() {
          }
      
          @Around("pt()")
          public void around(ProceedingJoinPoint pjp) throws Throwable {
              //記錄程式當前執行執行(開始時間)
              Long startTime = System.currentTimeMillis();
              //業務執行萬次
              for (int i = 0;i<10000;i++) {
                  // 表示對原始操作的呼叫
                  pjp.proceed();
              }
              //記錄程式當前執行時間(結束時間)
              Long endTime = System.currentTimeMillis();
              //計算時間差
              Long totalTime = endTime-startTime;
              //輸出資訊
              System.out.println("執行萬次消耗時間:" + totalTime + "ms");
      
          }
      }
      
    • 執行類

      public class App {
          public static void main(String[] args) {
              ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
              BookDao bookDao = ctx.getBean(BookDao.class);
              bookDao.save();
              // bookDao.update();
              // bookDao.delete();
              // bookDao.select();
          }
      }
      
  • AOP 核心概念圖示與解釋

    • 圖示

      AOP核心概念圖示

    • 概念

      • 連線點:在 AOP 中,將所以原始方法稱為連線點(如右側的 save,update,deleteselect 方法)。
      • 切入點:在上述四個方法中,除 save 方法之外,僅 updatedelete 方法執行了萬次,即追加了功能。這些追加了同一種功能的方法(可以是一個也可以是多個,此處為兩個)稱為一個切入點,反之,如 save, select 方法就不是切入點。
      • 通知:共性功能,即左邊的方法。
      • 通知類:通知是一個方法,必須寫在一個類中。
      • 切面:通知與切入點的關係,一個通知對應一個切入點,稱為一個切面。
  • AOP 核心概念總結

    • 連線點(JoinPoint):程式執行過程中的任意位置,粒度為執行方法、丟擲異常、設定變數等

      在SpringAOP中,理解為方法的執行

    • 切入點(Pointcut):匹配連線點的式子

      • 在SpringAOP中,一個切入點可以描述一個具體方法,也可也匹配多個方法,如以下描述:
        • 一個具體的方法:如priv.dandelion.dao包下的BookDao介面中的無形參無返回值的save方法
        • 匹配多個方法:所有的save方法,所有的get開頭的方法,所有以Dao結尾的介面中的任意方法,所有帶有一個引數的方法
      • 連線點範圍要比切入點範圍大,是切入點的方法也一定是連線點,但是是連線點的方法就不一定要被增強,所以可能不是切入點。
    • 通知(Advice):在切入點處執行的操作,也就是共性功能

      在SpringAOP中,功能最終以方法的形式呈現

    • 通知類:定義通知的類

    • 切面(Aspect):描述通知與切入點的對應關係

2、AOP 入門案例

2.1 需求分析

在方法執行前輸出當前系統時間。(使用 AOP )

2.2 思路分析

  1. 匯入座標(pom.xml)
  2. 製作連線點(原始操作,Dao介面與實現類)
  3. 製作共性功能(通知類與通知)
  4. 定義切入點
  5. 繫結切入點與通知關係(切面)

2.3 環境準備

環境搭建完成後:

  • 列印save方法的時候,因為方法中有列印系統時間,所以執行的時候是可以看到系統時間
  • 對於update方法來說,就沒有該功能
  • 依賴

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    </dependencies>
    
  • Dao 實現類 (介面細節不表)

    public interface BookDao {
        public void save();
        public void update();
    }
    
    @Repository
    public class BookDaoImpl implements BookDao {
    
        public void save() {
            System.out.println(System.currentTimeMillis());
            System.out.println("book dao save ...");
        }
    
        public void update(){
            System.out.println("book dao update ...");
        }
    }
    
  • Spring 配置類

    @Configuration
    @ComponentScan("priv.dandelion")
    public class SpringConfig {
    }
    
  • 執行類

    public class App {
        public static void main(String[] args) {
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao = ctx.getBean(BookDao.class);
            bookDao.save();
        }
    }
    

2.4 AOP 實現步驟

  1. 新增依賴

    • AspectJ 是 AOP 思想的一個具體實現

    • Spring 有自己的 AOP 實現,但是相比於 AspectJ 來說比較麻煩,所以我們直接採用Spring 整合 ApsectJ 的方式進行 AOP 開發

    <!-- 因為spring-context依賴aop,aop的包已經匯入 -->
    <!-- 此處我們額外匯入aspectjweaver包 -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
    
  2. 定義介面與實現類

    環境準備已經完成

  3. 定義通知類和通知

    package priv.dandelion.aop;
    
    public class MyAdvice {
        public void method(){
            // 獲取系統時間
            System.out.println(System.currentTimeMillis());
        }
    }
    
  4. 定義切入點

    • 切入點定義依託一個不具有實際意義的方法進行,即無引數、無返回值、方法體無實際邏輯
    • execution及後面編寫的內容,將在後續的章節中詳細介紹
    public class MyAdvice {
    
        // 定義切入點,註解中execution後面的內容即為對切入點的描述(即當執行到這個方法的時候)
        @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
        private void pt(){}
    
        public void method(){
            System.out.println(System.currentTimeMillis());
        }
    }
    
  5. 製作切面

    繫結切入點與通知關係

    public class MyAdvice {
    
        @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
        private void pt(){}
    
        // 定義執行時間(在執行到哪一個切入點的什麼時間執行,如此處使用Before就是在執行pt()切入點前執行)
        @Before("pt()")
        public void method(){
            System.out.println(System.currentTimeMillis());
        }
    }
    
  6. 將通知類配給容器並標識其為切面類

    // 告訴Spring,這是一個Bean,需要被管理
    @Component
    // 告訴Spring,掃描到該Bean時,當作AOP處理
    @Aspect
    public class MyAdvice {
    
        @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
        private void pt(){}
    
        @Before("pt()")
        public void method(){
            System.out.println(System.currentTimeMillis());
        }
    }
    
  7. 開啟註解格式 AOP 功能

    @Configuration
    @ComponentScan("priv.dandelion")
    // 告訴Spring,包含註解開發的AOP,即啟動了@Aspect註解
    @EnableAspectJAutoProxy
    public class SpringConfig {
    }
    

2.5 相關知識點

  • @EnableAspectJAutoProxy

    名稱 @EnableAspectJAutoProxy
    型別 配置類註解
    位置 配置類定義上方
    作用 開啟註解格式AOP功能
  • @Aspect

    名稱 @Aspect
    型別 類註解
    位置 切面類定義上方
    作用 設定當前類為AOP切面類(需要已經有@EnableAspectJAutoProxy)
  • @Pointcut

    名稱 @Pointcut
    型別 方法註解
    位置 切入點方法定義上方
    作用 設定切入點方法
    屬性 value(預設):切入點表示式
  • @Before

    名稱 @Before
    型別 方法註解
    位置 通知方法定義上方
    作用 設定當前通知方法與切入點之間的繫結關係,當前通知方法在原始切入點方法前執行

3、AOP 工作流程與核心概念

SpringAOP的本質:代理模式

3.1 AOP 工作流程

AOP 是基於 Spring 容器管理的 bean 做的增強,所以整個工作過程需要從 Spring 載入 bean 說起

  • 執行流程分解

    1. Spring 容器啟動

    2. 讀取所有切面配置中的切入點(僅包含已經被使用到了的切入點,具體案例如下)

      @Component
      @Aspect
      public class MyAdvice {
      
          // ptx()未被使用到,不會被讀取
          @Pointcut("execution(void priv.dandelion.dao.BookDao.save())")
          private void ptx(){}
          
          // pt()被使用到,會被讀取
          @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
          private void pt(){}
          
      	// 僅使用了pt()
          @Before("pt()")
          public void method(){
              System.out.println(System.currentTimeMillis());
          }
      }
      
    3. 初始化 bean,判定 bean 對應類中的方法是否匹配到任意切入點

      • 匹配失敗時,初始化bean
      • 匹配成功時,建立原始物件【即目標物件】的代理物件
    4. 獲取 bean 的執行方法

      • 獲取 bean 呼叫方法並執行,完成操作
      • 獲取的 bean 是代理物件時,根據代理物件的執行模式執行原始方法與增強內容,完成操作
  • 實驗:驗證容器中是否為代理物件

    1. 修改 App 類,獲取類的型別

      • 不能直接列印物件,直接列印物件走的是物件的toString方法,不管是不是代理物件列印的結果都是一樣的,原因是內部對toString方法進行了重寫
      • 此處使用getClass()方法
      public class App {
          public static void main(String[] args) {
              ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
              BookDao bookDao = ctx.getBean(BookDao.class);
              
              System.out.println(bookDao.getClass());
          }
      }
      
    2. 修改 MyAdvice 類,不增強

      @Component
      @Aspect
      public class MyAdvice {
      
          // Dao中無該方法,bean中的方法匹配不到當前切入點
          @Pointcut("execution(void priv.dandelion.dao.BookDao.update1())")
          private void pt(){}
      
          @Before("pt()")
          public void method(){
              System.out.println(System.currentTimeMillis());
          }
          /**
           * 控制檯輸出為原始物件:
           * class priv.dandelion.dao.impl.BookDaoImpl
           */
      }
      
    3. 修改 MyAdvice 類,增強

      @Component
      @Aspect
      public class MyAdvice {
      
          @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
          private void pt(){}
      
          @Before("pt()")
          public void method(){
              System.out.println(System.currentTimeMillis());
          }
          /**
           * 控制檯輸出為代理物件:
           * class com.sun.proxy.$Proxy19class com.sun.proxy.$Proxy19
           */
      }
      

3.2 AOP 核心概念

  • 目標物件(Target):原始功能去掉共性功能對應的類產生的物件,這種物件是無法直接完成最終工作的

    簡單來說,目標物件就是要增強的類 [如:BookServiceImpl 類] 對應的物件,也叫原始物件,不能說它不能執行,只能說它在執行的過程中對於要增強的內容是缺失的。

  • 代理(Proxy):目標物件無法直接完成工作,需要對其進行功能回填,透過原始物件的代理物件實現

    SpringAOP是在不改變原有設計 (程式碼) 的前提下對其進行增強的,它的底層採用的是代理模式實現的,所以要對原始物件進行增強,就需要對原始物件建立代理物件,在代理物件中的方法把通知 [如:MyAdvice 中的 method 方法] 內容加進去,就實現了增強,這就是我們所說的代理 (Proxy)

4、AOP 配置管理

4.1 AOP 切入點表示式

  • 切入點表示式在上面的章節出現過,即@Pointcut中的內容

    @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
    private void pt(){}
    
  • 對於AOP中的切入點表示式,本文將詳細說明三個內容,分別是語法格式、萬用字元和書寫技巧

4.1.1 語法格式

  • 概念明確:

    • 切入點:要進行增強的方法
    • 切入點表示式:要進行增強的方法的描述方式
  • 描述方式

    因為呼叫介面方法的時候最終執行的還是其實現類的方法,所以下面兩種描述方式都是可以的。

    • 執行介面中的方法(按介面描述)

      execution(void priv.dandelion.dao.BookDao.update())
      
    • 執行實現類中的方法(按實現類描述)

      execution(void priv.dandelion.dao.impl.BookDaoImpl.update())
      
  • 切入點表示式的語法

    • 標準格式

      動作關鍵字(訪問修飾符 返回值 包名.類/介面名.方法名(引數) 異常名)

    • 示例及說明

      解釋下方的程式碼段:

      • execution:動作關鍵字,描述切入點的行為動作,例如 execution 表示執行到指定切入點
      • public:訪問修飾符,還可以是 public,private 等(可以省略,預設 public)
      • User:返回值,寫返回值型別
      • priv.dandelion.service:包名,多級包使用點連線
      • UserService:類/介面名稱
      • findById:方法名
      • int:引數,直接寫引數的型別,多個型別用逗號隔開
      • 異常名:方法定義中丟擲指定異常(可以省略)
      execution(public User priv.dandelion.service.UserService.findById(int))
      

4.1.2 萬用字元

  • 萬用字元詳解

    • *:單個獨立的任意符號,可以獨立出現,也可以作為字首或者字尾

      匹配 priv.dandelion 包下的任意包中的 UserService 類或介面中所有 find 開頭的帶有一個引數的方法

      execution(public * priv.dandelion.*.UserService.find*(*))
      
    • ..:多個連續的任意符號,可以獨立出現,常用於簡化包名與引數的書寫

      匹配 priv 包下的任意包中的 UserService 類或介面中所有名稱為 findById 的方法

      execution(public User priv..UserService.findById(..))
      
    • +:用於匹配子類型別

      這個使用率較低,描述子類的,做JavaEE開發,繼承機會就一次,使用都很慎重,所以很少用它。*Service+,表示所有以Service結尾的介面的子類。

      execution(* *..*Service+.*(..))
      
  • 示例

    以案例中使用到的切入點為例

    @Repository
    public class BookDaoImpl implements BookDao {
    
        public void save() {
            System.out.println(System.currentTimeMillis());
            System.out.println("book dao save ...");
        }
    
        public void update(){
            System.out.println("book dao update ...");
        }
    }
    
    // 匹配介面,能匹配到
    execution(void priv.dandelion.dao.BookDao.update())
    // 匹配實現類,能匹配到
    execution(void priv.dandelion.dao.impl.BookDaoImpl.update())
    // 返回值任意,能匹配到
    execution(* priv.dandelion.dao.impl.BookDaoImpl.update())
    // 返回值任意,但是update方法必須要有一個引數,無法匹配,要想匹配需要在update介面和實現類新增引數
    execution(* priv.dandelion.dao.impl.BookDaoImpl.update(*))
    // 返回值為void,priv包下的任意包三層包下的任意類的update方法,匹配到的是實現類,能匹配
    execution(void priv.*.*.*.*.update())
    // 返回值為void,priv包下的任意兩層包下的任意類的update方法,匹配到的是介面,能匹配
    execution(void priv.*.*.*.update())
    // 返回值為void,方法名是update的任意包下的任意類,能匹配
    execution(void *..update())
    // 匹配專案中任意類的任意方法,能匹配,但是不建議使用這種方式,影響範圍廣
    execution(* *..*(..))
    // 匹配專案中任意包任意類下只要以u開頭的方法,update方法能滿足,能匹配
    execution(* *..u*(..))
    // 匹配專案中任意包任意類下只要以e結尾的方法,update和save方法能滿足,能匹配
    execution(* *..*e(..))
    // 返回值為void,priv包下的任意包任意類任意方法,能匹配,*代表的是方法
    execution(void priv..*())
    // 將專案中所有業務層方法的以find開頭的方法匹配
    execution(* priv.dandelion.*.*Service.find*(..))
    // 將專案中所有業務層方法的以save開頭的方法匹配
    execution(* priv.dandelion.*.*Service.save*(..))
    

4.1.3 書寫技巧

  • 所有程式碼按照標準規範開發,否則以下技巧全部失效
  • 描述切入點通常描述介面,而不描述實現類,如果描述到實現類,就出現緊耦合了
  • 訪問控制修飾符針對介面開發均採用 public 描述(可省略訪問控制修飾符描述
  • 返回值型別對於增刪改類使用精準型別加速匹配,對於查詢類使用*通配快速描述
  • 包名書寫儘量不使用..匹配,效率過低,常用*做單個包描述匹配,或精準匹配
  • 介面名/類名書寫名稱與模組相關的採用*匹配,例如 UserService 書寫成 *Service ,繫結業務層介面名
  • 方法名書寫以動詞進行精準匹配,名詞采用*匹配,例如 getById 書寫成 getBy*,selectAll 就書寫成 selectAll 即可
  • 引數規則較為複雜,根據業務方法靈活調整
  • 通常不使用異常作為匹配規則

4.2 AOP 通知型別

前面的案例中,涉及到如下內容:

@Before("pt()")

其代表的含義是將通知新增到切入點方法執行的前面

4.2.1 型別介紹

  • 關於 AOP 通知的回顧

    AOP 通知描述了抽取的共性功能,根據共性功能抽取的位置不同,最終執行程式碼時要將其加入到合理的位置

  • 通知型別(共5種)

    • 前置通知
    • 後置通知
    • 環繞通知(重要)
    • 返回後通知(不常用)
    • 丟擲異常後通知(不常用)
  • AOP 程式碼加入位置演示

    // 環繞通知功能比較強大,它可以追加功能到方法執行的前後,是比較常用的方式,它可以實現其他四種通知型別的功能,具體的實現方式將在下面進行說明
    public int methodName() {
        // 前置通知追加位置1,即方法執行前
        try {
            // 前置通知追加位置2,即方法執行前
            
            // code,原始的業務操作,即要被增強的方法本體
            return;
            
            // 返回後通知追加位置,即方法執行後(只有方法正常執行結束後才進行,如果方法執行丟擲異常,返回後通知將不會被新增)
        } catch (Exception e) {
            // 丟擲異常後通知追加位置,即丟擲異常後(只有方法丟擲異常後才會被新增)
        }
        // 後置通知追加位置,在方法執行後(不管方法執行的過程中有沒有丟擲異常都會執行) 
    }
    

4.2.2 環境準備

  • 新增依賴

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>
    
  • 新增 Dao 層介面和實現類(介面不表)

    @Repository
    public class BookDaoImpl implements BookDao {
        @Override
        public void update() {
            System.out.println("book dao update ...");
        }
    
        @Override
        public int select() {
            System.out.println("book dao select is running ...");
            return 100;
        }
    }
    
  • 建立 Spring 的配置類

    @Configuration
    @ComponentScan("priv.dandelion")
    @EnableAspectJAutoProxy
    public class SpringConfig {
    }
    
  • 建立通知類

    @Component
    @Aspect
    public class MyAdvice {
        @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
        private void pt(){}
    
        public void before() {
            System.out.println("before advice ...");
        }
    
        public void after() {
            System.out.println("after advice ...");
        }
    
        public void around(){
            System.out.println("around before advice ...");
            System.out.println("around after advice ...");
        }
    
        public void afterReturning() {
            System.out.println("afterReturning advice ...");
        }
    
        public void afterThrowing() {
            System.out.println("afterThrowing advice ...");
        }
    }
    
  • 編寫 App 執行類

    public class App {
        public static void main(String[] args) {
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao = ctx.getBean(BookDao.class);
            bookDao.update();
        }
    }
    

4.2.3 通知型別的使用

4.2.3.1 通知型別
  • 前置通知

    @Before("pt()")
    public void before() {
        System.out.println("before advice ...");
    }
    
  • 後置通知

    @After("pt()")
    public void after() {
        System.out.println("after advice ...");
    }
    
  • 環繞通知

    • 基本使用

      @Pointcut("execution(void priv.dandelion.dao.BookDao.update())")
      private void pt() {
      }
      
      @Pointcut("execution(int priv.dandelion.dao.BookDao.select())")
      private void pt2() {
      }
      
      // 環繞通知方法需要有一個ProceedingJoinPoint型別的引數,用於呼叫原始物件
      @Around("pt()")
      public void around(ProceedingJoinPoint pjp) throws Throwable {
          System.out.println("around before advice ...");
      
          // 表示對原始操作的呼叫,環繞通知必須手動呼叫原始方法
          pjp.proceed();
      
          System.out.println("around after advice ...");
      }
      
      // 有返回值的方法在增強時,環繞通知方法必須要有Object的返回值
      @Around("pt2()")
      public Object around2(ProceedingJoinPoint pjp) throws Throwable {
          System.out.println("around before advice ...");
      
          // 表示對原始操作的呼叫,並接收返回值
          Object proceed = pjp.proceed();
      
          System.out.println("around after advice ...");
      
          return proceed;
      }
      
    • 注意事項

      • 環繞通知方法需要有一個 ProceedingJoinPoint 型別的引數,用於呼叫原始物件,其中,可以使用pjp.proceed()來呼叫原始方法。
      • 環繞通知不手動呼叫原始方法時,會自動跳過原始方法(利用這一特性可完成許可權校驗與內容分配等功能)
      • 由於無法預知原始方法執行後是否會丟擲異常,因此環繞通知方法必須要處理 Throwable 異常
      • 有返回值的方法在增強時,環繞通知方法必須要有 Object 的返回值
      • 無返回值的原始方法對應的通知類一般返回 void,但也可以寫返回值,正常獲取並返回後得到的結果為null,通常會返回 Object
  • 返回後通知

    若原始方法在執行過程中發生異常,則該通知不會被執行

    @AfterReturning("pt2()")
    public void afterReturning() {
        System.out.println("afterReturning advice ...");
    }
    
  • 異常後通知

    僅在原始方法發生異常會被執行

    @AfterThrowing("pt2()")
    public void afterThrowing() {
        System.out.println("afterThrowing advice ...");
    }
    
4.2.3.2 通知型別相關知識點總結
  • @After

    名稱 @After
    型別 方法註解
    位置 通知方法定義上方
    作用 設定當前通知方法與切入點之間的繫結關係,當前通知方法在原始切入點方法後執行
  • @AfterReturning

    名稱 @AfterReturning
    型別 方法註解
    位置 通知方法定義上方
    作用 設定當前通知方法與切入點之間繫結關係,當前通知方法在原始切入點方法正常執行完畢後執行
  • @AfterThrowing

    名稱 @AfterThrowing
    型別 方法註解
    位置 通知方法定義上方
    作用 設定當前通知方法與切入點之間繫結關係,當前通知方法在原始切入點方法執行丟擲異常後執行名稱
  • @Around

    名稱 @Around
    型別 方法註解
    位置 通知方法定義上方
    作用 設定當前通知方法與切入點之間的繫結關係,當前通知方法在原始切入點方法前後執行
  • 環繞通知注意事項

    • 環繞通知方法需要有一個 ProceedingJoinPoint 型別的引數,用於呼叫原始物件,其中,可以使用pjp.proceed()來呼叫原始方法。
    • 環繞通知不手動呼叫原始方法時,會自動跳過原始方法(利用這一特性可完成許可權校驗與內容分配等功能)
    • 由於無法預知原始方法執行後是否會丟擲異常,因此環繞通知方法必須要處理 Throwable 異常
    • 有返回值的方法在增強時,環繞通知方法必須要有 Object 的返回值
    • 無返回值的原始方法對應的通知類可以返回 void,但也可以寫返回值,正常獲取並返回後得到的結果為null,通常會返回 Object

4.3 案例:測試業務層介面萬次執行效率

4.3.1 需求分析

  • 測試萬次執行時間則需要知道程式執行前後的時間

    • 因此此處應使用環繞通知,以便於原始方法執行前後都可以進行增強
  • 環繞通知需要包含返回值,因為原始方法需要返回值

4.3.2 環境準備

  • 依賴

  • 實體類

    public class Account implements Serializable {
    
        private Integer id;
        private String name;
        private Double money;
    
        // setter, getter, toString
    }
    
  • Dao介面

    public interface AccountDao {
    
        @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
        void save(Account account);
    
        @Delete("delete from tbl_account where id = #{id} ")
        void delete(Integer id);
    
        @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
        void update(Account account);
    
        @Select("select * from tbl_account")
        List<Account> findAll();
    
        @Select("select * from tbl_account where id = #{id} ")
        Account findById(Integer id);
    }
    
  • Service實現類(介面不表)

    @Service
    public class AccountServiceImpl implements AccountService {
    
        @Autowired
        private AccountDao accountDao;
    
        public void save(Account account) {
            accountDao.save(account);
        }
    
        public void update(Account account){
            accountDao.update(account);
        }
    
        public void delete(Integer id) {
            accountDao.delete(id);
        }
    
        public Account findById(Integer id) {
            return accountDao.findById(id);
        }
    
        public List<Account> findAll() {
            return accountDao.findAll();
        }
    }
    
  • properties 配置檔案

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
    jdbc.username=root
    jdbc.password=123456
    
  • 基礎配置類

    @Configuration
    @ComponentScan("priv.dandelion")
    @PropertySource("classpath:jdbc.properties")
    @Import({JdbcConfig.class,MybatisConfig.class})
    public class SpringConfig {
    }
    
  • JDBC配置類

    public class JdbcConfig {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String userName;
        @Value("${jdbc.password}")
        private String password;
    
        @Bean
        public DataSource dataSource(){
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(userName);
            ds.setPassword(password);
            return ds;
        }
    }
    
  • Mybatis配置類

    public class MybatisConfig {
    
        @Bean
        public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
            SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
            ssfb.setTypeAliasesPackage("priv.dandelion.entity");
            ssfb.setDataSource(dataSource);
            return ssfb;
        }
    
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer(){
            MapperScannerConfigurer msc = new MapperScannerConfigurer();
            msc.setBasePackage("priv.dandelion.dao");
            return msc;
        }
    }
    

4.3.3 功能開發

  • 開啟 SpringAOP 的註解功能

    在 Spring 的主配置檔案 SpringConfig 類中新增註解

    @EnableAspectJAutoProxy
    
  • 建立通知類並編寫通知

    • 該類要被Spring管理,需要新增@Component

    • 要標識該類是一個AOP的切面類,需要新增@Aspect

    • 配置切入點表示式,需要新增一個方法,並新增@Pointcut

    • 在runSpeed()方法上新增@Around

    @Component
    @Aspect
    public class ProjectAdvice {
    
        // 匹配業務層所有方法
        @Pointcut("execution(* priv.dandelion.service.*Service.*(..))")
        private void servicePt(){}
    
        @Around("servicePt()")
        public Object runSpeed(ProceedingJoinPoint pjp) throws Throwable {
            Signature signature = pjp.getSignature();
            String className = signature.getDeclaringTypeName();
            String methodName = signature.getName();
    
            long start = System.currentTimeMillis();
            Object proceed = null;
            for (int i = 0; i < 10000; i++) {
                proceed = pjp.proceed();
            }
            long end = System.currentTimeMillis();
    
            System.out.println("萬次執行:" + className + "." + methodName + "----->" + (end - start) + "ms");
            return proceed;
        }
    }
    
  • 測試

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = SpringConfig.class)
    public class AccountServiceTestCase {
        @Autowired
        private AccountService accountService;
    
        @Test
        public void testFindById(){
            Account ac = accountService.findById(2);
            System.out.println(ac);
        }
    
        @Test
        public void testFindAll(){
            List<Account> all = accountService.findAll();
            System.out.println(all);
        }
    }
    

4.4 AOP 通知獲取資料

  • 獲取引數(所有的通知型別都可以獲取引數)
    • JoinPoint:適用於前置、後置、返回後、丟擲異常後通知
    • ProceedingJoinPoint:適用於環繞通知
  • 獲取返回值(前置和丟擲異常後通知沒有返回值,後置通知可有可無,所以不做研究)
    • 返回後通知
    • 環繞通知
  • 獲取異常資訊(獲取切入點方法執行異常資訊,前置和返回後通知不會有,後置通知可有可無,所以不做研究)
    • 丟擲異常後通知
    • 環繞通知

4.4.1 環境準備

  • 依賴

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>
    
  • Dao

    @Repository
    public class BookDaoImpl implements BookDao {
    
        public String findName(int id) {
            System.out.println("id:"+id);
            return "dandelion";
        }
    }
    
  • 配置類

    @Configuration
    @ComponentScan("priv.dandelion")
    @EnableAspectJAutoProxy
    public class SpringConfig {
    }
    
  • 通知類

    @Component
    @Aspect
    public class MyAdvice {
        @Pointcut("execution(* priv.dandelion.dao.BookDao.findName(..))")
        private void pt(){}
    
        @Before("pt()")
        public void before() {
            System.out.println("before advice ..." );
        }
    
        @After("pt()")
        public void after() {
            System.out.println("after advice ...");
        }
    
        @Around("pt()")
        public Object around(ProceedingJoinPoint pjp) throws Throwable{
            Object ret = pjp.proceed();
            return ret;
        }
        @AfterReturning("pt()")
        public void afterReturning() {
            System.out.println("afterReturning advice ...");
        }
    
    
        @AfterThrowing("pt()")
        public void afterThrowing() {
            System.out.println("afterThrowing advice ...");
        }
    }
    
  • 執行類

    public class App {
        public static void main(String[] args) {
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao = ctx.getBean(BookDao.class);
            String name = bookDao.findName(100);
            System.out.println(name);
        }
    }
    

4.4.2 獲取引數

4.4.2.1 非環繞通知獲取方式
@Before("pt()")
public void before(JoinPoint jp) {
    Object[] args = jp.getArgs();
    System.out.println(Arrays.toString(args));
    System.out.println("before advice ..." );
}

@After("pt()")
public void after() {
    Object[] args = jp.getArgs();
    System.out.println(Arrays.toString(args));
    System.out.println("after advice ...");
}
4.4.2.2 環繞通知獲取方式
  • 基本的獲取引數

    ProceedingJoinPoint 繼承自 JoinPoint,可直接獲取引數

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        Object ret = pjp.proceed();
        return ret;
    }
    
  • 引數的修正

    ProceedingJoinPoint 的 proceed() 方法用於呼叫原始方法,但是該方法除了空參的形式還包括有參形式 proceed(Object[] args),二者本質區別不大,後者用於手動傳入引數

    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        // 假設原始方法被呼叫時傳入的引數有問題,此處進行處理
        args[0] = 666;
        // 手動傳入引數,執行原始方法時將使用被手動傳入的引數
        Object ret = pjp.proceed(args);
        return ret;
    }
    

4.4.3 獲取返回值

只有返回後AfterReturing和環繞Around這兩個通知型別可以獲取返回值

4.4.3.1 環繞通知獲取返回值

環繞通知獲取返回值時,在呼叫原始方法時接收返回值,並且為通知方法定義返回值型別 Object,如果有需要可以進行修改

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
    Object[] args = pjp.getArgs();
    System.out.println(Arrays.toString(args));
    // 假設原始方法被呼叫時傳入的引數有問題,此處進行處理
    args[0] = 666;
    // 手動傳入引數,執行原始方法時將使用被手動傳入的引數
    Object ret = pjp.proceed(args);
    return ret;
}
4.4.3.2 非環繞通知獲取返回值
  • 僅獲取返回值

    非環繞通知獲取返回值時

    • 需要設定引數用於接收返回值
    • 需要在對應的通知註解中註明用於接收返回值的形參名稱
    @AfterReturning(value = "pt()", returning = "ret")
    public void afterReturning(Object ret) {
        System.out.println("afterReturning advice ..." + ret);
    }
    
  • 獲取引數的同時獲取返回值

    同時獲取時需要注意

    • 用於獲取引數列表的 JoinPoint 型別的形參必須放在第一位,否則會報錯
    @AfterReturning(value = "pt()", returning = "ret")
    public void afterReturning(JoinPoint jp, Object ret) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("afterReturning advice ..." + ret);
    }
    

4.4.4 獲取異常

  • 對於獲取丟擲的異常,只有丟擲異常後AfterThrowing和環繞Around這兩個通知型別可以獲取

  • 假設 Dao 層程式碼中存在異常

    @Repository
    public class BookDaoImpl implements BookDao {
    
        public String findName(int id, String password) {
            System.out.println("id:"+id);
            if(true){
                throw new NullPointerException();
            }
            return "dandelion";
        }
    }
    
4.4.4.1 環繞通知獲取異常
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
    Object[] args = pjp.getArgs();
    System.out.println(Arrays.toString(args));
    // 假設原始方法被呼叫時傳入的引數有問題,此處進行處理
    args[0] = 666;

    Object ret = null;
    try {
        // 手動傳入引數,執行原始方法時將使用被手動傳入的引數
        ret = pjp.proceed(args);
    } catch (Throwable t) {
        // 捕獲異常
        t.printStackTrace();
    }
    return ret;
}
4.4.4.2 丟擲異常後通知獲取異常
@AfterThrowing(value = "pt()", throwing = "t")
public void afterThrowing(Throwable t) {
    System.out.println("afterThrowing advice ..." + t);
}

4.5 百度網盤密碼資料相容處理

4.5.1 需求分析

百度網盤選取分享密碼時會多帶一個空格,影響正常使用

  • 在業務方法執行之前對所有的輸入引數使用trim()進行格式處理
  • 後續類似的操作可能很多,故此處採用 AOP 進行統一處理
  • 需要先處理引數再呼叫原始方法,故此處採用環繞通知

4.5.2 環境準備

  • 依賴

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>
    
  • Dao(介面不表)

    @Repository
    public class ResourcesDaoImpl implements ResourcesDao {
        @Override
        public boolean readResources(String url, String password) {
            //模擬校驗
            return password.equals("root");
        }
    }
    
  • Service(介面不表)

    @Service
    public class ResourcesServiceImpl implements ResourcesService {
        @Autowired
        private ResourcesDao resourcesDao;
    
        public boolean openURL(String url, String password) {
            return resourcesDao.readResources(url,password);
        }
    }
    
  • Spring 配置類

    @Configuration
    @ComponentScan("priv.dandelion")
    public class SpringConfig {
    }
    
  • 執行類

    public class App {
        public static void main(String[] args) {
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
            boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root");
            System.out.println(flag);
        }
    }
    

4.5.3 具體實現

  1. 開啟 SpringAOP 的註解功能

    @EnableAspectJAutoProxy
    
  2. 編寫通知類

    @Component
    @Aspect
    public class DataAdvice {
    }
    
  3. 定義切入點

    // 定義切入點,假設對業務層任意包含字串的引數都進行處理
    @Pointcut("execution(boolean priv.dandelion.service.*Service.*(..))")
    private void servicePt(){}
    
  4. 新增環繞通知

    @Around("servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        // 獲取引數,若引數為字串型別,則去除空格
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            if (args[i].getClass().equals(String.class))
                args[i] = args[i].toString().trim();
        }
        // 呼叫原始方法,手動傳入修改後的引數
        Object proceed = pjp.proceed(args);
    
        return proceed;
    }
    

5、AOP 總結

5.1 AOP 的核心概念

  • 概念:AOP(Aspect Oriented Programming) 面向切面程式設計,一種程式設計正規化

  • 作用:在不驚動原始設計的基礎上為方法進行功能增強

  • 核心概念

    • 代理(Proxy):SpringAOP 的核心本質是採用代理模式實現的
    • 連線點(JoinPoint):在 SpringAOP 中,理解為任意方法的執行
    • 切入點(Pointcut):匹配連線點的式子,也是具有共性功能的方法描述
    • 通知(Advice):若干個方法的共性功能,在切入點處執行,最終體現為一個方法
    • 切面(Aspect):描述通知與切入點的對應繫結關係
    • 目標物件(Target):被代理的原始物件成為目標物件

5.2 切入點表示式

  • 切入點表示式標準格式:

    動作關鍵字(訪問修飾符 返回值 包名.類/介面名.方法名(引數)異常名)

    execution(* priv.dandelion.service.*Service.*(..))
    
  • 切入點表示式描述萬用字元:

    • 作用:用於快速描述,範圍描述
    • *:匹配任意符號(常用)
    • .. :匹配多個連續的任意符號(常用)
    • +:匹配子類型別
  • 切入點表示式書寫技巧

    1. 標準規範開發
    2. 查詢操作的返回值建議使用*匹配
    3. 減少使用..的形式描述包
    4. 對介面進行描述,使用*表示模組名,例如UserService的匹配描述為*Service
    5. 方法名書寫保留動詞,例如get,使用*表示名詞,例如getById匹配描述為getBy*
    6. 引數根據實際情況靈活調整

5.3 五種通知型別

  • 前置通知

  • 後置通知

  • 環繞通知(重點)

    • 環繞通知依賴形參ProceedingJoinPoint才能實現對原始方法的呼叫
    • 環繞通知可以隔離原始方法的呼叫執行
    • 環繞通知返回值設定為Object型別
    • 環繞通知中可以對原始方法呼叫過程中出現的異常進行處理
  • 返回後通知

  • 丟擲異常後通知

5.4 通知中獲取引數、返回值以及異常資訊

  • 獲取切入點方法的引數,所有的通知型別都可以獲取引數

    • JoinPoint:適用於前置、後置、返回後、丟擲異常後通知
    • ProceedingJoinPoint:適用於環繞通知
  • 獲取切入點方法返回值,前置和丟擲異常後通知是沒有返回值,後置通知可有可無,所以不做研究

    • 返回後通知
    • 環繞通知
  • 獲取切入點方法執行異常資訊,前置和返回後通知是不會有,後置通知可有可無,所以不做研究

    • 丟擲異常後通知
    • 環繞通知

6、AOP 事務管理

6.1 Spring 事務簡介及案例

6.1.1 相關概念介紹

  • 概念

    • 事務作用:在資料層保障一系列的資料庫操作的一致性

    • Spring事務作用:在資料層業務層保障一系列的資料庫操作的一致性

      業務層本質上是組合了多個資料層的功能,因此業務層也需要事務以保證操作的一致性

  • 使用到的介面

    Spring 提供了介面 PlatformTransactionManager 以及其簡單實現類 DataSourceTransactionManager(內部使用 JDBC 事務)

    public interface PlatformTransactionManager {
        void commit(TransactionStatus status) throws TransactionException;
        void rollback(TransactionStatus status) throws TransactionException;
    }
    

6.1.2 轉賬案例

6.1.2.1 需求分析
6.1.2.2 環境搭建
  1. 資料庫

    create database spring_db character set utf8;
    use spring_db;
    create table tbl_account(
        id int primary key auto_increment,
        name varchar(35),
        money double
    );
    insert into tbl_account values(1,'Tom',1000);
    insert into tbl_account values(2,'Jerry',1000);
    
  2. 建立專案匯入 jar 包

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
    
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
    
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
    
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    
    </dependencies>
    
  3. 根據表建立模型類

    public class Account implements Serializable {
    
        private Integer id;
        private String name;
        private Double money;
    	// setter
        // getter
        // toString    
    }
    
  4. Dao介面

    public interface AccountDao {
    
        @Update("update tbl_account set money = money + #{money} where name = #{name}")
        void inMoney(@Param("name") String name, @Param("money") Double money);
    
        @Update("update tbl_account set money = money - #{money} where name = #{name}")
        void outMoney(@Param("name") String name, @Param("money") Double money);
    }
    
  5. Service 介面和實現類(介面不表)

    @Service
    public class AccountServiceImpl implements AccountService {
        @Autowired
        private AccountDao accountDao;
    
        @Override
        public void transfer(String out,String in ,Double money) {
            accountDao.outMoney(out,money);
            accountDao.inMoney(in,money);
        }
    }
    
  6. jdbc.properties 配置檔案

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
    jdbc.username=root
    jdbc.password=123456
    
  7. JDBCConfig 配置類

    public class JdbcConfig {
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String userName;
        @Value("${jdbc.password}")
        private String password;
    
        @Bean
        public DataSource dataSource(){
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(userName);
            ds.setPassword(password);
            return ds;
        }
    }
    
  8. MybatisConfig 配置類

    public class MybatisConfig {
        @Bean
        public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
            SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
            ssfb.setTypeAliasesPackage("priv.dandelion.entity");
            ssfb.setDataSource(dataSource);
            return ssfb;
        }
    
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer(){
            MapperScannerConfigurer msc = new MapperScannerConfigurer();
            msc.setBasePackage("priv.dandelion.dao");
            return msc;
        }
    }
    
  9. SpringConfig 配置類

    @Configuration
    @ComponentScan("priv.dandelion")
    @PropertySource("classpath:jdbc.properties")
    @Import({JdbcConfig.class,MybatisConfig.class})
    public class SpringConfig {
    }
    
  10. Service 測試類

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = SpringConfig.class)
    public class AccountServiceTest {
    
        @Autowired
        private AccountService accountService;
    
        @Test
        public void testTransfer() throws IOException {
            accountService.transfer("Tom","Jerry",100D);
        }
    
    }
    
6.1.2.3 事務管理
  1. 再需要被事務管理的方法上新增@Transactional註解(一般加在介面而非實現類中)

    public interface AccountService {
        /**
         * 轉賬操作
         * @param out 傳出方
         * @param in 轉入方
         * @param money 金額
         */
        
        @Transactional
        public void transfer(String out,String in ,Double money);
    }
    
  2. 在 JDBCConfig 類中配置事務管理器

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        // 需要其他的Bean,直接寫引數,詳見Bean的注入
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
    
  3. 開啟事務註解 @EnableTransactionManagement

    @Configuration
    @ComponentScan("priv.dandelion")
    @PropertySource("classpath:jdbc.properties")
    @Import({JdbcConfig.class,MybatisConfig.class})
    @EnableTransactionManagement
    public class SpringConfig {
    }
    
6.1.2.4 相關知識點
  • @EnableTransactionManagement

    名稱 @EnableTransactionManagement
    型別 配置類註解
    位置 配置類定義上方
    作用 設定當前Spring環境中開啟註解式事務支援
  • @Transactional

    名稱 @Transactional
    型別 介面註解 類註解 方法註解
    位置 業務層介面上方 業務層實現類上方 業務方法上方
    作用 為當前業務層方法新增事務(如果設定在類或介面上方則類或介面中所有方法均新增事務)名稱

6.2 Spring 事務角色

  • 事務角色

    • 事務管理員:發起事務方,在Spring中通常指代業務層開啟事務的方法
    • 事務協調員:加入事務方,在Spring中通常指代資料層方法,也可以是業務層方法
  • 事務角色說明

    • Service 中方法 (事務管理員)

      // @Transactional
      public void transfer(String out,String in ,Double money) {
          accountDao.outMoney(out,money);
          accountDao.inMoney(in,money);
      }
      
    • Dao 介面中的方法 (事務協調員)

      @Update("update tbl_account set money = money + #{money} where name = #{name}")
      void inMoney(@Param("name") String name, @Param("money") Double money);
      
      @Update("update tbl_account set money = money - #{money} where name = #{name}")
      void outMoney(@Param("name") String name, @Param("money") Double money);
      
    • 新增@Transactional@Transactional

      • Service 中執行到 outMoney() 時,呼叫Dao,運算元據庫,該步驟是一個完整的事務
      • Service 中執行到 inMoney() 時,呼叫Dao,運算元據庫,該步驟是一個完整的事務
      • outMoney()inMoney() 之間沒有事務關係
    • 新增@Transactional@Transactional

      • Service 中執行到 outMoney() 時,呼叫Dao,運算元據庫,該步驟是一個完整的事務
      • Service 中執行到 inMoney() 時,呼叫Dao,運算元據庫,該步驟是一個完整的事務
      • 開啟 Spring 的事務管理後,Service 的 transfer() 方法成為一個獨立事務,此時其下事務將進行事務合併,outMoney()inMoney() 都加入到了transfer()事務中,合併成了完整的事務

6.3 Spring 事務屬性及案例

6.3.1 事務配置

補充:

  • 事務僅在發生 Error執行時異常 時才能正常回滾
  • 此外的異常若想正常回滾需要設定 rollbackFor 屬性
屬性 作用 示例
readOnly 設定是否為只讀事務 readOnly=true只讀,預設非只讀
timeOut 設定事務超時時間 值為 -1 表示永不超時
rollbackFor 設定遇到異常時回滾事務 rollbackFor={異常1.class, 異常2.class}
rollbackForClassName 設定遇到異常時回滾事務 引數為字串列表,是異常的名稱
noRollbackFor 設定不回滾的異常 引數為.class
noRollbackForClassName 設定不回滾的異常 引數為字串,異常名稱
propagation 設定事務傳播行為 (詳見6.3.2)

6.3.2 轉賬業務追加日誌案例

  • 改進轉賬案例

    1. 新增日誌記錄功能
    2. 不論事務是否回滾,都將記錄日誌
6.3.2.1 需求分析

禁止事務協調員的事務加入事務管理者的事務即可

6.3.2.2 環境準備
  1. 建立日誌表

    create table tbl_log(
       id int primary key auto_increment,
       info varchar(255),
       createDate datetime
    )
    
  2. 新增 LogDao 介面

    public interface LogDao {
        @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
        void log(String info);
    }
    
  3. 新增 LogService 介面與實現類

    @Service
    public class LogServiceImpl implements LogService {
    
        @Autowired
        private LogDao logDao;
        
    	@Transactional
        public void log(String out,String in,Double money ) {
            logDao.log("轉賬操作由"+out+"到"+in+",金額:"+money);
        }
    }
    
  4. 在轉賬的業務中新增記錄日誌

    @Service
    public class AccountServiceImpl implements AccountService {
    
        @Autowired
        private AccountDao accountDao;
        
        @Autowired
        private LogService logService;
        
    	@Transactional
        public void transfer(String out,String in ,Double money) {
            try{
                accountDao.outMoney(out,money);
                accountDao.inMoney(in,money);
            }finally {
                logService.log(out,in,money);
            }
        }
    }
    

6.3.3 事務傳播行為

  • 程式碼中,outMoney()inMoney()、三個為獨立事務,但是都加入了事務管理者transfer()開啟的事務中,合併為一個整體,出現異常時全部回滾,無法記錄日誌

    @Transactional
    public void transfer(String out,String in ,Double money) {
        try{
            accountDao.outMoney(out,money);
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
    
  • 可以將log()對應的事務獨立出來,不參與與事務管理者transfer()開啟的的事務合併,自然可以不隨之而回滾,可在任何時候完成事務

6.3.3.1 修改 logService 改變事務的傳播行為
@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String out,String in,Double money ) {
        logDao.log("轉賬操作由"+out+"到"+in+",金額:"+money);
    }
}
6.3.3.2 事務傳播行為的可選值
傳播屬性 事務管理員 事務協調員
REQUIRED(預設) 開啟事務T 加入事務T
:: 新建事務T2
REQUIRES_NEW 開啟事務T 另新建事務T2
:: 自主新建事務T2
SUPPORTS 開啟事務T 加入事務T
:: 跟隨事務管理員,不建立事務
NOT_SUPPORTED 開啟事務T 無視事務管理員,不加入事務
::
MANDATORY 開啟事務T 加入事務T
:: ERROR,事務管理員必須有事務
NEVER 開啟事務T ERROR,事務管理員不可有事務
::
NESTED 設定savePoint,一旦回滾將回滾到存檔點,有客戶響應提交 / 回滾

相關文章