Spring 配置使用 - AOP 通知类型

最新推荐文章于 2023-03-19 16:39:39 发布
最新推荐文章于 2023-03-19 16:39:39 发布
阅读量4.8k 收藏 7
点赞数 3
分类专栏： Spring Spring 文章标签： spring aop advice aspect pointcut
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012420654/article/details/52811060
版权

基本概念

AOP，即 Aspect-Oriented Programming（面向切面编程），它其实是 OOP（Object-Oriented Programing，面向对象编程）思想的补充和完善。

在使用 Spring AOP 之前，首先需要掌握以下几个常用术语：

1.aspect

aspect，即切面。切面是通知和切点的结合。通知和切点共同定义了关于切面的全部内容。

2.advice

advice，即通知。通知在 AOP 中代表切面的工作，它定义了切面具体要做什么，何时做。

在 Spring 中共有 5 类通知类型，用来分别表示切面在不同时候要做的工作。

  • 前置通知（Before Advice）：在切入点选择的连接点处的方法之前执行的通知，该通知不影响正常程序执行流程（除非该通知抛出异常，该异常将中断当前方法链的执行而返回）。

  • 后置通知（After Advice）：在切入点选择的连接点处的方法之后执行的通知（无论方法执行是否成功都会被调用）。

  • 后置返回通知（After returning Advice）：在切入点选择的连接点处的方法正常执行完毕时执行的通知，必须是连接点处的方法没抛出任何异常正常返回时才调用。

  • 后置异常通知（After throwing Advice）: 在切入点选择的连接点处的方法抛出异常返回时执行的通知，必须是连接点处的方法抛出任何异常返回时才调用异常通知。

  • 环绕通知（Around Advices）：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知可以在方法调用之前和之后自定义任何行为，并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。

3.pointcut

pointcut，即切点。在 AOP 中切点表示切面生效的地方。

4.joinpoint

joinpoint，连接点。在 AOP 中表示能让切面生效，产生作用的地方。这个点可以是调用方法时，抛出异常时，甚至是字段被修改时。乍看之下会觉的连接点和切点没什么区别，其实它们就是全部与部分的关系，如下图：

这里写图片描述

实例探究

1.前置通知

首先来看一个关于 Spring AOP 前置通知的简单例子。

  • 定义一个 Bean，用它来表示连接点（joinpoint）的一部分
public class Animals {
    public void setName(String name) {
        System.out.println(name);
    }
}
  • 定义一个 Bean，用来表示切面
public class AnimalsAspect {
    // 该方法表示切面的具体工作
    public void beforeAdvice() {
        System.out.println("before advice..." );
    }
}
  • 在 xml 文件中配置
<!-- 1.容器中注入 Bean -->
<bean id="joinpoint" class="com.demo.Animals" />
<bean id="aspect" class="com.aop.AnimalsAspect"/>

<!-- 2.AOP 配置 -->
<aop:config>
    <!-- 2.1指定切面 -->
    <aop:aspect ref="aspect">
        <!-- 2.2指定通知和切点-->
        <!-- before 表示通知类型是前置通知，method 表示通知的具体作用，即指定了切面在何时做什么-->
        <!-- pointcut 表示切点，即指定了切面在哪生效-->
        <aop:before method="beforeAdvice" pointcut="execution(* com.demo.Animals.setName(..))" />
    </aop:aspect>
</aop:config>
  • 调用验证
String location = ...
ApplicationContext factory = new FileSystemXmlApplicationContext(location);
Animals animals = (Animals) factory.getBean("joinpoint");
animals1.setName("cat");
// 输出结果：
// before advice...
// cat

2.后置通知

上面的例子中介绍了 Spring AOP 的简单使用，且具体使用的是 AOP 的前置通知，接下来探究下其他通知类型的作用。

  • 定义一个 Bean，用它来表示连接点（joinpoint）的一部分。
public class Animals {
    public void setName(String name) {
        // 为空时，打印并抛出异常
        if(name == null){
             System.out.println("Exception");
             throw new NullPointerException();
        }
        System.out.println(name);
    }
}
  • 定义切面
public class AnimalsAspect {

    public void afterAdvice() {
        System.out.println("after advice...");
    }

