day09-AOP-02

一刀一個小西瓜發表於2023-01-24

AOP-02

4.問題提出

在上一篇的MyProxyProvider類中，我們的輸出語句功能比較弱，在實際開發中，我們希望是以一個方法的形式，嵌入到真正執行的目標方法前，怎麼辦？

image-20230123225502663

1.使用土方法解決

需求分析：使用土方法解決前面的問題，後面使用spring的aop元件完成

改進MyProxyProvider：

主要是對前置/返回/異常/最終通知的程式碼進行封裝，封裝到不同的方法中進行呼叫。

package com.li.aop.proxy3;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 返回一個動態代理物件，可以執行被代理的物件的方法
 */
public class MyProxyProvider {

    //定義要執行的目標物件，該物件需要實現 SmartAnimal介面
    private SmartAnimal target_animal;

    //構造器
    public MyProxyProvider(SmartAnimal target_animal) {
        this.target_animal = target_animal;
    }

    //定義一個方法，在目標物件執行前執行
    public void before(Method method, Object[] args) {
        System.out.println("before-方法執行開始-日誌-方法名-" + method.getName() +
                "-引數 " + Arrays.toString(args));//AOP的角度看，是一個橫切關注點-前置通知
    }

    //定義一個方法，在目標物件執行後行
    public void after(Method method, Object result) {
        System.out.println("after-方法執行正常結束-日誌-方法名-" + method.getName()
                + "-結果 result = " + result);//也是一個橫切關注點-返回通知
    }

    //定義方法返回代理物件，該代理物件可以執行目標物件
    public SmartAnimal getProxy() {
        //(1)先得到類載入器物件
        ClassLoader classLoader = target_animal.getClass().getClassLoader();
        //(2)得到要執行的目標物件的介面資訊
        Class<?>[] interfaces = target_animal.getClass().getInterfaces();
        //(3)使用匿名內部類 建立 InvocationHandler物件
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object result = null;
                try {

                    before(method, args);

                    //使用反射真正呼叫方法
                    result = method.invoke(target_animal, args);

                    after(method, result);

                } catch (Exception e) {
                    //如果反射出現異常，就會進入到catch塊
                    System.out.println("方法執行異常-日誌-方法名" + method.getName()
                            + "-異常型別=" + e.getClass().getName());//橫切關注點-異常通知
                    e.printStackTrace();
                } finally {//無論是否出現異常，最終都會執行到 finally{}
                    //也是一個橫切關注點-最終通知
                    System.out.println("方法最終結束-日誌-方法名-" + method.getName());
                }
                return result;
            }
        };

        //建立代理物件
        SmartAnimal proxy = (SmartAnimal) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
        return proxy;
    }
}

2.對土方法進行解耦-開發簡易的AOP類

上面的程式碼因為前後置等處理方法都寫在同一個類中，造成程式碼耦合度高的問題。因此，更好的解決方法是新建一個類MyAOP，在該類中進行處理方法的編寫，然後在MyProxyProvider類中呼叫該類的方法。

MyAOP類：

package com.li.aop.proxy3;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 自己寫的一個極簡AOP類
 */
public class MyAOP {
    //定義一個方法，在目標物件執行前執行
    public static void before(Method method, Object[] args) {
        System.out.println("MyAOP-方法執行開始-日誌-方法名-" + method.getName() +
                "-引數 " + Arrays.toString(args));//前置通知
    }

    //定義一個方法，在目標物件執行後行
    public static void after(Method method, Object result) {
        System.out.println("MyAOP-方法執行正常結束-日誌-方法名-" + method.getName()
                + "-結果 result = " + result);//返回通知
    }

}

3.再次分析-提出Spring AOP

使用上面的辦法仍存在一些問題：

  1. 不夠靈活：假設被代理物件有很多方法，而我們只想僅對其中一個方法進行處理，當前的程式碼還不能實現這個需求
  2. 複用性差：假如有一個新的介面USBInterface，Phone類實現了這個介面，現在我們想要Phone類去呼叫之前MyAOP中的方法。但MyAOP類的方法是根據之前的SmartAnimal介面的方法寫的，因此不能很好的適用於新的介面及其實現類
  3. 硬編碼：沒有註解和反射的支撐

5.AOP的基本介紹

1.什麼是AOP?

官方文件：核心技術 (spring.io)

AOP全稱：aspect oriented programming，即面向切面程式設計。

AOP 是一種程式設計思想，是物件導向程式設計（OOP）的一種補充。物件導向程式設計將程式抽象成各個層次的物件，而面向切面程式設計是將程式抽象成各個切面。

