day09-AOP-02

来源:https://www.cnblogs.com/liyuelian/archive/2023/01/24/17066553.html
-Advertisement-
Play Games

AOP-02 4.問題提出 在上一篇的MyProxyProvider類中，我們的輸出語句功能比較弱，在實際開發中，我們希望是以一個方法的形式，嵌入到真正執行的目標方法前，怎麼辦？ 1.使用土方法解決 需求分析：使用土方法解決前面的問題，後面使用spring的aop組件完成 改進MyProxyProv ...


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......執行的過程中，在方法的不同橫切關註點任意切入/調用。

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

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. 其他通知，如返回通知，異常通知，後置通知，也可以加入

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • System
    System類 exit：退出當前程式。 arraycopy：複製數組元素，比較適合底層調用，一般使用Arrays.copyOF完成複製數組。 currentTimeMillens：返回當前時間距離 1970-1-1 的毫秒數。 gc：運行垃圾回收機制 System.gc(); public cla ...
  • 財務精度：BigInteger 與 BigDecimal
    財務精度：BigInteger 與 BigDecimal 每博一文案 師父說: 人這一輩子，真地好難。 有些人，好著好著，忽然就變陌生了，有些手，牽著牽著，瞬間就放開了，有些路，走著走著，就失去了方向了。 懵懵懂懂，一眨眼，我們就長大了，愛過的人，一轉身，，青春就溜走了。以為有來日方長的，最後只剩人 ...
  • 學習筆記——Liunx；Linux文件與目錄結構；VI/VIM編輯器（一般模式、編輯模式、命令模式）
    2023-01-23 一、Linux 1、Liunx的簡介 Linux是一套免費使用和自用傳播的類Unix操作系統，是一個基於POSIX和UNIX的多用戶、多任務、支持多線程和多CPU的操作系統。Linux能運行主要的UNIX工具軟體、應用程式和網路協議。它支持32位和64位硬體。Linux繼承了U ...
  • RHCE01-Redhat 8 的安裝和初始配置
    Redhat 8 的安裝和初始配置 環境說明： 1.在VMWare Workstation上創建虛擬機安裝RHEL 8先決條件：自己的物理機（電腦/工作站/伺服器）的CPU的虛擬化功能要開啟。Intel的CPU：Virtualization Technology（VT-x）AMD的CPU：SVM M ...
  • 微機原理與系統設計筆記2 | 8086CPU結構與功能
    打算整理彙編語言與介面微機這方面的學習記錄。本部分講解8086CPU的結構和基本功能以及特性。 參考資料 西電《微機原理與系統設計》周佳社 西交《微機原理與介面技術》 課本《彙編語言與介面技術》王讓定 小甲魚《彙編語言》 1. 微處理器的外部結構 1.1 引腳 外部結構就是封裝出來的輸入輸出引腳。8 ...
  • linux環境編程(2): 使用pipe完成進程間通信
    1. 寫在前面 linux系統內核為上層應用程式提供了多種進程間通信(IPC)的手段，適用於不同的場景，有些解決進程間數據傳遞的問題，另一些則解決進程間的同步問題。對於同樣一種IPC機制，又有不同的API供應用程式使用，目前有POSIX IPC以及System V IPC可以為應用程式提供服務。後續 ...
  • flex佈局 -- 彈性盒模型
    flex佈局 -- 彈性盒模型 display: flex; 就會讓其變成彈性盒子 當把一個元素的 display 屬性設置為 flex 或者 inline-flex 後，它就成了一個容器。 flex 與 inline-flex 的關係就類似 block 與 inline-block 的關係，定義里 ...
  • 淺談PHP設計模式的組合模式
    簡介： 組合模式，屬於結構型的設計模式。將對象組合成樹形結構以表示“部分-整體”的層次結構。組合模式使得用戶對單個對象和組合對象的使用具有一致性。 組合模式分兩種狀態： 透明方式，子類的所有介面一致，使其葉子節點和枝節點對外界沒有區別。 安全方式，子類介面不一致，只實現特定的介面。 適用場景： 希望 ...