    public void afterReturningAdvice() {
        System.out.println("after returning advice...");
    }

    public void afterThrowingAdvice(Exception exception) {
        System.out.println("after throwing advice exception..." );
    }

}
  • 在 xml 配置文件定义：
<!-- 容器中注入 Bean ,同上-->

<!-- AOP 配置 -->
<aop:config>
    <!-- 定义切点，简化配置（由于多种通知类型都要作用在该切点）-->
    <aop:pointcut expression="execution(* com.demo.Animals.setName(..))" id="pointcut"/>
    <aop:aspect ref="aspect">
        <!-- 相应的，这里不再使用 pointcut 而使用 poincut-ref 指定切点 -->
        <!-- pointcut 和 pointcut-ref 都能指定切点（前者为指定切点，后者为匿名切点）-->
        <aop:after method="afterAdvice" pointcut-ref="pointcut"/>
        <aop:after-returning method="afterReturningAdvice" pointcut-ref="pointcut"/>
        <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>
  • 调用验证
String location = ...
ApplicationContext factory = new FileSystemXmlApplicationContext(location);
Animals animals = (Animals) factory.getBean("joinpoint");
animals1.setName("cat");
animals1.setName(null);
// 输出结果：
// cat
// after advice...
// after returning advice...
// 
// Exception
// after advice...
// after throwing advice exception...

3.通知参数

到目前的例子中，几乎所有通知类型的方法都是不带参数。下面来看下如何在通知时调用【被通知方法】的方法参数。

  • 定义一个 Bean，用它来表示连接点（joinpoint）的一部分。
public class Animals {
    public String setName(String name) {
        // 为空时，打印并抛出异常
        if(name == null){
             System.out.println("Exception");
             throw new NullPointerException();
        }
        System.out.println(name);

        // 返回值
        return "return "+name;
    }
}
  • 定义切面
public class AnimalsAspect {
    // 这里需要注意的是：切面的参数类型只有与被通知方法的参数类型一致时才能生效，因此这里采用 Object，因为它能匹配任意类型
    public void beforeAdvice(Object param) {
        System.out.println("before advice...，param is :"+param);
    }

    public void afterAdvice(Object param) {
        System.out.println("after advice...，param is :"+param);
    }

    public void afterReturningAdvice(Object param) {
        System.out.println("after returning advice...，param is :"+param);
    }

    public void afterThrowingAdvice(Exception exception) {
        System.out.println("after throwing advice exception...，exception is :"+exception);
    }
}
  • 在 xml 配置文件定义：
<!-- 容器中注入 Bean ,同上-->

<!-- AOP 配置 -->
<aop:config>
    <!-- 这里定义了两种切点：带参、不带参 -->
    <aop:pointcut expression="execution(* com.demo.Animals.setName(..)) and args(param)" id="pointcut"/>
    <aop:pointcut expression="execution(* com.demo.Animals.setName(..))" id="point-noparam"/>
    <aop:aspect ref="aspect">
        <aop:before method="beforeAdvice" pointcut-ref="pointcut" arg-names="param"/>
         <aop:after method="afterAdvice" pointcut-ref="pointcut" arg-names="param"/>
        <!-- 以下两种通知并没有调用到方法参数，所以使用不带参的切点，注意区别 -->
        <aop:after-returning method="afterReturningAdvice" pointcut-ref="point-noparam" returning="param"/>
        <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="point-noparam"  throwing="exception" /> 
    </aop:aspect>
</aop:config>
  • 调用验证：
String location = ...
ApplicationContext factory = new FileSystemXmlApplicationContext(location);
Animals animals = (Animals) factory.getBean("joinpoint");
animals1.setName("cat");
animals1.setName(null);
// 输出结果：
// before advice...，param is :cat
// cat
// after advice...，param is :cat
// after returning advice...，param is :return cat
//
// before advice...，param is :null
// after advice...，param is :null
// after throwing advice exception...，exception is :java.lang.NullPointerException

4.环绕通知

环绕通知非常强大，可以决定【被通知方法】是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。

  • 定义一个 Bean，用它来表示连接点（joinpoint）的一部分。（同上）

  • 定义切面

public class AnimalsAspect {

