5.1 Spring5原始碼--Spring AOP原始碼分析一

盛開的太陽發表於2020-12-06
Spring原始碼

目標:

1.什麼是AOP, 什麼是AspectJ,

2. 什麼是Spring AOP

3. Spring AOP註解版實現原理

4. Spring AOP切面原理解析

 一. 認識AOP

1.1 什麼是AOP

aop是面向切面程式設計，相比傳統oop，aop能夠在方法的前置，中置，後置中插入邏輯程式碼，對於專案中大量邏輯重複的程式碼，使用aop能很好的收口邏輯，將邏輯獨立於業務程式碼之外，一處編寫，多處使用。

AOP是Object Oriented Programming（OOP）的補充.

OOP能夠很好地解決物件的資料和封裝的問題，卻不能很好的解決Aspect（"方面"）分離的問題。下面舉例具體說明。

比如，我們有一個Bank（銀行）類。Bank有兩個方法，save（存錢）和withdraw（取錢）。

類和方法的定義如下:

package com.lxl.www.aop;

public class Bank {

  /**
   * 存錢
   */
  public Float save(Account account, float money) {
    // 增加account賬戶的錢數，返回賬戶裡當前的錢數
    return null;
  }

  /**
   * 取錢
   */
  public Float withdraw(Account account, float money) {
    // 減少account賬戶的錢數，返回取出的錢數
    return null;
  }
};

 

這兩個方法涉及到使用者的賬戶資金等重要資訊，必須要非常小心，所以編寫完上面的商業邏輯之後，專案負責人又提出了新的要求--給Bank類的每個重要方法加上安全認證特性。

於是, 我們在兩個方法上增加安全程式碼

改後的類和方法如下:

public class Bank {

  /**
   * 存錢
   */
  public Float save(Account account, float money) {
    // 驗證account是否為合法使用者
    // 增加account賬戶的錢數，返回賬戶裡當前的錢數
    return null;
  }

  /**
   * 取錢
   */
  public Float withdraw(Account account, float money) {
    // 驗證account是否為合法使用者
    // 減少account賬戶的錢數，返回取出的錢數
    return null;
  }
};

 

這兩個方法都需要運算元據庫，為了保持資料完整性，專案負責人又提出了新的要求--給Bank類的每個運算元據庫的方法加上事務控制。

於是，我們不得不分別在上面的兩個方法中加入安全認證的程式碼。

類和方法的定義如下：

package com.lxl.www.aop;

public class Bank {

  /**
   * 存錢
   */
  public Float save(Account account, float money) {
    // 驗證account是否為合法使用者
    // begin Transaction
    // 增加account賬戶的錢數，返回賬戶裡當前的錢數
    // end Transaction
    return null;
  }

  /**
   * 取錢
   */
  public Float withdraw(Account account, float money) {
    // 驗證account是否為合法使用者
    // begin Transaction
    // 減少account賬戶的錢數，返回取出的錢數
    // end Transaction 
    return null;
  }
};

 

我們看到，這些與商業邏輯無關的重複程式碼遍佈在整個程式中。實際的工程專案中涉及到的類和函式，遠遠不止兩個。如何解決這種問題？

AOP就是為了解決這種問題而出現的。在不修改程式碼的情況下達到增強的效果

1.2 AOP的相關概念

  • 切面(Aspect): 封裝通用業務邏輯的元件，即我們想要插入的程式碼內容. 在spring AOP中, 切面可以使用通用類基於模式的方式, 或者在普通類中標註@Aspect註解來實現
  • 連線點(Join point): 連線點是在應用執行過程中能夠插入切面的點。簡單理解, 可以理解為需要增強的方法.
  • 通知(Advice):　用於指定具體產生作用的位置，是方法之前或之後等等
    • 前置通知（before） - 在目標方法被呼叫之前呼叫通知功能
    • 後置通知（after） - 在目標方法完成之後呼叫通知（不論程式是否出現異常），此時不會關心方法的輸出是什麼
    • 返回通知（after-returning） - 在目標方法成功執行之後呼叫通知
    • 異常通知（after-throwing） - 在目標方法丟擲異常後呼叫通知
    • 環繞通知（around） - 通知包裹了被通知的方法，在被通知的方法呼叫之前和呼叫之後執行自定義的行為
  • 目標物件(target): 目標物件是指要被增強的物件, 即包含主業務邏輯的類物件
  • 切點(PointCut): 指定哪些Bean元件的哪些方法使用切面元件. 例如:當執行某個特定名稱的方法時.我們定義一個切點(execution com.lxl.www.aop.*.*(..)) . 切點表示式如何和連線點匹配是AOP的核心. spring預設使用AspectJ切點語義.
  • 織入(Weaving): 將通知切入連線點的過程叫做織入
  • 引入(Introductions): 可以將其它介面或者實現動態引入到targetClass中
5.1 Spring5原始碼--Spring AOP原始碼分析一

對照上圖, 來對應每一個區域,看看其具體含義

 5.1 Spring5原始碼--Spring AOP原始碼分析一 

那麼在Spring中使用AOP就意味著你需要哪些東西呢?我們來舉個例子, 就實現上面銀行的例子.
  • 首先有一個bank銀行類 
    package com.lxl.www.aop.bank;

public interface Bank {

  /**
   * 存錢
   */
  Float save(Account account, float money) ;

  /**
   * 取錢
   */
  Float withdraw(Account account, float money);
};

     

     

  • 有一個銀行類的實現方法. 這裡面save, withdraw就是連線點. 最終會將各種通知插入到連線點中 
    package com.lxl.www.aop.bank;

import org.springframework.stereotype.Service;

