AOP-03

7.AOP-切入運算式

7.1切入運算式的具體使用

1.切入運算式的作用：

通過運算式的方式定義一個或多個具體的連接點，

2.語法細節：

（1）切入運算式的語法格式：

execution([權限修飾符] [回傳值型別] [簡單類名/全類名] [方法名]([引數串列])

若目標類、介面與該切面類在用同一個包中，可以省略包名，只寫簡單類名

（2）舉例說明：

例子1：

運算式：execution(* com.sina.spring.ArithmeticCalculator.*(..))

含義：ArithmeticCalculator.* ：介面中宣告的所有方法，第一個 * 代表任意修飾符和任意回傳值，第二個 * 代表任意方法，.. 代表匹配任意數量和任意型別的引數，若目標類、介面與該切面類在用同一個包中，可以省略包名，

例子2：

運算式：execution(public * ArithmeticCalculator.*(..))

含義：ArithmeticCalculator 介面中的所有公有方法

例子3：

運算式：execution(public double ArithmeticCalculator.*(..))

含義：ArithmeticCalculator 介面中回傳 double 型別數值的方法

例子4：

運算式：execution(public double ArithmeticCalculator.*(double, ..))

含義：第一個引數為double 型別的方法，.. 匹配任意數量、任意型別的引數，

例子5：

運算式：execution(public double ArithmeticCalculator.*(double, double))

含義：引數型別為double ，double 型別的方法，

（3）在AspectJ中，切入點運算式可以通過 && 或者 || 或者 ! 等運算子結合起來

例子：

運算式：execution(* *.add(int, ..))|| exexution(* *.sub(int, ..))

含義：任意類中第一個引數為 int 型別的 add 方法或 sub 方法

7.2注意事項和細節

切入運算式可以指向（實作了介面的）類的方法，這時切入運算式會對該類/物件生效
切入運算式也可以指向介面的方法，這時切入運算式會對實作了介面的類/物件生效
切入運算式可以對沒有實作介面的類進行切入，

這涉及到CGlib動態代理：動態代理jdk的Proxy與spring的CGlib
兩個動態代理的區別：
- JDK動態代理是面向介面的，只能增強實作類中介面中存在的方法，CGlib是面向父類的，可以增強父類的所有方法
- JDK得到的物件是JDK代理物件實體，而CGlib得到的物件是被代理物件的子類

靜態代理例子：

一個普通類Car：

package com.li.aop.hw;

import org.springframework.stereotype.Component;

/**
 * @author 李
 * @version 1.0
 */
@Component
public class Car {
    public void run() {
        System.out.println("小汽車在running...");
    }
}

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 {
    //CGlib
    //給沒有實作介面的一個普通類設定前置通知，其他通知亦可以設定
    @Before(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public void Car.run())")
    public void ok(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("MyAspect前置通知ok()-目標方法-" + methodName +
                " 引數-" + Arrays.toString(joinPoint.getArgs()));
    }
}

測驗類：

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");
        //carProxy是 被代理物件的子類
        Car carProxy = ioc.getBean(Car.class);
        System.out.println("carProxy的實際運行型別=" + carProxy.getClass());
        carProxy.run();
    }
}

測驗結果：

8.AOP-JoinPoint

在切面類的通知方法中，可以通過 JoinPoint物件獲取到目標方法的一系列資訊：

JoinPoint物件的方法	釋義
getSignature().getName()	獲取目標方法名
getSignature().getDeclaringType().getSimpleName()	獲取目標方法所屬類的簡單類名
getSignature().getDeclaringTypeName()	獲取目標方法所屬類的全類名
getSignature().getModifiers()	獲取目標方法宣告型別（public/private/protected）
getArgs()	獲取傳入目標方法的引數，回傳一個陣列
getTarget()	獲取被代理的物件
getThis()	獲取代理物件自己

9.AOP-回傳通知獲取結果

在回傳通知 @AfterReturning 中，可以獲取目標方法回傳的結果，

