學習筆記——Spring中的AOP(AspectJ)；Spring中AOP概述；Spring中AOP相關術語；AspectJ中切入點表達式；AspectJ中JoinPoint對象；AspectJ中通知

2023-01-18 一、Spring中的AOP 1、AspectJ （1）簡介 Java社區里最完整最流行的AOP框架在Spring2.0以上版本中，可以使用AspectJ註解或基於XML配置的AOP （2）使用AspectJ步驟 ①在spring核心包的基礎上添加支持jar包 <!-- htt ...

2023-01-18

一、Spring中的AOP

1、AspectJ

（1）簡介

Java社區里最完整最流行的AOP框架

在Spring2.0以上版本中，可以使用AspectJ註解或基於XML配置的AOP

（2）使用AspectJ步驟

①在spring核心包的基礎上添加支持jar包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.10</version>
</dependency>

②創建spring的配置文件，配置自動掃描的包和AspectJ註解支持

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    開啟組件掃描-->
    <context:component-scan base-package="com.hh"></context:component-scan>
<!--    開啟AspectJ註解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

③創建一個類作為切麵，在類的上面添加註解

@Component：將當前類標識為一個組件

@Aspect：將當前類標識為切麵類（非核心業務提取類）

@Component
@Aspect
public class MyLogging {

    /**
     * 方法之前
     */
    public static void beforeMethod(String methodName,Object[] arg){
        System.out.println("==>Calc中"+methodName+"方法()，參數："+ Arrays.toString(arg));
    }
    /**
     * 方法之後
     */
    public static void afterMethod(String methodName,Object rs){
        System.out.println("==>Calc中"+methodName+"方法()，結果："+rs);
    }
}

④將日誌類中的方法添加“通知註解”

@Before

⑤測試

二、Spring中AOP概述

1、AOP：Aspect-Oriented Programming，面向切麵編程（面向對象的一種補充）

優勢：解決了代碼分散與代碼混亂的問題

2、OOP：Object-Oriented Programming，面向對象編程

三、Spring中AOP相關術語

1、橫切關註點

非核心業務代碼

2、切麵（Aspect）

將橫切關註點提取到類中，這個類稱之為切麵類

3、通知（Advice）

將橫切關註點提取到類之後，橫切關註點更名為通知

4、目標（Target）

目標對象，指的是需要被代理的對象（實現類CalcImpl）

5、代理（Proxy）

代理對象可以理解為中介

6、連接點（Joinpoint）

通知方法需要指定通知位置，這個位置稱之為連接點（通知之前）

7、切入點（pointcut）

通知方法需要指定通知位置，這個位置稱之為切入點（通知之後）

四、AspectJ中切入點表達式

1、語法：@Before(value="execution(許可權修飾符返回值類型包名.類名.方法名(參數類型))")

2、通配符

（1）【*】

*：可以代表任意許可權修飾符＆返回值類型

*：可以代表任意包名、任意類名、任意方法名

（2）【..】

.. 代表任意參數類型及參數個數

3、重用切入點表達式

（1）使用@PointCut註解，提取可重用的切入點表達式

 //重用切入點表達式
    @Pointcut("execution(* com.hh.aop.CalcImpl.*(..))")
    public void myPointCut(){}

（2）使用方法名（）引入切入點表達式

@Before(value = "myPointCut()")

@After("myPointCut()")

五、AspectJ中JoinPoint對象

1、JoinPoint：切入點對象

2、作用：

（1）獲取方法名稱

String methodName = joinPoint.getSignature().getName();

註：joinPoint.getSignature() 表示方法簽名（方法簽名=方法名+參數列表）

（2）獲取參數

Object[] args = joinPoint.getArgs();

六、AspectJ中通知

1、前置通知

（1）語法：@Before

（2）執行時機：指定方法之前執行

指定方法：即切入點表達式設置位置

註：如果目標方法中有異常，會執行

（3）示例代碼

@Before(value = "myPointCut()")
    public void beforeMethod(JoinPoint joinPoint){
        //獲取方法名稱
        String methodName = joinPoint.getSignature().getName();
        //獲取參數
        Object[] args = joinPoint.getArgs();
        System.out.println("【前置通知】==>Calc中"+methodName+"方法()，參數："+ Arrays.toString(args));
    }

2、後置通知

（1）語法：@After

（2）執行時機：指定方法所有通知執行之後執行

註：如果目標方法中有異常，會執行

（3）示例代碼

 @After("myPointCut()")
    public void afterMethod(JoinPoint joinPoint){
        //獲取方法名稱
        String methodName = joinPoint.getSignature().getName();
        //獲取參數
        Object[] args = joinPoint.getArgs();
        System.out.println("【後置通知】==>Calc中"+methodName+"方法()，之後執行："+ Arrays.toString(args));
    }

3、返回通知

（1）語法：@AfterReturnning

（2）執行時機：指定方法返回結果時執行

註：@AfterReturnning中returning屬性中的的屬性名與入參中參數名一致；

如果目標方法中有異常，不執行

（3）示例代碼

@AfterReturning(value = "myPointCut()",returning = "rs")
    public void afterReturnning(JoinPoint joinPoint,Object rs){
        //獲取方法名稱
        String methodName = joinPoint.getSignature().getName();
        //獲取參數
        Object[] args = joinPoint.getArgs();
        System.out.println("【返回通知】==>Calc中"+methodName+"方法()，返回結果執行！結果："+ rs);
    }

4、異常通知

（1）語法：@AfterThrowing

（2）執行時機：：指定方法出現異常時執行

註：@AfterThrowing中throwing屬性中的的屬性名與入參中參數名一致；

如果目標方法中有異常，執行

（3）示例代碼

@AfterThrowing(value = "myPointCut()",throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint,Exception ex){
        //獲取方法名稱
        String methodName = joinPoint.getSignature().getName();
        //獲取參數
        Object[] args = joinPoint.getArgs();
        System.out.println("【異常通知】==>Calc中"+methodName+"方法()，出現異常時執行！異常："+ ex);
    }

說明：

①有異常：前置通知—>異常通知—>後置通知

②無異常：前置通知—>返回通知—>後置通知

5、環繞通知（前四個通知整合）

（1）語法：@Around

（2）作用:整合前四個通知

（3）註意：參數中必須使用ProceedingJoinPoint

（4）示例代碼

 @Around(value = "myPointCut()")
    public Object aroundMethod(ProceedingJoinPoint pjp){

        //獲取方法名稱
        String methodName = pjp.getSignature().getName();
        //獲取參數
        Object[] args = pjp.getArgs();
        //定義返回值
        Object rs = null;
        try {
            //前置通知 ）
            System.out.println("【前置通知】==>Calc中"+methodName+"方法()，參數："+ Arrays.toString(args));
            //觸發目標對象的目標方法(加減乘除)
            rs = pjp.proceed();
            //返回通知（有異常不執行
            System.out.println("【返回通知】==>Calc中"+methodName+"方法()，返回結果執行！結果："+ rs);
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            //異常通知
            System.out.println("【異常通知】==>Calc中"+methodName+"方法()，出現異常時執行！異常："+ throwable);
        }finally {
            //後置通知(有異常執行)
            System.out.println("【後置通知】==>Calc中"+methodName+"方法()，之後執行："+ Arrays.toString(args));
        }
        return rs;
    }