    // 环绕通知第一个参数必须是 org.aspectj.lang.ProceedingJoinPoint 类型
    public void aroundAdvice(ProceedingJoinPoint joinpoint,Object param) throws Throwable {

        // 关键 -> 取得方法的入参，由于被通知方法只有一个入参，所以取数组的第一个元素
        String param = joinpoint.getArgs()[0];

        System.out.println("around before advice..，param is："+param);

        // 关键 -> 执行被通知的方法（替换方法入参，并取得返回值）
        Object returnValue = joinpoint.proceed(new Object[]{"replace"});
        System.out.println("around after advice.."+returnValue);
    }
}
  • 在 xml 配置文件定义： 
<!-- 容器中注入 Bean ,同上-->

<!-- AOP 配置 -->
<aop:config>
    <aop:pointcut expression="execution(* com.demo.Animals.setName(..))" id="point-noparam"/>
    <aop:aspect ref="aspect">
        <aop:around method="aroundAdvice" pointcut-ref="point-noparam"/> 
    </aop:aspect>
</aop:config>
  • 调用验证
String location = ...
ApplicationContext factory = new FileSystemXmlApplicationContext(location);
Animals animals = (Animals) factory.getBean("joinpoint");
animals1.setName("cat");
// 输出结果：
// around before advice..，param is cat
// replace
// around after advice..return replace

参考