我們在 @AfterReturning （回傳通知）的注解原始碼中可以看到有一個returning屬性，通過 returning 屬性可以獲取目標方法執行完畢后，回傳的結果，

底層大概是：在反射執行目標方法時，將目標方法回傳的結果賦給 returning 的定義的變數，然后賦給切入方法同名的引數，

例子

必須在回傳通知中，才能獲取目標方法的回傳值
returning 屬性定義的變數，要和切入方法接收的引數名稱一致，

10.AOP-例外通知中獲取例外

在例外通知中，可以獲取目標方法出現例外的資訊

例外通知 @AfterThrowing 中有一個throwing 的屬性，它可以接收例外資訊

例子

11.AOP-環繞通知

環繞通知可以完成其他四個通知要做的事情（了解即可）

以AOP-02-6.2 快速入門為例子

介面為 SmartAnimal.java，實作類為 SmartDog.java

切面類為 SmartAnimalAspect2.java：

package com.li.aop.aspectj;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;


import java.util.Arrays;
import java.util.List;

/**
 * @author 李
 * @version 1.0
 * 切面類-這里主要演示環繞通知
 */
@Aspect
@Component
public class SmartAnimalAspect2 {

    //環繞通知
    /**
     * 1.@Around 表示環繞通知，它可以完成其他四個通知的功能
     * 2.value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(...)" 切入運算式
     * 3.doAround() 表示要切入的方法，呼叫結構為 try-catch-finally
     *
     * @param joinPoint 如果是環繞通知，需要用到 ProceedingJoinPoint
     * @return
     */
    @Around(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        Object result = null;
        String methodName = joinPoint.getSignature().getName();
        try {

            //1.相當于前置通知完成的事情
            Object[] args = joinPoint.getArgs();
            List<Object> argList = Arrays.asList(args);
            System.out.println("AOP 環繞通知 " + methodName + "方法開始了--引數有：" + argList);

            //在環繞通知中一定要呼叫 joinPoint.proceed()來執行目標方法
            result = joinPoint.proceed();

            //2.相當于回傳通知完成的事情
            System.out.println("AOP 環繞通知 " + methodName + "方法結束了--結果是：" + result);

        } catch (Throwable throwable) {

            //3.相當于例外通知完成的事情
            System.out.println("AOP 環繞通知 " + methodName + "方法拋例外了--例外物件：" + throwable);
        } finally {

            //4.相當于最終通知完成的事情
            System.out.println("AOP 環繞通知 " + methodName + "方法最終結束了...");
        }
        return result;
    }

}

測驗方法：

@Test
public void testDoAround(){
    //得到ioc容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans07.xml");
    //獲取代理物件
    SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);
    //執行方法
    smartAnimal.getSum(99,88);
}

測驗結果：

12.AOP-切入點運算式重用

切入點運算式重用

為了統一管理切入點運算式，可以使用切入點運算式重用/復用技術，

以AOP-02-6.2 快速入門為例子

介面為 SmartAnimal.java，實作類為 SmartDog.java

切面類為 SmartAnimalAspect.java：

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
 * 切面類
 */
@Aspect 
@Component
public class SmartAnimalAspect {

