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

来源:https://www.cnblogs.com/dandelion-000-blog/archive/2022/12/28/17009348.html
-Advertisement-
Play Games

原文地址：Spring學習筆記 - 第三章 - AOP與Spring事務 Spring 學習筆記全系列傳送門： Spring學習筆記 - 第一章 - IoC（控制反轉）、IoC容器、Bean的實例化與生命周期、DI（依賴註入） Spring學習筆記 - 第二章 - 註解開發、配置管理第三方Bean、 ...


原文地址：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,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 = "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 Serializab
您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 數字孿生賦能智慧港口解決方案，助力港口數字化轉型
    「如果港口是國民經濟的晴雨表，那麼智慧港口就是窺探港口未來發展的視窗。」 12月16日，2022智慧港口大會在浙江嘉興舉行，會議以“加快數字化轉型 賦能高質量發展”為主題，由中國港口協會、中國交通通信信息中心、浙江省海港集團聯合主辦，來自行業主管部門及港航管理部門、各大港口集團、科研院校、解決方案供 ...
  • 有備無患！DBS高性價比方案助力富途證券備份上雲
    “某中心受病毒攻擊，導致服務中斷，線上業務被迫暫停” “某公司員工誤操作刪庫，核心業務數據部分丟失，無法完全找回” “由於伺服器斷線，某醫院信息系統癱瘓近4小時，期間病人無法使用醫保卡掛號和結算” …… 數據丟失風險防不勝防，企業構建數據備份方案迫在眉睫！ 此次騰訊雲資料庫備份服務DBS攜手富途證券 ...
  • 盤活數據資產，驅動不動產數字化創新
    摘要：解決數據問題的本質，還要從數據層面入手，資料庫的價值就十分關鍵。 過去很長一段時間，不動產行業的數字化程度都是比較低的，特別在業務層面，存在大量碎片化和多主體的問題，導致在數據層面的標準化和數據結構統一化不足；而且在不動產行業全生命周期中，每個階段都頻繁涉及到數據流轉問題，對數據一致性和安全性 ...
  • Web應用怎樣獲取Access Token？
    1.在聯盟創建伺服器應用 參考文檔：開發準備 2.獲取用戶級Access Token 2.1 獲取code 參考文檔：接入華為帳號獲取憑證 2.1.1 先按照跳轉鏈接進行配置url https://oauth-login.cloud.huawei.com/oauth2/v3/authorize? r ...
  • Vue3 企業級優雅實戰 - 組件庫框架 - 9 實現組件庫 cli - 上
    上文搭建了組件庫 cli 的基礎架子，實現了創建組件時的用戶交互，但遺留了 cli/src/command/create-component.ts 中的 createNewComponent 函數，該函數要實現的功能就是上文開篇提到的 —— 創建一個組件的完整步驟。本文咱們就依次實現那些步驟。（友情 ...
  • 你是來找茬的吧？對自己的博客進行調優
    “作為博客園的使用者而不是開發者，就不能對博客進行調優了？看好了，我只示範一次。” —— 我說的 0x00 大綱 0x01 前言 用過很多博客和寫作平臺，但是最終還是選擇了博客園，畢竟，自定義 CSS 和自定義 JS 是真的香！某天突發奇想，決定對自己的博客進行下優化，現將其中的一些心得與大家分享。 ...
  • 物聯網 IOT 設備如何脫離信息孤島？
    目前在家庭物聯網這一塊，絕大部分的電子消費品都是基於wifi聯網的設備。從商家那裡達到消費者手中之後，簡單開機使用無法體現其全部價值，還是需要經過消費者給設備配網的過程，把設備從信息孤島接入互聯互通的世界。 ...
  • 後臺開發進階：白話DDD從入門到實踐
    DDD（領域驅動設計）是 Eric Evans 於 2003 年提出的解決複雜的中大型軟體的方法，開始一直不慍不火。直到 Martin Fowler 於 2014 年發表的論文《Microservices》引起大家對微服務的關註，DDD 才重新慢慢的回到了大眾的視野中。 DDD 這幾年升溫的同時，... ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類