oxf
关注
专栏目录
AOP通知类型
m0_62656695的博客
07-21 144
1.前置通知 2.后置通知 3.环绕通知 Around注意事项 4.返回后通知 5.抛出异常通知
AOP的5种类通知类型
最新发布
weixin_44249746的博客
03-18 381
(5)环绕通知,环绕通知功能比较强大，它可以追加功能到方法执行的前后，这也是比较常用的方式，它可以实现其他四种通知类型的功能，具体是如何实现的，需要我们往下学习。(3)返回后通知,追加功能到方法执行后，只有方法正常执行结束后才进行,类似于在代码3添加内容，如果方法执行抛出异常，返回后通知将不会被添加。(4)抛出异常后通知,追加功能到方法抛出异常后，只有方法执行出异常才进行,类似于在代码4添加内容，只有方法抛出异常后才会被添加。(1)前置通知，追加功能到方法执行前,类似于在代码1或者代码2添加内容。
Spring AOP 各种通知
08-25 1009
sping aop 各种通知
Spring AOP 通过XML方式配置各种通知
起个名字这么长的专栏
11-25 547
Spring AOP 通过XML方式配置各种通知 上一篇AOP原理补充：http://blog.csdn.net/u013704342/article/details/53290191 1.声明一个接口：package test.aop.service.interfaces; public interface TestAopServiceInterface { void
spring-aop-jar
12-14
在IT领域，Spring框架是一个广泛使用的Java应用框架，它提供了许多功能，包括依赖注入、面向切面编程（AOP）等。"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨...
spring-nested-aop.zip_aop_spring aop
09-23
Spring AOP支持多种类型的通知，如`@Before`、`@After`、`@Around`等。 - **连接点（Join Point）**: 连接点是程序执行的某个点，如方法的执行、字段的赋值等。 - **切入点（Pointcut）**: 切入点是匹配连接点的规则...
spring-aop-4.2.xsd.zip
05-31
开发人员可以使用这个文件来验证他们的Spring AOP配置是否符合规范，或者在编写新的配置时作为参考。 总的来说，这个压缩包提供了Spring AOP模块的4.2版本的XML Schema定义，对理解和调试Spring AOP配置文件非常有...
ssm-spring-security-Aop.zip
09-05
在AOP通知中，当一个操作完成后，可能会调用MyBatis的SqlSession来执行插入日志的SQL语句，将日志信息保存到数据库中。为了优化性能，可能还会涉及到缓存机制和事务管理，确保日志数据的一致性和完整性。 文件...
Spring 配置使用 - AOP 通知参数
一把空心菜
10-17 4012
基本概念若想要在通知方法获取被通知方法的参数共有两种方式：自动获取、手动指定。下面来探究下这两种方式的不同之处。自动获取参数在介绍 AOP 的通知类型时有提到过环绕通知，该通知类型可以通过参数 ProceedingJoinPoint 自动获取被通知方法的参数值并调用该方法。除了 ProceedingJoinPoint 外，还有 JoinPoint，JoinPoint.StaticPart 也都能自动
Spring AOP的5种通知类型
流楚丶格念的博客
07-24 5897
AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。编写通知类，我们使用5种通知类型分别配置update与save方法上。接下来我们将save中的除0操作取消注释。编写配置类，开启切面编程配置。再运行，发现运行异常通知。.........
Spring aop 五种通知类型
小熊
12-20 9826
Spring aop 五种通知类型 spring aop 的五种通知类型 前置通知 Before advice：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常 后置通知 After returning advice：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行 异常通知 After throwing advice：在连接点抛出异常后执行 最终通知 After (finally) advice：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内
Spring AOP 通知类型
qq_64360391的博客
12-13 2199
·AOP中的通知一共分为五种类型，分别为：前置通知 ，后置通知，环绕通知，异常通知以及最终通知。 try{ // 前置通知、环绕通知 // 目标类的方法 // 后置通知、环绕通知 } catch() { // 抛出异常通知 } finally { // 最终通知 } //前置通知 @Before //后置通知 @AfterReturning //环绕通知 @Around //抛出异常通知 @AfterThrowing //最终通知 @After 1.1环境搭...
spring aop编程(二)
smile6688的专栏
01-24 488
前面主要介绍了如何通过xml实现aop编程，下面主要介绍如何通过@AspectJ来实现。为了使@AspectJ 支持生效,需要做以下步骤：在xml中设置或者在xml中加入声明 aspect      package org.xyz; import org.aspectj.lang.annotation.Aspect;   @Aspect public
Spring AOP的五种通知类型
apmvn的博客
11-10 519
SpringAOP的五种通知类型
AOP中通知的类型有哪些？
Tine Aine
06-11 1686
前置通知：在目标方法执行前执行 后置通知：在目标方法执行后执行，无论方法是否执行成功 返回通知：在目标方法返回后执行，执行成功之后 异常通知：在目标方法抛异常时执行 环绕通知：在目标方法执行中执行（之前或之后） try{ //前置通知 int method(){ ​ return 0; //返回通知 } //后置通知 }catch(Exception e){ //异常通知 } ...
AOP学习之五种通知
原创学无止尽
07-13 962
Spring AOP五种通知详解spring aop通知(advice)分成五类：前置通知Before advice：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常。正常返回通知After returning advice：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行。异常返回通知After throwing advice：在连接点抛出异常后执行。后置通知After...
【spring】spring通知有哪些类型
王佑辉的博客
03-19 345
7.spring5.2.7之前的执行顺序：前置->方法->后置->返回，前置->方法->后置->异常，spring5.2.7之后的执行顺序：前置->方法->返回->后置，前置->方法->异常->后置。6.环绕通知（around）：通知包裹被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。3. 后置通知（after）：在目标方法完成之后调用通知，不关心方法的输出是什么。2.前置通知（before）：在目标方法被调用之前调用通知功能。1.spring切面有5种类型的通知。
Spring AOP 五大通知类型
Hanyinh的博客
04-29 4818
Spring AOP 五大通知类型 总结： 1、前置通知 在目标方法执行之前执行执行的通知。 2、环绕通知 在目标方法执行之前和之后都可以执行额外代码的通知。 3、后置通知 在目标方法执行之后执行的通知。 4、异常通知 在目标方法抛出异常时执行的通知。 5、最终通知 是在目标方法执行之后执行的通知。 以上5种都可以额外接收一个JoinPoint参数，来获取目标对象和目标方法相关信息，但一定要保证必须是第一个参数。 五种通知的执行顺序： 1、在目标方法没有抛出异常的情况下 前置通知 环绕通知的调用
spring-aop与spring-boot-starter-aop的区别
09-22
spring-aop与spring-boot-starter-aop的区别在于配置的简化程度和依赖的引入方式。spring-aop是基于Spring框架的AOP实现方式，需要通过XML配置文件来定义切面和通知。而spring-boot-starter-aop是针对Spring Boot应用程序提供的一种简化配置和使用的方式，可以通过注解和Java配置来定义切面和通知。使用spring-boot-starter-aop可以更方便地进行AOP操作，并且不需要额外引入独立的AOP依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

oxf

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值