    //定義一個切入點，在后面使用時可以直接參考，提高復用性
    @Pointcut(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
    public void myPointCut() {

    }

    //前置通知
    //@Before(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
    //這里我們使用定義好的切入點
    @Before(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()")
    public void f1(JoinPoint joinPoint) {
        //通過連接點物件joinPoint 拿到方法簽名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f1()-方法執行開始-日志-方法名-" + signature.getName() +
                "-引數 " + Arrays.toString(joinPoint.getArgs()));
    }

    //回傳通知
    //@AfterReturning(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", returning = "res")
    @AfterReturning(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()", returning = "res")
    public void f2(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f2()-方法執行正常結束-日志-方法名-" + signature.getName());
        System.out.println("目標方法回傳的結果=" + res);
    }

    //例外通知
    //@AfterThrowing(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", throwing = "throwable")
    @AfterThrowing(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()", throwing = "throwable")
    public void f3(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f3()-方法執行例外-日志-方法名-" + signature.getName() + "例外資訊-" + throwable);
    }

    //最終通知
    //@After(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
    @After(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()")
    public void f4(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類f4()-方法最終執行完畢-日志-方法名-" + signature.getName());
    }

}

測驗：

@Test
public void test(){
    //得到ioc容器
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans07.xml");
    //獲取代理物件
    SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);
    //執行方法
    smartAnimal.getSum(99,88);
}

測驗結果：

13.AOP-切面優先級問題

如果同一個方法，有多個切面在同一個切入點切入，那么執行的優先級如何控制？

答：在切面類宣告時，使用@Order注解控制優先級：n值越小，優先級越高

@Order(value=https://www.cnblogs.com/liyuelian/archive/2023/01/26/n) //n值越小，優先級越高

例子-以AOP-02-6.2 快速入門為例子

介面為 SmartAnimal.java，實作類為 SmartDog.java，兩個切面類： SmartAnimalAspect.java 和 SmartAnimalAspect2.java

SmartAnimalAspect.java：

package com.li.aop.aspectj;

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

import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 切面類1
 */
@Aspect 
@Component 
@Order(value = https://www.cnblogs.com/liyuelian/archive/2023/01/26/2)//表示該切面類執行的順序，value越小，優先級越高
public class SmartAnimalAspect {

    //定義一個切入點，在后面使用時可以直接參考，提高復用性
    @Pointcut(value ="https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
    public void myPointCut() {

    }

    //前置通知
    @Before(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()")
    public void f1(JoinPoint joinPoint) {
        //通過連接點物件joinPoint 拿到方法簽名
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類1-f1()-方法執行開始-日志-方法名-" + signature.getName() +
                "-引數 " + Arrays.toString(joinPoint.getArgs()));
    }

    //回傳通知
    @AfterReturning(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()", returning = "res")
    public void f2(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類1-f2()-方法執行正常結束-日志-方法名-" + signature.getName() + " 目標方法回傳的結果=" + res);
    }

    //例外通知
    @AfterThrowing(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()", throwing = "throwable")
    public void f3(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類1-f3()-方法執行例外-日志-方法名-" + signature.getName() + "例外資訊-" + throwable);
    }

    //最終通知
    @After(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/myPointCut()")
    public void f4(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類1-f4()-方法最終執行完畢-日志-方法名-" + signature.getName());
    }

}

SmartAnimalAspect2.java：

package com.li.aop.aspectj;

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

import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 切面類 2
 */
@Aspect
@Component
@Order(value = https://www.cnblogs.com/liyuelian/archive/2023/01/26/1)
public class SmartAnimalAspect2 {

    @Before(value ="https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
    public void f1(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類2-f1()-方法執行開始-日志-方法名-" + signature.getName() +
                "-引數 " + Arrays.toString(joinPoint.getArgs()));
    }

    //回傳通知：
    @AfterReturning(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", returning = "res")
    public void f2(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類2-f2()-方法執行正常結束-日志-方法名-" + signature.getName() + " 目標方法回傳的結果=" + res);
    }

    //例外通知：
    @AfterThrowing(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))", throwing = "throwable")
    public void f3(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類2-f3()-方法執行例外-日志-方法名-" + signature.getName() + "例外資訊-" + throwable);
    }

    //最終通知：
    @After(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public float com.li.aop.aspectj.SmartDog.*(float, float))")
    public void f4(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("切面類2-f4()-方法最終執行完畢-日志-方法名-" + signature.getName());
    }

}

測驗方法：

@Test
public void smartDogTestByAspectj() {
    //得到Spring容器
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("beans07.xml");
    //通過介面型別來獲得注入的SmartDog物件（實際上是代理物件proxy）
    SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);
    smartAnimal.getSum(100, 48);
}

測驗結果：

注意事項和細節：

不能理解成：優先級高的切面類，每個訊息通知都先執行，

真實的執行順序和 Filter 過濾器鏈式呼叫類似：

14.基于XML配置AOP

前面我們都是通過注解來配置aop的，在spring中，同樣支持通過xml的方式來配置aop

例子

1.SmartAnimal 介面：

package com.li.aop.xml;

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

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

2.SmartDog 實作類：

package com.li.aop.xml;

/**
 * @author 李
 * @version 1.0
 */
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;
    }
}

3.SmartAnimalAspect 切面類：

package com.li.aop.xml;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;

import java.util.Arrays;

/**
 * @author 李
 * @version 1.0
 * 這是一個切面類，使用xml的方法配置
 */
public class SmartAnimalAspect {

    public void showBeginLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("xml-showBeginLog()-方法執行開始-日志-方法名-" + signature.getName() +
                "-引數 " + Arrays.toString(joinPoint.getArgs()));
    }

    public void showSuccessEndLog(JoinPoint joinPoint, Object res) {
        Signature signature = joinPoint.getSignature();
        System.out.println("xml-showSuccessEndLog()-方法執行正常結束-日志-方法名-" + signature.getName() + " 目標方法回傳的結果=" + res);
    }

    public void showExceptionLog(JoinPoint joinPoint, Throwable throwable) {
        Signature signature = joinPoint.getSignature();
        System.out.println("xml-showExceptionLog()-方法執行例外-日志-方法名-" + signature.getName() + "例外資訊-" + throwable);
    }

    public void showFinallyEndLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println("xml-showFinallyEndLog()-方法最終執行完畢-日志-方法名-" + signature.getName());
    }

}

4.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: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/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--使用xml配置完成aop編程-->

    <!--配置一個切面類物件 bean-->
    <bean  id="smartAnimalAspect"/>

    <!--配置一個SmartDog物件-->
    <bean  id="smartDog"/>

    <!--配置切面類 (注意要引入aop名稱空間)-->
    <aop:config>
        <!--先配置切入點-->
        <aop:pointcut id="myPointCut" expression="execution(public float com.li.aop.xml.SmartDog.*(float, float))"/>
        <!--配置切面的前置/回傳/例外/最終通知-->
        <aop:aspect ref="smartAnimalAspect" order="10">
            <!--配置前置通知-->
            <aop:before method="showBeginLog" pointcut-ref="myPointCut"/>
            <!--配置回傳通知-->
            <aop:after-returning method="showSuccessEndLog" pointcut-ref="myPointCut" returning="res"/>
            <!--配置例外通知-->
            <aop:after-throwing method="showExceptionLog" pointcut-ref="myPointCut" throwing="throwable"/>
            <!--最終通知-->
            <aop:after method="showFinallyEndLog" pointcut-ref="myPointCut"/>
            <!--還可以配置環繞通知...-->
        </aop:aspect>
    </aop:config>

</beans>

5.測驗類：

package com.li.aop.xml;

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

/**
 * @author 李
 * @version 1.0
 * 測驗類
 */
public class AopAspectjXMLTest {
    @Test
    public void testAspectjByXML() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("beans09.xml");
        SmartAnimal smartAnimalProxy = ioc.getBean(SmartAnimal.class);

        smartAnimalProxy.getSum(1000, 888);
    }
}

測驗結果：

15.aop練習

請撰寫一個Cal介面，該介面有兩個方法：
- cal1(int n)，計算1 + 2 + ... + n
- cal2(int n)，計算1 * 2 *... * n
Cal 實作類為 MyCal
請分別使用注解方式和xml配置的方式，完成aop編程
- 在執行 cal2 前列印開始執行的時間，在執行完后列印時間
- 在執行 cal2 前列印開始執行的時間，在執行完后列印時間

（1）xml配置的方式：

Cal：

package com.li.aop.hw2;

/**
 * @author 李
 * @version 1.0
 */
public interface Cal {
    //累加
    public void cal1(int n);

    //累乘
    public void cal2(int n);
}

MyCal：

package com.li.aop.hw2;

/**
 * @author 李
 * @version 1.0
 */
public class MyCal implements Cal {

    @Override
    public void cal1(int n) {
        int result = 0;
        if (n >= 1) {
            for (int i = 0; i <= n; i++) {
                result += i;
            }
            System.out.println("cal1-result=" + result);
            return;
        }
        System.out.println("cal1-引數有誤");
    }

    @Override
    public void cal2(int n) {
        int result = 1;
        if (n >= 1) {
            for (int i = 1; i <= n; i++) {
                result *= i;
            }
            System.out.println("cal2-result=" + result);
            return;
        }
        System.out.println("cal2-引數有誤");
    }
}

切面類：

package com.li.aop.hw2;

/**
 * @author 李
 * @version 1.0
 * 切面類
 */
public class CalAspect {
    //前置通知
    public void beforeTime() {
        System.out.println("開始執行計算 "+System.currentTimeMillis());
    }

    //回傳通知
    public void returningTime() {
        System.out.println("結束執行計算 "+System.currentTimeMillis());
    }
}

xml容器組態檔：

<!--配置實作類物件bean-->
<bean  id="myCal"/>
<!--配置切面類物件bean-->
<bean  id="calAspect"/>
<aop:config>
    <!--配置切入點運算式-->
    <aop:pointcut id="myPointCut" expression="execution(public void com.li.aop.hw2.MyCal.*(int))"/>
    <!--配置切面類-->
    <aop:aspect ref="calAspect">
        <!--前置通知-->
        <aop:before method="beforeTime" pointcut-ref="myPointCut"/>
        <!--回傳通知-->
        <aop:after-returning method="returningTime" pointcut-ref="myPointCut"/>
    </aop:aspect>
</aop:config>

測驗方法：

@Test
public void myCalTest() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans10.xml");
    //因為這里只有一個實作物件，因此用型別獲取
    Cal myCalProxy = ioc.getBean(Cal.class);

    myCalProxy.cal1(200);
    System.out.println("===============");
    myCalProxy.cal2(5);
}

測驗結果：

（2）基于注解的配置方式

Cal 介面不變，在MyCal 實作類上添加 @Component 注解：

@Component
public class MyCal implements Cal {...}

切面類：

package com.li.aop.hw2;

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

/**
 * @author 李
 * @version 1.0
 * 切面類
 */
@Component
@Aspect
public class CalAspect {
    //前置通知
    //如果切面類和目標類在同一個包，可以省略包名
    @Before(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public void com.li.aop.hw2.Cal.*(int))")
    public void beforeTime(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println(signature.getName() + " 開始時間: " + System.currentTimeMillis());
    }

    //回傳通知
    @AfterReturning(value = "https://www.cnblogs.com/liyuelian/archive/2023/01/26/execution(public void com.li.aop.hw2.Cal.*(int))")
    public void returningTime(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        System.out.println(signature.getName() + " 結束時間: " + System.currentTimeMillis());
    }
}

xml容器組態檔：

<!--配置要掃描的包-->
<context:component-scan base-package="com.li.aop.hw2"/>
<!--開啟基于注解的aop功能-->
<aop:aspectj-autoproxy/>

測驗方法不變：

@Test
public void myCalTest() {
    ApplicationContext ioc = new ClassPathXmlApplicationContext("beans10.xml");
    //因為這里只有一個實作物件，因此用型別獲取
    //又因為是代理物件，因此使用介面型別獲取
    Cal myCalProxy = ioc.getBean(Cal.class);

    myCalProxy.cal1(200);
    System.out.println("===============");
    myCalProxy.cal2(5);
}

測驗結果：

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/542418.html

標籤：其他

上一篇：用狀態機實作通用多位元組SPI介面模塊

下一篇：C++Day12 虛擬繼承記憶體布局測驗

day10-AOP-03

AOP-03

7.AOP-切入運算式

7.1切入運算式的具體使用

7.2注意事項和細節

8.AOP-JoinPoint

9.AOP-回傳通知獲取結果

10.AOP-例外通知中獲取例外

11.AOP-環繞通知

12.AOP-切入點運算式重用

13.AOP-切面優先級問題

14.基于XML配置AOP

15.aop練習