一周排行
    -Advertisement-
    Play Games
  • （開源）都進來！簡單易懂、功能強大的許可權+可視化流程管理系統
    1、預覽地址：http://139.155.137.144:9012 2、qq群:801913255 一、前言 隨著網路的發展，企業對於信息系統數據的保密工作愈發重視，不同身份、角色對於數據的訪問許可權都應該大相徑庭。 列如 1、不同登錄人員對一個數據列表的可見度是不一樣的，如數據列、數據行、數據按鈕 ...
  • 設計模式-C#實現簡單工廠模式
    前言 上一篇文章寫瞭如何使用RabbitMQ做個簡單的發送郵件項目，然後評論也是比較多，也是準備去學習一下如何確保RabbitMQ的消息可靠性，但是由於時間原因，先來說說設計模式中的簡單工廠模式吧！ 在瞭解簡單工廠模式之前，我們要知道C#是一款面向對象的高級程式語言。它有3大特性，封裝、繼承、多態。 ...
  • Nodify學習 一：介紹與使用
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 介紹 Nodify是一個WPF基於節點的編輯器控制項，其中包含一系列節點、連接和連接器組件，旨在簡化構建基於節點的工具的過程 ...
  • 使用C#/.NET解析Wiki百科數據實現獲取歷史上的今天
    創建一個webapi項目做測試使用。 創建新控制器，搭建一個基礎框架，包括獲取當天日期、wiki的請求地址等 創建一個Http請求幫助類以及方法，用於獲取指定URL的信息 使用http請求訪問指定url，先運行一下，看看返回的內容。內容如圖右邊所示，實際上是一個Json數據。我們主要解析 大事記 部 ...
  • .NET科普：.NET簡史、.NET Standard以及C#和.NET Framework之間的關係
    最近在不少自媒體上看到有關.NET與C#的資訊與評價，感覺大家對.NET與C#還是不太瞭解，尤其是對2016年6月發佈的跨平臺.NET Core 1.0，更是知之甚少。在考慮一番之後，還是決定寫點東西總結一下，也回顧一下.NET的發展歷史。 首先，你沒看錯，.NET是跨平臺的，可以在Windows、 ...
  • Nodify學習 二：添加節點
    Nodify學習 一：介紹與使用 - 可樂_加冰 - 博客園 (cnblogs.com) Nodify學習 二：添加節點 - 可樂_加冰 - 博客園 (cnblogs.com) 添加節點（nodes） 通過上一篇我們已經創建好了編輯器實例現在我們為編輯器添加一個節點 添加model和viewmode ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（上）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
  • C# 使用模式匹配的好處,因為好用所以推薦~
    類型檢查和轉換：當你需要檢查對象是否為特定類型，並且希望在同一時間內將其轉換為那個類型時，模式匹配提供了一種更簡潔的方式來完成這一任務，避免了使用傳統的as和is操作符後還需要進行額外的null檢查。 複雜條件邏輯：在處理複雜的條件邏輯時，特別是涉及到多個條件和類型的情況下，使用模式匹配可以使代碼更 ...
  • 推薦一種批量判斷文件是否存在的快速辦法
    在日常開發中，我們經常需要和文件打交道，特別是桌面開發，有時候就會需要載入大批量的文件，而且可能還會存在部分文件缺失的情況，那麼如何才能快速的判斷文件是否存在呢？如果處理不當的，且文件數量比較多的時候，可能會造成卡頓等情況，進而影響程式的使用體驗。今天就以一個簡單的小例子，簡述兩種不同的判斷文件是否... ...
  • 論如何直接用EF Core實現創建更新時間、用戶審計，自動化樂觀併發、軟刪除和樹形查詢（中）
    前言 資料庫併發，數據審計和軟刪除一直是數據持久化方面的經典問題。早些時候，這些工作需要手寫複雜的SQL或者通過存儲過程和觸發器實現。手寫複雜SQL對軟體可維護性構成了相當大的挑戰，隨著SQL字數的變多，用到的嵌套和複雜語法增加，可讀性和可維護性的難度是幾何級暴漲。因此如何在實現功能的同時控制這些S ...
所有分類