主頁 > 後端開發 > Spring學習筆記 - 第三章 - AOP與Spring事務

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

2022-12-28 07:10:12 後端開發

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

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

  • Spring學習筆記 - 第一章 - IoC（控制反轉）、IoC容器、Bean的實體化與生命周期、DI（依賴注入）

  • Spring學習筆記 - 第二章 - 注解開發、配置管理第三方Bean、注解管理第三方Bean、Spring 整合 MyBatis 和 Junit 案例

  • 【本章】Spring學習筆記 - 第三章 - AOP與Spring事務

目錄
  • 1、AOP 簡介
    • 1.1 什么是 AOP
    • 1.2 AOP 的作用
    • 1.3 AOP 核心概念
  • 2、AOP 入門案例
    • 2.1 需求分析
    • 2.2 思路分析
    • 2.3 環境準備
    • 2.4 AOP 實作步驟
    • 2.5 相關知識點
  • 3、AOP 作業流程與核心概念
    • 3.1 AOP 作業流程
    • 3.2 AOP 核心概念
  • 4、AOP 配置管理
    • 4.1 AOP 切入點運算式
      • 4.1.1 語法格式
      • 4.1.2 通配符
      • 4.1.3 書寫技巧
    • 4.2 AOP 通知型別
      • 4.2.1 型別介紹
      • 4.2.2 環境準備
      • 4.2.3 通知型別的使用
        • 4.2.3.1 通知型別
        • 4.2.3.2 通知型別相關知識點總結
    • 4.3 案例：測驗業務層介面萬次執行效率
      • 4.3.1 需求分析
      • 4.3.2 環境準備
      • 4.3.3 功能開發
    • 4.4 AOP 通知獲取資料
      • 4.4.1 環境準備
      • 4.4.2 獲取引數
        • 4.4.2.1 非環繞通知獲取方式
        • 4.4.2.2 環繞通知獲取方式
      • 4.4.3 獲取回傳值
        • 4.4.3.1 環繞通知獲取回傳值
        • 4.4.3.2 非環繞通知獲取回傳值
      • 4.4.4 獲取例外
        • 4.4.4.1 環繞通知獲取例外
        • 4.4.4.2 拋出例外后通知獲取例外
    • 4.5 百度網盤密碼資料兼容處理
      • 4.5.1 需求分析
      • 4.5.2 環境準備
      • 4.5.3 具體實作
  • 5、AOP 總結
    • 5.1 AOP 的核心概念
    • 5.2 切入點運算式
    • 5.3 五種通知型別
    • 5.4 通知中獲取引數、回傳值以及例外資訊
  • 6、AOP 事務管理
    • 6.1 Spring 事務簡介及案例
      • 6.1.1 相關概念介紹
      • 6.1.2 轉賬案例
        • 6.1.2.1 需求分析
        • 6.1.2.2 環境搭建
        • 6.1.2.3 事務管理
        • 6.1.2.4 相關知識點
    • 6.2 Spring 事務角色
    • 6.3 Spring 事務屬性及案例
      • 6.3.1 事務配置
      • 6.3.2 轉賬業務追加日志案例
        • 6.3.2.1 需求分析
        • 6.3.2.2 環境準備
      • 6.3.3 事務傳播行為
        • 6.3.3.1 修改 logService 改變事務的傳播行為
        • 6.3.3.2 事務傳播行為的可選值

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,delete和select 方法），
      • 切入點：在上述四個方法中，除 save 方法之外，僅 update 和 delete 方法執行了萬次，即追加了功能，這些追加了同一種功能的方法（可以是一個也可以是多個，此處為兩個）稱為一個切入點，反之，如 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 = "https://www.cnblogs.com/dandelion-000-blog/archive/2022/12/28/pt()", returning = "ret")
public void afterReturning(Object ret) {
    System.out.println("afterReturning advice ..." + ret);
}

  • 獲取引數的同時獲取回傳值

    同時獲取時需要注意

    • 用于獲取引數串列的 JoinPoint 型別的形參必須放在第一位，否則會報錯
    @AfterReturning(value = "https://www.cnblogs.com/dandelion-000-blog/archive/2022/12/28/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 = "https://www.cnblogs.com/dandelion-000-blog/archive/2022/12/28/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，一旦回滾將回滾到存檔點，有客戶回應提交 / 回滾

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/540787.html

標籤：其他

上一篇：Spring IOC官方檔案學習筆記（五）之bean的作用域

下一篇：C++11：非受限聯合體（union）

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