/**
 * 工商銀行
 *
 *
 * DATE 2020/12/6.
 *
 * @author lxl.
 */
@Service
public class IcbcBank implements Bank{
    @Override
    public Float save(Account account, float money) {
            // 主業務邏輯: 增加account賬戶的錢數，返回賬戶裡當前的錢數
        System.out.println(account.getName() + "賬戶存入" + money);
        return null;
    }

    @Override
    public Float withdraw(Account account, float money) {
            // 主業務邏輯: 減少account賬戶的錢數，返回取出的錢數
        System.out.println(account.getName() + "賬戶取出" + money);
        return null;
    }
}

     

     

  • 接下來, 要有一個切面, 切面是一個類. 切面類裡面定義了切點, 通知, 引用 
    package com.lxl.www.aop.bank;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.DeclareParents;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 切面
 */
@Aspect // 標記這是一個切面
@Order
@Component // 將其放到ioc容器管理
public class BankLogAspect {

  /**
   * 引入
   *
   * 這段話可以理解為, 為com.lxl.www.aop.bank.IcbcBank 引入了一個介面 EnhanceFunctionOfBank,
   * 同時, 引入了預設的實現類 IcbcEnhanceFunctionOfBank
   */
  @DeclareParents(value = "com.lxl.www.aop.bank.IcbcBank",    // 引入的目標類. 也就是需要引入動態實現的類
          defaultImpl = IcbcEnhanceFunctionOfBank.class) // 引入的介面的預設實現
  public static EnhanceFunctionOfBank enhanceFunctionOfBank; // 引入的介面


  /**
   * 定義一個切點
   */
  @Pointcut("execution(* com.lxl.www.aop.bank.IcbcBank.*(..))")
  public void pointCut() {}

  /**
   * 定義一個前置通知
   * @param joinPoint
   */
  @Before(value = "pointCut()")
  public void beforeAdvice(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    System.out.println("執行目標方法"+methodName+"的前置通知");
  }

  /**
   * 定義了一個後置通知
   */
  @After(value = "pointCut()")
  public void afterAdvice(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    System.out.println("執行目標方法"+methodName+"的後置通知");
  }

  /**
   * 定義了一個返回通知
   */
  @AfterReturning(value = "pointCut()", returning = "result")
  public void returningAdvice(JoinPoint joinPoint, Object result) {
    String methodName = joinPoint.getSignature().getName();
    System.out.println("執行目標方法"+methodName+"的返回通知");
  }

  /**
   * 定義了一個異常通知
   */
  @AfterThrowing(value = "pointCut()")
  public void throwingAdvice(JoinPoint joinPoint) {
    String methodName = joinPoint.getSignature().getName();
    System.out.println("執行目標方法"+methodName+"的異常通知");
  }

}

    那麼這裡的目標物件是誰呢? 就是我們的IcbcBank類. 這裡需要注意的是引入: 引入的概念是將一個介面動態的讓另一個類實現了. 這樣實現了介面的類, 就可以動態的擁有介面實現類的功能.

  • 銀行的額外功能. 也就是銀行除了可以存錢, 取錢. 還有一個額外的功能. 比如理財. 不是每個銀行都有的.  
    package com.lxl.www.aop.bank;

/**
 * 增強的功能
 */
public interface EnhanceFunctionOfBank {

    void Financialanagement(Account account);
}

     

  • 具體銀行額外功能的實現類 
    package com.lxl.www.aop.bank;

import org.springframework.stereotype.Service;

/**
 * Description
 */
@Service
public class IcbcEnhanceFunctionOfBank implements EnhanceFunctionOfBank {
    /**
     * 理財功能
     * @param account
     */
    @Override
    public void Financialanagement(Account account) {
        System.out.println(account.getName() +"的賬戶 增加 理財功能");
    }

}

    這個功能我們可以通過引入,動態增加到IcbcBank類中, 原本IcbcBank只有存錢和取錢的功能. 這樣, 就可以增加理財功能了. 這就是引入.

  • 整體配置類 
    package com.lxl.www.aop.bank;

import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configurable
// 使用註解的方式引入AOP
@EnableAspectJAutoProxy
@ComponentScan("com.lxl.www.aop.bank")
public class BankMainConfig {

}

     

    使用aop,需要引入AOP, 這裡使用的註解的方式引入的.

  • main入口方法 
    package com.lxl.www.aop.bank;

import com.lxl.www.aop.Calculate;
import com.lxl.www.aop.MainConfig;
import com.lxl.www.aop.ProgramCalculate;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class BankMainClass {
  public static void main(String[] args) {

    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(BankMainConfig.class);

    Account account = new Account("張三");

    Bank bank = (Bank) ctx.getBean("icbcBank");
    bank.save(account, 100);

    System.out.println();
    EnhanceFunctionOfBank enhanceFunctionOfBank = (EnhanceFunctionOfBank) ctx.getBean("icbcBank");
    enhanceFunctionOfBank.Financialanagement(account);
  }
}

    如上, 執行結果:

        5.1 Spring5原始碼--Spring AOP原始碼分析一 

  • 需要注意的地方: 是.gradle配置檔案. 通常, 我們在引入AspectJ的jar包的時候, 會引入到父類專案的build.gradle中. 如下所示5.1 Spring5原始碼--Spring AOP原始碼分析一

     

    最後我們還需要引入到指定的專案中 

       5.1 Spring5原始碼--Spring AOP原始碼分析一

 

以上就是對整個AOP的理解. 接下來, 分析AOP的原始碼.

詳見第二篇文章

 

 

 

 

 

 

 

 

 

 

 

as

相關文章