2.AOP和OOP的區別：

OOP 針對業務處理過程的實體及其屬性和行為進行抽象封裝，以獲得更加清晰高效的邏輯單元劃分。

而 AOP 則是針對業務處理過程中的切面進行提取，它所面對的是處理過程中的某個步驟或階段，以獲得邏輯過程中各部分之間低耦合性的隔離效果。

這兩種設計思想在目標上有著本質的差異：

面向目標不同：簡單來說 OOP 是面向名詞領域，AOP 面向動詞領域。

思想結構不同：OOP 是縱向結構，AOP 是橫向結構。

注重方面不同：OOP 注重業務邏輯單元的劃分，AOP 偏重業務處理過程中的某個步驟或階段。

image-20230124201430007

aop透過動態代理+反射的方式，對被代理物件的方法進行呼叫。

這個被代理物件的方法的呼叫過程，會拆分成幾個橫切關注點：

  1. 方法呼叫前
  2. 方法呼叫
  3. 方法呼叫後
  4. 異常位置（catch塊）
  5. 方法最終呼叫位置（finally塊）

如下，切面類C的不同方法f1……fn可以在不同類A,B......的方法m1,m2......執行的過程中，在方法的不同橫切關注點任意切入/呼叫。

即切面類的任意方法可以在任意類的任意方法執行的過程中，在該方法的不同橫切關注點任意切入。

day09-AOP-02
day09-AOP-02 image-20230124220055481

3.AOP的實現方式

  1. 基於動態代理的方式[內建AOP實現]
  2. 使用框架aspectj來實現

6.AOP程式設計快速入門

6.1基本說明

這裡使用框架aspectj來實現：

  1. 引入核心的aspect包

  2. 在切面類中宣告通知方法

    • 前置通知：@Before
    • 返回通知：@AfterReturning
    • 異常通知：@AfterThrowing
    • 後置通知：@After
    • 環繞通知：@Around

  3. 五種通知和前面寫的動態代理類方法的對應關係：

    image-20230124220656090

6.2快速入門例項

使用aop程式設計的方式，來實現手寫的動態代理案例的效果。以上一篇的3.1為例子：

需求說明：有一個SmartAnimal介面，可以完成簡單的加減法，要求在執行getSum()和getSub()時，輸出執行前、執行過程、執行後的日誌輸出，請思考如何實現

1.匯入AOP程式設計需要的包

image-20230124221446843

2.程式碼實現

2.1SmartAnimal介面：

package com.li.aop.aspectj;

/**
 * @author 李
 * @version 1.0
 */
public interface SmartAnimal {
    //求和
    float getSum(float a, float b);

    //求差
    float getSub(float a, float b);
}

2.2SmartDog實現類：

package com.li.aop.aspectj;

import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 */

//使用component註解，當spring容器啟動時，將SmartDog注入容器
@Component
public class SmartDog implements SmartAnimal {
    @Override
    public float getSum(float a, float b) {
        float result = a + b;
        System.out.println("方法內部列印 result = " + result);
        return result;
    }

    @Override
    public float getSub(float a, float b) {
        float result = a - b;
        System.out.println("方法內部列印 result = " + result);
        return result;
    }
}

2.3SmartAnimalAspect切面類：

package com.li.aop.aspectj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 切面類，類似之前寫的 MyProxyProvider，但是功能比它強大得多
 */
@Aspect //表示一個切面類[底層自動注入切面程式設計的支撐(動態代理+反射+動態繫結)]
@Component  //注入切面類到ioc容器
public class SmartAnimalAspect {

    /**
     * 前置通知
     * 1.@Before表示前置通知，即在我們的目標物件執行方法前執行
     * 2.value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))"
     * 指定切入到哪個類的哪個方法 形式為：execution(訪問修飾符 返回型別 全類名.方法名(形參列表))
     * 3.f1方法就是一個切入方法，方法名隨意
     * 4.JoinPoint joinPoint 在底層執行時，由AspectJ切面框架，給切入方法傳入joinPoint連線點物件
     * 透過切面方法，可以獲取你想要的資訊
     *
     * @param joinPoint
     */
    @Before(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
    public void f1(JoinPoint joinPoint) {
        //透過連線點物件joinPoint 拿到方法簽名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f1()-方法執行開始-日誌-方法名-" + signature.getName() +
                "-引數 " + Arrays.toString(joinPoint.getArgs()));
    }

