Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂）

2024-01-07 19:44
文章标签 java 类型 详解 spring 表达式 万字 通知 aop 通俗易懂 切入点

本文主要是介绍Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

一、前言

二、AOP—快速入门

        1.动态代理优化 : 

        2.问题分析 : 

        3.AOP—基本介绍 : 

        4.AOP—使用说明 : 

        5.AOP—入门案例 : 

三、AOP—切入点表达式

        1.基本说明 : 

        2.语法格式 : 

        3.注意事项 : 

        4.代码演示 : 

四、AOP—切入点表达式的更多细节

        1.JoinPoint : 

            1.1 简介 

            1.2 方法 

            1.3 演示

        2.通知进阶 : 

            2.1 通过@AfterReturning获取方法的返回结果

            2.2 通过@AfterThrowing获取异常信息

            2.3 环绕通知

        3.切入点表达式重用(@Pointcut) : 

            3.1 简介

            3.2 实例

        4.切面类执行顺序 : 

            4.1 简介

            4.2 实例

        5.基于XML配置AOP : 

五、总结

一、前言

  • 第五节内容，up主要和大家分享一下Spring AOP方面的内容；包括通知类型，切入表达式 和 基于XML配置AOP。
  • 注意事项——①代码中的注释也很重要；②不要眼高手低，自己跟着敲一遍才真正有收获；③点击文章的侧边栏目录或者文章开头的目录可以进行跳转。
  • 良工不示人以朴，up所有文章都会适时补充完善。大家如果有问题都可以在评论区进行交流或者私信up。感谢阅读！

二、AOP—快速入门

        1.动态代理优化 : 

                “书接上回”，在动态代理一文最后，我们提出一个问题——假如将匿名内部类实现的invoke方法中的输出语句，都替换成方法，用一个方法直接切入，那不就既满足灵活性，又可以实现强大的功能吗？

                那现在我们就来尝试一个简单的案例，我们自己定义一个简单的AOP类，并在该类中定义用于切入的静态方法（这么做可以达到降低耦合度的目的，而不是直接把方法定义在提供代理对象的类中）；up以CyanAOP类为例，CyanAOP类代码如下 : 

package com.cyan.spring.aop;import java.lang.reflect.Method;
import java.time.LocalDateTime;public class CyanAOP {//1. beforeNotice静态方法用于完成前置通知public static void beforeNotice(Method method, Object[] args) {//获取到当前传入的参数double n1 = (double) args[0];double n2 = (double) args[1];//获取当前方法名String name = method.getName();//Δ在运算方法执行前打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",传入两个参数分别是 " + n1 + " 和 " + n2);}//2. returnNotice静态方法用于完成返回通知public static void returnNotice(Method method, Object result) {//获取当前方法名String name = method.getName();//Δ在运算方法执行后打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",运算结果 = " + result);}//3.exceptionNotice静态方法用于完成异常通知public static void exceptionNotice(Method method) {System.out.println("异常日志————" + LocalDateTime.now() + ",方法" + method.getName() + "执行异常");}//4.afterNotice静态方法用于完成后置通知public static void afterNotice(Method method) {System.out.println("执行日志————" + method.getName() + "方法执行结束。");}
}

                接着，在CalculatorProxyProvider类中调用CyanAOP类中的静态方法，取代原有的输出语句；
                CalculatorProxyProvider类代码如下 : 

package com.cyan.spring.aop;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class CalculatorProxyProvider {private Calculator calculator;public CalculatorProxyProvider(Calculator calculator) {this.calculator = calculator;}/*底层仍然使用java.lang.reflect包下的Proxy类的newProxyInstance方法来获取代理对象。*/public Calculator getCalculatorProxy() {//1.获取newProxyInstance方法的第一个参数————类加载器ClassLoader classLoader = calculator.getClass().getClassLoader();//2.获取newProxyInstance方法的第二个参数————接口信息Class<?>[] interfaces = calculator.getClass().getInterfaces();//3.获取newProxyInstance方法的第三个参数————处理器对象//仍然借助匿名内部类来实现，并通过构造接口多态的形式做接收。InvocationHandler invocationHandler = new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//定义运算结果double result = 0.0;try {//Δ调用CyanAOP中的静态方法，实现前置通知CyanAOP.beforeNotice(method, args);//执行运算result = (double) method.invoke(calculator, args);System.out.println("result = " + result);//Δ调用CyanAOP中的静态方法，实现返回通知CyanAOP.returnNotice(method, result);//返回运算结果return result;} catch (Exception e) {//Δ调用CyanAOP中的静态方法，实现异常通知CyanAOP.exceptionNotice(method);throw new RuntimeException(e);} finally {//Δ调用CyanAOP中的静态方法，实现后置通知CyanAOP.afterNotice(method);}}};//4.调用newProxyInstance方法，得到代理对象Calculator instance = (Calculator) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);//5.返回获得的代理对象return instance;}
}

                然后，在测试类中运行单元测试方法，测试动态代理是否生效，测试类TestCalculator代码如下 : 

package com.cyan.spring.aop;import org.junit.jupiter.api.Test;public class TestCalculator {@Testpublic void testArithmetic() {//1.构造接口多态Calculator calculator = new Calculator_Demo1();//2.传入需要被代理的对象CalculatorProxyProvider calculatorProxyProvider = new CalculatorProxyProvider(calculator);//3.获取代理对象Calculator calculatorProxy = calculatorProxyProvider.getCalculatorProxy();//4.通过代理对象调用实现类方法double addResult = calculatorProxy.add(200.333, 33);System.out.println("-----------------------------");double subtractResult = calculatorProxy.subtract(141, 5);System.out.println("-----------------------------");//double multiplyResult = calculatorProxy.multiply(11.11, 2);//System.out.println("-----------------------------");//double divideResult = calculatorProxy.divide(3917.0, 500.00);}
}

                运行结果 : 

        2.问题分析 : 

        上文中我们通过自定义简单的AOP类，成功用较为灵活的“方法” 替换了 非常死板的“输出语句”。但是，新的问题出现了—— 这种改进方式依然不够灵活，功能依然弱鸡，并且复用性也比较差。

        新的问题体现在哪里呢？

        (1) 当前方案下，比如我们在测试类中调用了add方法和subtract方法，这俩个方法都受到了CyanAOP类中的静态方法的影响，但是，假如我们此时仅希望针对于add方法的控制，显然当前方案是做不到的。即，我们无法针对于某个或某些指定的方法进行控制，不够灵活。

        (2) 当前方案下，CyanAOP类中定义的静态方法只是适用于Calculator接口和它的实现类；假如up此时又定义了其他的接口，那么CyanAOP类中定义的静态方法便无法满足新的需求。即，我们无法对于其他接口及其实现类进行切入控制，代码复用性差。

        (3) 我们要明白，之所以存在以上问题，是由于当前方案缺少 “注解 + 反射机制” 的支持。 

        3.AOP—基本介绍 : 

        AOP : Aspect Oriented Programming，即面向切面编程。

                我们知道，在传统的OOP中，某个类所定义的成员方法，只能被该类对象或该类的子类对象所调用；即我们先通过new关键字创建一个对象，亦可构成多态，然后通过 "对象." 的形式来调用类中的方法。

                但是在AOP，我们是通过 “动态代理 + 反射” 的形式来调用类中的方法，那么类中的方法在执行过程中会被分为多个横切关注点，包括前置通知，返回通知，异常通知，后置通知。我们可以定义切面类，切面类中定义了用于切入的方法，通过注解配置，这些方法可以切入到任意支持AOP的类的任意方法的横切关注点。如下图所示 : 

        4.AOP—使用说明 : 

        (1) 要想使用Spring 的AOP注解，需要导入以下几个jar包，如下图所示 :

        此外，需要引入核心aspects.jar包，如下图所示 : （在Spring安装目录的libs目录下可以找到）

        (2) 常用的用于声明通知方法的五大注解如下——

                1> @Before : 前置通知；

                2> @AfterReturning : 返回通知；

                3> @AfterThrowing : 异常通知；

                4> @After : 后置通知；

                5> @Around : 环绕通知[可以将四个通知合并管理]；

                官方文档的解释如下 : (Spring Framework 6.1.2)

        5.AOP—入门案例 : 

                需求 : 定义切面类CalculatorAspect，并在切面类中定义两个方法，利用通知注解， 将这两个方法分别切入到Calculator_Demo1类的add方法执行之前 和 执行之后，即分别作为前置通知 和 返回通知。PS : 需要在xml配置文件中配置注解扫描。

                up先在aop.aspectJ包下拷贝/创建 这么几个类，如下图所示 : 

                Calculator接口代码如下 : 

package com.cyan.spring.aop.aspectJ;/*** @author : Cyan_RA9* @version : 21.0*/
public interface Calculator {public abstract double add(double n1, double n2);public abstract double subtract(double n1, double n2);public abstract double multiply(double n1, double n2);public abstract double divide(double n1, double n2);
}

                Calculator_Demo1类代码如下 : 

package com.cyan.spring.aop.aspectJ;import org.springframework.stereotype.Component;@Component(value = "calculator01")
public class Calculator_Demo1 implements Calculator {@Overridepublic double add(double n1, double n2) {double result = n1 + n2;System.out.println("result = " + result);return result;}@Overridepublic double subtract(double n1, double n2) {double result = n1 - n2;System.out.println("result = " + result);return result;}@Overridepublic double multiply(double n1, double n2) {double result = n1 * n2;System.out.println("result = " + result);return result;}@Overridepublic double divide(double n1, double n2) {double result = -1;if (n2 != 0) {  //分母不允许为0result = n1 / n2;}System.out.println("result = " + result);return result;}
}

                切面类CalculatorAspect代码如下 : (注意看代码注释)

package com.cyan.spring.aop.aspectJ;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;/*** 切面类 : CalculatorAspect*/
@Aspect //Aspect注解提供了底层切面编程的支撑
@Component  //Component注解表示该类是一个组件
public class CalculatorAspect {/*(1) 通过配置@Before注解，将beforeAdvice方法切入到Calculator_Demo1的add方法执行之前，作为前置通知。(2) value = "execution(access_modifier return_type 全类名.方法名(形参声明))",表示将该方法切入到指定类的指定方法（注意方法重载）。(3) beforeAdvice方法即实际起作用的切入方法，其方法名不是唯一的，可以自行定义。(4) 切入方法的形参是JointPoint类对象，是AspectJ 切面框架在底层将相关参数打包成JointPoint传入的。(5) 此时的切面类相当于一个功能更加强大的CalculatorProxyProvider类。*/@Before(value = "execution(public double com.cyan.spring.aop.aspectJ.Calculator_Demo1.add(double, double))")public void beforeAdvice(JoinPoint joinPoint) {//1.通过连接点对象，得到方法参数Object[] args = joinPoint.getArgs();double n1 = (double) args[0];double n2 = (double) args[1];//2.通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//3.通过方法签名对象，获取到方法名String name = signature.getName();//Δ在运算方法执行前打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",传入两个参数分别是 " + n1 + " 和 " + n2);}//returnAdvice方法，作为返回通知@AfterReturning(value = "execution(public double com.cyan.spring.aop.aspectJ.Calculator_Demo1.add(double, double))")public void returnAdvice(JoinPoint joinPoint) {//通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//通过方法签名对象，获取到方法名String name = signature.getName();//获得方法参数Object[] args = joinPoint.getArgs();double result = (double) args[0] + (double) args[1];//Δ在运算方法执行后打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",运算结果 = " + result);}//afterAdvice方法，作为后置通知@After(value = "execution(public double com.cyan.spring.aop.aspectJ.Calculator_Demo1.add(double, double))")public void afterAdvice(JoinPoint joinPoint) {//通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//通过方法签名对象，获取到方法名String name = signature.getName();//Δ在运算方法最终执行完毕后打印出执行日志System.out.println("执行日志————" + name + "方法执行结束。");}
}

                为了获取到bean对象，我们需要在xml配置文件中配置基于注解的组件扫描。up以beans_aop.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.cyan.spring.aop.aspectJ"/><!-- 开启基于注解的AOP功能，若不开启，不能实现切入[动态代理 + 反射调用] --><aop:aspectj-autoproxy/>
</beans>

                接着，我们仍在该包下定义一个测试类TestAspectJ，测试切面类中的方法是否成功切入到指定位置，TestAspectJ类代码如下 : 

package com.cyan.spring.aop.aspectJ;import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;/*** @author : Cyan_RA9* @version : 21.0*/
public class TestAspectJ {@Testpublic void testBeforeAdvice() {//1.获取IOC容器对象ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_aop.xml");//2.通过接口类型来获取bean对象(实际获得的是代理对象，因此不能用实现类作为接收)//亦可以通过id来获取代理对象，同样需要使用接口类型来作接收Calculator calculator = ioc.getBean(Calculator.class);System.out.println("calculator = " + calculator);System.out.println("calculator's class = " + calculator.getClass());System.out.println("================================================");//3.通过得到的代理对象执行实现类中的方法calculator.add(133.22, 141.78);System.out.println("================================================");//4.调用其他方法，不会触发通知calculator.subtract(500, 41);}
}

                运行结果 :  

三、AOP—切入点表达式

        1.基本说明 : 

        实际上，我们在上文 “AOP—入门案例” 中所用到的 “execution(public double com.cyan.spring.aop.aspectJ.Calculator_Demo1.add(double, double))” 就是一个切入点表达式。
        其作用是——通过表达式的方式定位一个或多个具体的的连接点。

        2.语法格式 : 

        (1) "execution(access_modifier return_type 全类名 方法名(形参列表))"

        (2) Spring AOP的切入点表达式非常灵活，支持模糊配置。

        eg1 : execution(* 全类名.*(..))——第一个 "*" 表示支持任意修饰符及返回值类型；第二个 "*" 表示支持该类中的任意方法；形参列表中的".."则表示可以匹配任意数量和类型的参数。(PS : 若目标类、接口与当前切面类在同一个包下，可以省略包名，只写类名)

        eg2 : execution(public * 全类名.*(..))——表示支持该类中的所有公有的方法

        eg3 : execution(public double 全类名.*(..))——表示支持该类中所有公有的且返回值为double的方法

        eg4 : execution(public double 全类名.*(double, ..))——表示支持该类中所有形参列表第一个参数为double类型，且后续参数可以是任意数量任意类型的，公有的返回值为double的方法。

        eg5 : execution(double 全类名.*(double, double)——表示支持该类中所有形参列表为两个double类型，公有的且返回值为double类型的方法。

        (3) 在AspectJ中，切入点表达式可以通过"&&"，"||"，"!"等操作符结合起来。

        eg : execution(* *.add(int, ..)) || execution(* *.subtract(int, ..))——表示支持任意类中的任意访问修饰符和任意返回值类型的，且形参列表第一个参数为int类型的add 或 subtract方法。

        3.注意事项 : 

        (1) 当切入点表达式直接指向了接口某个实现类的方法（非实现类特有方法），这时切入点表达式仅会对该实现类生效（动态代理 + 反射），即接口的其他实现类不会生效（不会得到代理对象，即使你以接口类型作为接收）。

        (2) 当切入点表达式指向接口的方法时，切入表达式会对该接口的所有实现类生效。

        (3) 切入点表达式也可以切入到没有实现接口的类的横切关注点中。(CGlib动态代理模式)

        PS : JDK Proxy动态代理和CGlib动态代理的区别——

        JDK动态代理是面向接口的，只能增强实现类中重写了接口中的方法。而CGlib是面向父类的，可以增强父类的所有方法。

        JDK得到的对象是JDK代理对象实例，而CGlib得到的对象是被代理对象的子类。

        4.代码演示 : 

                先来演示"注意事项"中的第一点，up新定义一个Calculator接口的实现类Calculator_Demo2类，代码如下 : （用@Component注解标记为组件，且给出了自定义的id值 = calculator02）

package com.cyan.spring.aop.aspectJ;import org.springframework.stereotype.Component;/*** @author : Cyan_RA9* @version : 21.0*/
@Component(value = "calculator02")
public class Calculator_Demo2 implements Calculator{@Overridepublic double add(double n1, double n2) {System.out.println("Calculator_Demo2");return 0;}@Overridepublic double subtract(double n1, double n2) {System.out.println("Calculator_Demo2");return 0;}@Overridepublic double multiply(double n1, double n2) {System.out.println("Calculator_Demo2");return 0;}@Overridepublic double divide(double n1, double n2) {System.out.println("Calculator_Demo2");return 0;}
}

                切面类保持不变，即配置的切入表达式仍然直接指向了Calculator_Demo1类。
                接着，up定义一个测试方法，代码如下 : 

    @Testpublic void testImplementationClass() {ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_aop.xml");Calculator calculator01 = (Calculator) ioc.getBean("calculator01");Calculator calculator02 = (Calculator) ioc.getBean("calculator02");System.out.println("calculator01's class = " + calculator01.getClass());System.out.println("calculator02's class = " + calculator02.getClass());calculator01.add(2121, 212);System.out.println("===========================");calculator02.add(11, 635);}

                运行结果 : 

                可以看到，只有Calculator_Demo1类成功得到了代理对象，且配置的切入点表达式也执行成功，而Calculator_Demo2类却仍然只是一个实现类对象。

                注意，这时候，up将切面类中原来的@Before前置通知的代码注释掉，重新定义一个@Before前置通知，令切入表达式指向Calculator接口，代码如下 : 

    //配置到接口上@Before(value = "execution(public double com.cyan.spring.aop.aspectJ.Calculator.add(double, double))")public void beforeAdvice(JoinPoint joinPoint) {//1.通过连接点对象，得到方法参数Object[] args = joinPoint.getArgs();double n1 = (double) args[0];double n2 = (double) args[1];//2.通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//3.通过方法签名对象，获取到方法名String name = signature.getName();//Δ在运算方法执行前打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",传入两个参数分别是 " + n1 + " 和 " + n2);}

                这时，再次运行刚才的测试方法，会发现Calculator_Demo1类和Calculator_Demo2类都可以成功获得代理对象，并且配置的@Before前置通知也成功执行，运行结果如下图所示 : 

                最后来演示一下注意事项3——即CGlib动态代理的使用。
                up新定义一个Cat类，代码如下 : 

package com.cyan.spring.aop.aspectJ;import org.springframework.stereotype.Component;@Component(value = "cat01")
public class Cat {public void eat() {System.out.println("Cat love to eat meat.");}
}

                然后，再新定义一个切面类，CatAspect类代码如下 : 

package com.cyan.spring.aop.aspectJ;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class CatAspect {@Before(value = "execution(public * Cat.*(..))")public void beforeEat(JoinPoint joinPoint) {System.out.println("猫猫吃饭前也要洗手捏~");}
}

                最后，再定义一个简单的测试类，测试CGlib动态代理是否生效，CatTest类代码如下 : 

package com.cyan.spring.aop.aspectJ;import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class CatTest {@Testpublic void testCGlib() {ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_aop.xml");Cat cat01 = (Cat) ioc.getBean("cat01");System.out.println("cat01's class = " + cat01.getClass());cat01.eat();}
}

                运行结果 : 

                可以看到，切面类中定义的前置通知成功执行！

四、AOP—切入点表达式的更多细节

        1.JoinPoint : 

            1.1 简介 

        JoinPoint，即连接点对象，通过该对象可以获取到调用的Method的签名，即方法签名对象Signature。

            1.2 方法 

        //(1) 获取方法名
        joinPoint.getSignature().getName();
        //(2) 获取简单类名
        joinPoint.getSignature().getDeclaringType().getSimpleName();
        //(3) 获取全类名
        joinPoint.getSignature().getDeclaringTypeName();
        //(4) 获取访问权限修饰符（int类型）
        joinPoint.getSignature().getModifiers();
        //(5) 获取方法的参数，用数组作接收。
        Object[] args = joinPoint.getArgs();
        //(6) 获取被代理的对象
        joinPoint.getTarget();
        //(7) 获取代理对象本身
        joinPoint.getThis();

            1.3 演示

                我们就在刚才的CatAspect中测试这些方法，CatAspect类代码如下 : 

package com.cyan.spring.aop.aspectJ;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;@Aspect
@Component
public class CatAspect {@Before(value = "execution(public * Cat.*(..))")public void beforeEat(JoinPoint joinPoint) {System.out.println("猫猫吃饭前也要洗手捏~");String name = joinPoint.getSignature().getName();String simpleName = joinPoint.getSignature().getDeclaringType().getSimpleName();String declaringTypeName = joinPoint.getSignature().getDeclaringTypeName();int modifiers = joinPoint.getSignature().getModifiers();Object[] args = joinPoint.getArgs();Object target = joinPoint.getTarget();Object aThis = joinPoint.getThis();System.out.println("-----------------------------------------------");System.out.println("name = " + name);System.out.println("simpleName = " + simpleName);System.out.println("declaringTypeName = " + declaringTypeName);System.out.println("modifiers = " + modifiers);System.out.println("args = " + args);System.out.println("target = " + target);System.out.println("aThis = " + aThis.getClass());System.out.println("-----------------------------------------------");}
}

                运行结果 : 

        2.通知进阶 : 

            2.1 通过@AfterReturning获取方法的返回结果

        在使用@AfterReturning注解配置“返回通知”时，可以在配置切入点表达式后，额外通过returning = "表示返回结果的变量"来定义方法的返回结果，但需要在切入方法的形参列表中，同时也额外定义一个相同名称的变量。如下图所示 : 

                我们可以定义一个单元测试方法，测试方法的返回结果是否成功传递到了result变量中，代码如下 : 

    //返回通知获取方法的运行结果@Testpublic void testReturningResult() {ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_aop.xml");Calculator calculator = ioc.getBean("calculator01", Calculator.class);System.out.println("calculator's class = " + calculator.getClass());calculator.add(11.5, 141);}

                运行结果 : 

            2.2 通过@AfterThrowing获取异常信息

        在使用@AfterThrowing注解配置“返回通知”时，可以在配置切入点表达式后，额外通过throwing= "表示异常信息的变量"来定义方法的异常信息，但需要在切入方法的形参列表中，同时也额外定义一个相同名称的变量（注意变量的类型）。如下图所示 : 

                我们可以在Calculator_Demo2类的add方法中，故意制造一个算术异常，如下图所示 : 

                然后，定义一个单元测试方法，测试“异常通知”是否成功获取了异常信息。代码如下 : 

    //异常通知获取方法的异常信息@Testpublic void testExceptionInfo() {ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_aop.xml");Calculator calculator = ioc.getBean("calculator02", Calculator.class);System.out.println("calculator's class = " + calculator.getClass());calculator.add(11.5, 141);}

                运行结果 :  

            2.3 环绕通知

        环绕通知可以将四个通知合并管理，它可以完成其他四个通知的功能（前置通知，返回通知，异常通知，后置通知）。

                我们新定义一个切面类CalculatorAspect_EX，用于配置环绕通知；为了防止之前配置的其他通知对测试结果造成干扰，up把之前定义的切面类CalculatorAspect类先给注释掉了。
                CalculatorAspect_EX类代码如下 : 

package com.cyan.spring.aop.aspectJ;import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;/*** 切面类 : CalculatorAspect_EX*/
@Aspect //Aspect注解提供了底层切面编程的支撑
@Component  //Component注解表示该类是一个组件
public class CalculatorAspect_EX {//定义一个切入方法，用于实现“环绕通知”@Around(value = "execution(* Calculator_Demo1.add(..))")public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {//定义方法的返回结果Object result = null;//通过连接点对象获取方法签名对象Signature signature = proceedingJoinPoint.getSignature();//通过方法签名对象获取方法名String methodName = signature.getName();//try-catch-finally结构try {//1.完成前置通知的任务Object[] args = proceedingJoinPoint.getArgs();List<Object> objects = Arrays.asList(args);System.out.println("(Around~)运算日志————运算法则 = " + methodName + ",传入的参数是 " + objects);//!!!//在环绕通知中，需要通过proceed()方法来执行目标方法result = proceedingJoinPoint.proceed();//2.完成返回通知的任务System.out.println("(Around~)运算日志————运算法则 = " + methodName + ",运算结果 = " + result);} catch (Throwable throwable) {//3.完成异常通知的任务System.out.println("(Around~)异常日志————" + LocalDateTime.now() + ",方法" + methodName + "执行异常");System.out.println("(Around~)异常信息如下————\n" + throwable);} finally {//4.完成后置通知的任务System.out.println("(Around~)执行日志————" + methodName + "方法执行结束。");}return result; }
}

                然后，up再定义一个单元测试方法，用于测试环绕通知是否生效，代码如下 : 

    //环绕通知测试@Testpublic void testAroundAdvice() {ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_aop.xml");Calculator calculator = ioc.getBean("calculator01", Calculator.class);System.out.println("calculator's class = " + calculator.getClass());calculator.add(150, 255.5);}

                运行结果 : 

                可以看到，通过环绕通知，成功达到了“前置通知”，“返回通知”，“后置通知”的效果。

        3.切入点表达式重用(@Pointcut) : 

            3.1 简介

        我们在之前定义的切面类CalculatorAspect类中定义了多个切入点表达式，但是我们发现这样一个问题——多个切入点表达式都指向了相同的类的相同方法，未免有些冗余的感觉，能不能想办法将这些切入点表达式进行复用，以提高使用效率呢？

        为了统一管理切入点表达式，我们可以使用切入点表达式重用技术（使用@Pointcut注解）。其使用格式如下图所示 : 

            3.2 实例

                需求 : 我们就在原来的CalculatorAspect切面类中进行修改，要求通过@Pointcut注解配置一个切入点表达式，然后对该表达式重用，完成前置通知和返回通知。

                实现 : 首先，为防止对输出结果造成干扰，up先将上文“环绕通知”中定义的CalculatorAspect_EX切面类注释掉。然后在CalculatorAspect类中进行配置，代码如下 :

package com.cyan.spring.aop.aspectJ;import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;import java.time.LocalDateTime;/*** 切面类 : CalculatorAspect*/
@Aspect //Aspect注解提供了底层切面编程的支撑
@Component  //Component注解表示该类是一个组件
public class CalculatorAspect {/*切入点表达式重用*/@Pointcut(value = "execution(public double Calculator_Demo1.add(..))")public void myPointcut() {}//@Before(value = "execution(public double com.cyan.spring.aop.aspectJ.Calculator.add(double, double))")@Before(value = "myPointcut()")public void beforeAdvice(JoinPoint joinPoint) {//1.通过连接点对象，得到方法参数Object[] args = joinPoint.getArgs();double n1 = (double) args[0];double n2 = (double) args[1];//2.通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//3.通过方法签名对象，获取到方法名String name = signature.getName();//Δ在运算方法执行前打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",传入两个参数分别是 " + n1 + " 和 " + n2);}//returnAdvice方法，作为返回通知//@AfterReturning(value = "execution(* Calculator_Demo1.add(double, double))", returning = "result")@AfterReturning(value = "myPointcut()", returning = "result")public void returnAdvice(JoinPoint joinPoint, Object result) {//通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//通过方法签名对象，获取到方法名String name = signature.getName();//获得方法参数Object[] args = joinPoint.getArgs();//double result = (double) args[0] + (double) args[1];//Δ在运算方法执行后打印出运算日志System.out.println("运算日志————运算法则 = " + name + ",运算结果 = " + result);}}

                接着，仍然在测试类TestAspectJ中定义一个单元测试方法，测试切入表达式重用是否成功，代码如下 : 

    //切入表达式重用测试@Testpublic void testPointcut() {ApplicationContext ioc = new ClassPathXmlApplicationContext("beans_aop.xml");Calculator calculator01 = ioc.getBean("calculator01", Calculator.class);System.out.println("calculator01's class = " + calculator01.getClass());calculator01.add(11, 22);}

                运行结果 : 

        4.切面类执行顺序 : 

            4.1 简介

        (1) 若多个切面类中定义的切入方法指向了同一个横切关注点，可以通过@Order(value=n)注解来控制切面类执行的优先级，其中，n的值越小，则该切面类执行的优先级越高。PS : 注意，是org.springframework.core.annotation包下的@Order注解。

        (2) 多个切面类的执行顺序，其实和FilterChain过滤器链的执行顺序是十分相似的，即后调用的先执行完毕，如下图所示 : 

            4.2 实例

                新定义一个切面类——CalculatorAspect2类，并修改该切面类中前置通知和返回通知的输出信息，以和CalculatorAspect切面类作区分。CalculatorAspect2类代码如下 : 

package com.cyan.spring.aop.aspectJ;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;@Aspect
@Component
public class CalculatorAspect2 {//前置通知@Before(value = "execution(public double com.cyan.spring.aop.aspectJ.Calculator.add(double, double))")public void beforeAdvice(JoinPoint joinPoint) {//1.通过连接点对象，得到方法参数Object[] args = joinPoint.getArgs();double n1 = (double) args[0];double n2 = (double) args[1];//2.通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//3.通过方法签名对象，获取到方法名String name = signature.getName();//Δ在运算方法执行前打印出运算日志System.out.println("(2)运算日志————运算法则 = " + name + ",传入两个参数分别是 " + n1 + " 和 " + n2);}//返回通知@AfterReturning(value = "execution(* Calculator_Demo1.add(double, double))", returning = "result")public void returnAdvice(JoinPoint joinPoint, Object result) {//通过连接点对象，得到方法签名对象Signature signature = joinPoint.getSignature();//通过方法签名对象，获取到方法名String name = signature.getName();//获得方法参数Object[] args = joinPoint.getArgs();//double result = (double) args[0] + (double) args[1];//Δ在运算方法执行后打印出运算日志System.out.println("(2)运算日志————运算法则 = " + name + ",运算结果 = " + result);}
}

                这时，若我们运行测试方法（切入表达式重用中定义的测试方法），会发现两个切面类的切入方法同时生效，运行结果如下图所示 : 

                可以看到，当前是旧的切面类先生效；现在，我们给两个切面类都配置上@Order注解，如下图所示 : 

                可以看到，此时新配置的切面类CalculatorAspect2的执行优先级更高；这时我们重新运行测试方法，运行结果如下 : 

                可以看到，果然是CalculatorAspect2切面类先执行。

        5.基于XML配置AOP : 

                到现在为止，我们一直都在使用“基于注解配置AOP”的形式，那么基于XML又怎么配置AOP呢？
                up将原先的beans_aop.xml配置文件进行修改，将注解扫描的代码注释掉，并在该配置文件中基于XML配置AOP，beans_aop.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.cyan.spring.aop.aspectJ"/>--><!-- 开启基于注解的AOP功能，若不开启，不能实现切入[动态代理 + 反射调用] --><!--<aop:aspectj-autoproxy/>--><!--配置实现类对象(被代理对象)--><bean class="com.cyan.spring.aop.aspectJ.Calculator_Demo1" id="calculator01"/><!--配置切面类--><bean class="com.cyan.spring.aop.aspectJ.CalculatorAspect" id="aspect01"/><!--XML配置AOP--><aop:config><!-- 先配置切入点(联系之前的“切入点表达式重用”) --><aop:pointcut id="myPointcut" expression="execution(public double *.add(..))"/><!-- 再指定切面类 --><aop:aspect ref="aspect01" order="3"><!-- 表示将该类中的beforeAdvice方法切入到myPointcut指向的横切关注点上，并作为前置通知 --><aop:before method="beforeAdvice" pointcut-ref="myPointcut"/><!-- 方法的返回结果保存在result变量中 --><aop:after-returning method="returnAdvice" pointcut-ref="myPointcut" returning="result"/><!-- 方法的异常信息保存在exception变量中 --><aop:after-throwing method="throwingAdvice" pointcut-ref="myPointcut" throwing="exception"/></aop:aspect></aop:config>
</beans>

                重新运行测试方法，会发现依然成功，如下图所示 : 

五、总结

  • 🆗，以上就是Spring系列博文第五小节的全部内容了。
  • 总结一下，我们先从“动态代理的优化”引出，自己定义了一个AOP类进行模拟，进行问题分析后（不够灵活，复用性差）；又通过一个入门案例了解了AOP——通知注解的使用。接着，我们又详细介绍了AOP——切入点表达式，包括它的基本使用，注意事项和更多细节；最后，我们又简单介绍了基于XML方式配置AOP。
  • 下一节内容——Spring 手动实现Spring底层机制，我们不见不散😆。感谢阅读！

        System.out.println("END--------------------------------------------------");

这篇关于Spring AOP—通知类型 和 切入点表达式 万字详解（通俗易懂）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/581046。

相关文章

在Ubuntu上部署SpringBoot应用的操作步骤

在Ubuntu上部署SpringBoot应用的操作步骤

《在Ubuntu上部署SpringBoot应用的操作步骤》随着云计算和容器化技术的普及,Linux服务器已成为部署Web应用程序的主流平台之一,Java作为一种跨平台的编程语言,具有广泛的应用场景,本... 目录一、部署准备二、安装 Java 环境1. 安装 JDK2. 验证 Java 安装三、安装 mys
阅读更多...
Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

《Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单》：本文主要介绍Springboot的ThreadPoolTaskScheduler线... 目录ThreadPoolTaskScheduler线程池实现15分钟不操作自动取消订单概要1，创建订单后
阅读更多...
JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

《JAVA中整型数组、字符串数组、整型数和字符串的创建与转换的方法》本文介绍了Java中字符串、字符数组和整型数组的创建方法,以及它们之间的转换方法,还详细讲解了字符串中的一些常用方法,如index... 目录一、字符串、字符数组和整型数组的创建1、字符串的创建方法1.1 通过引用字符数组来创建字符串1.2
阅读更多...
SpringCloud集成AlloyDB的示例代码

SpringCloud集成AlloyDB的示例代码

《SpringCloud集成AlloyDB的示例代码》AlloyDB是GoogleCloud提供的一种高度可扩展、强性能的关系型数据库服务,它兼容PostgreSQL,并提供了更快的查询性能... 目录1.AlloyDBjavascript是什么？AlloyDB 的工作原理2.搭建测试环境3.代码工程1.
阅读更多...
Java调用Python代码的几种方法小结

Java调用Python代码的几种方法小结

《Java调用Python代码的几种方法小结》Python语言有丰富的系统管理、数据处理、统计类软件包,因此从java应用中调用Python代码的需求很常见、实用,本文介绍几种方法从java调用Pyt... 目录引言Java core使用ProcessBuilder使用Java脚本引擎总结引言python
阅读更多...
SpringBoot操作spark处理hdfs文件的操作方法

SpringBoot操作spark处理hdfs文件的操作方法

《SpringBoot操作spark处理hdfs文件的操作方法》本文介绍了如何使用SpringBoot操作Spark处理HDFS文件,包括导入依赖、配置Spark信息、编写Controller和Ser... 目录SpringBoot操作spark处理hdfs文件1、导入依赖2、配置spark信息3、cont
阅读更多...
springboot整合 xxl-job及使用步骤

springboot整合 xxl-job及使用步骤

《springboot整合xxl-job及使用步骤》XXL-JOB是一个分布式任务调度平台,用于解决分布式系统中的任务调度和管理问题,文章详细介绍了XXL-JOB的架构,包括调度中心、执行器和Web... 目录一、xxl-job是什么二、使用步骤1. 下载并运行管理端代码2. 访问管理页面，确认是否启动成功
阅读更多...
Java中的密码加密方式

Java中的密码加密方式

《Java中的密码加密方式》文章介绍了Java中使用MD5算法对密码进行加密的方法,以及如何通过加盐和多重加密来提高密码的安全性,MD5是一种不可逆的哈希算法,适合用于存储密码,因为其输出的摘要长度固... 目录Java的密码加密方式密码加密一般的应用方式是总结Java的密码加密方式密码加密【这里采用的
阅读更多...
Mysql 中的多表连接和连接类型详解

Mysql 中的多表连接和连接类型详解

《Mysql中的多表连接和连接类型详解》这篇文章详细介绍了MySQL中的多表连接及其各种类型,包括内连接、左连接、右连接、全外连接、自连接和交叉连接,通过这些连接方式,可以将分散在不同表中的相关数据... 目录什么是多表连接？1. 内连接（INNER JOIN）2. 左连接（LEFT JOIN 或 LEFT
阅读更多...
Java中ArrayList的8种浅拷贝方式示例代码

Java中ArrayList的8种浅拷贝方式示例代码

《Java中ArrayList的8种浅拷贝方式示例代码》：本文主要介绍Java中ArrayList的8种浅拷贝方式的相关资料,讲解了Java中ArrayList的浅拷贝概念,并详细分享了八种实现浅... 目录引言什么是浅拷贝？ArrayList 浅拷贝的重要性方法一：使用构造函数方法二：使用 addAll(
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2