    //返回通知：把 f2方法切入到目標物件方法正常執行完畢後的位置
    @AfterReturning(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
    public void f2(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f2()-方法執行正常結束-日誌-方法名-" + signature.getName());
    }

    //異常通知：把 f3方法切入到目標物件方法出現異常後的catch塊位置
    @AfterThrowing(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
    public void f3(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f3()-方法執行異常-日誌-方法名-" + signature.getName());
    }

    //最終通知：把 f4方法切入到目標物件方法執行後的位置，無論有無出現異常都會執行
    @After(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
    public void f4(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f4()-方法最終執行完畢-日誌-方法名-" + signature.getName());
    }

}

2.4配置容器檔案beans07.xml：

<?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.li.aop.aspectj"/>

    <!--一定要開啟基於註解的 AOP 功能-->
    <aop:aspectj-autoproxy/>
</beans>

2.5測試類：

package com.li.aop.aspectj;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 * 測試類
 */
public class AopAspectjTest {
    @Test
    public void smartDogTestByAspectj() {

        //得到Spring容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans07.xml");

        //透過介面型別來獲得注入的SmartDog物件（實際上是代理物件proxy）
        SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);

        //class com.sun.proxy.$Proxy15
        //System.out.println("smartAnimal的執行型別=" + smartAnimal.getClass());

        smartAnimal.getSum(100, 48);
    }
}

測試結果：

image-20230124231954462

6.3細節說明

  1. 關於切面類方法命名可以自己規範一下

  2. 切入表示式的更多配置，比如使用模糊配置

    形式為：execution(訪問修飾符 返回型別 全類名.方法名(形參列表))

    @Before(value = "execution(* com.li.aop.aspect.SmartDog.*(..))")

  3. 下面表示所有訪問許可權，所有包下所有類的所有方法（前提是基於動態代理的類），都會被執行前置通知方法

    @Before(value = "execution(* *.*(..))")

  4. spring容器開啟了基於註解的AOP功能<aop:aspectj-autoproxy/>，獲取注入的物件則需要以介面的型別來獲取，因為你注入的物件.getClass()已經是代理型別了！

  5. spring容器開啟了基於註解的AOP功能，也可以透過id來獲取注入的物件，但也要轉成介面型別來獲取。

6.4練習

  1. 有一個介面USBInterface，該介面有一個方法work
  2. 寫出實現子類Phone和Camera
  3. 寫一個切面類，在該切面類中寫一個方法（可輸出日誌資訊）等作為前置通知，在Phone和Camera物件執行work方法前呼叫
  4. 其他通知，如返回通知，異常通知，後置通知，也可以加入

（1）UsbInterface介面：

package com.li.aop.hw;

/**
 * @author 李
 * @version 1.0
 */
public interface UsbInterface {
    public void work(String s);
}

（2）Phone實現類：

package com.li.aop.hw;

import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 */
@Component //將Phone物件當做元件注入到容器中
public class Phone implements UsbInterface {
    @Override
    public void work(String s) {
        System.out.println("手機開始工作，引數是=" + s);
    }
}

（3）Camera實現類：

package com.li.aop.hw;

import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 */
@Component
public class Camera implements UsbInterface {
    @Override
    public void work(String s) {
        System.out.println("相機開始工作，引數是=" + s);
    }
}

（4）配置容器檔案：

<!--配置自動掃描的包-->
<context:component-scan base-package="com.li.aop.hw"/>

<!--開啟基於註解的aop功能-->
<aop:aspectj-autoproxy/>

（5）MyAspect切面類：

package com.li.aop.hw;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 切面類
 */

@Component
@Aspect
public class MyAspect {
    //前置通知
    @Before(value = "execution(public void com.li.aop.hw.*.work(String))")
    public void beforeRunning(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("MyAspect前置通知-目標方法-" + methodName +
                " 引數-" + Arrays.toString(joinPoint.getArgs()));
    }

    //其他通知邏輯相同,略

}

（6）測試類：

package com.li.aop.hw;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
public class UsbTest {
    @Test
    public void UsbAspectTest() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans08.xml");
        //獲取的實際都是代理物件
        UsbInterface phoneProxy = ioc.getBean("phone", UsbInterface.class);
        UsbInterface cameraProxy = ioc.getBean("camera", UsbInterface.class);
        phoneProxy.work("三星");
        System.out.println("============");
        cameraProxy.work("萊卡");
    }
}

測試結果：

image-20230125210719575

需要注意的是，如果測試類中使用介面型別獲取bean，是因為當前ioc容器中只有一個代理物件。即只有一個類實現了SmartAnimal介面，因此這裡只會有一個代理類。

如果有多個類實現介面，就不能使用介面型別獲取bean。單例物件id預設分配的id是：id=類名（首字母小寫）。或者透過自定義id來獲取實現類的代理物件。