Spring开发基于注解AOP和通知的类型、执行顺序

最新推荐文章于 2023-05-07 20:26:28 发布
最新推荐文章于 2023-05-07 20:26:28 发布
阅读量668 收藏 1
点赞数
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qidaihuimou/article/details/121677832
版权

文章目录

前言：

Spring版本不一样，通知执行顺序也会存在差异
查看Spring版本的方法：

public static void main(String[] args) {
        System.out.println(SpringVersion.getVersion());
    }

版本结果：
在这里插入图片描述

新建一个springBoot项目，目录结构：

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.7</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>chang</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>chang</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
切点类代码：

定义切点时execution表达式语法规则：
execution表达式语法规则

package com.example.chang.aop;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;


//该注解表示声明该类为一个切面类
@Aspect
@Component
//可以使用@Order注解指定先后顺序，数字越小，优先级越高，先进后出
@Order(value = 1)
public class MyAspect {

    //定义一个切点，execution表达式可以灵活运用
    @Pointcut("execution(public * com.example.chang..*.*(..))")
    public void pointCut(){};

    //@Before在目标方法之前切入；切入点表达式（指定在哪个方法切入）
    @Before("pointCut()")
    public void logStart(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        System.out.println("进入@Before测试"+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+ Arrays.asList(args)+"}");
    }

    //方法执行开始之后
    @After("pointCut()")
    public void logEnd(JoinPoint joinPoint){
        System.out.println("进入@Afte测试"+joinPoint.getSignature().getName()+"结束。。。@After");
    }


    //当方法进行返回的时候，returning属性是指定方法参数中的result来接收返回参数，这样就可以修改返回参数
    @AfterReturning(value="pointCut()",returning="result")
    public void logReturn(JoinPoint joinPoint,Object result){
        System.out.println("进入@AfterReturning测试"+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
    }


    //当方法执行异常的时候，throwding是指定方法参数中的e来接收异常参数，可以查看发生的什么异常
    @AfterThrowing(value="pointCut()",throwing="exception")
    public void logException(JoinPoint joinPoint,Exception exception){
        System.out.println("进入@AfterThrowing测试"+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
    }

    //环绕通知
    @Around("pointCut()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable{

        System.out.println("进入@Around测试"+joinPoint.getSignature().getName()+"开始");
        //开始执行真正的请求
        Object  obj= joinPoint.proceed();
        System.out.println("进入@Around测试"+joinPoint.getSignature().getName()+"中间");
        System.out.println("进入@Around测试"+joinPoint.getSignature().getName()+"结束");
        return obj;


    }

}
测试类：
package com.example.chang.aop;

import org.springframework.core.SpringVersion;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("request")
public class TestController01 {

    @RequestMapping("test")
    public String test(){
        System.out.println("真正的方法");
        //System.out.println(6/0);
        return "success666";
    }

//可以查看自己的spring的版本
    public static void main(String[] args) {
        System.out.println(SpringVersion.getVersion());
    }
}
启动项目

在浏览器中输入访问路径：
在这里插入图片描述

正常运行查看日志输出：

在这里插入图片描述

抛出异常查看日志输出：

在这里插入图片描述

敲黑板了！进行总结：

单个切面，通知的执行顺序：

（1）单个@Before、@After、@AfterReturning、@AfterThrowing执行顺序
　①Spring4.0
　　正常情况：@Before=目标方法=@After=====@AfterReturning
　 异常情况：@Before=目标方法=@After=====@AfterThrowing
　　
　②Spring5
　　正常情况：@Before=目标方法=@AfterReturning=====@After
　　异常情况：@Before=目标方法=@AfterThrowing=====@After
　　
（2）单个@Around的执行顺序
①Spring4.0
　　　　正常情况：环绕前置===== 目标方法执行===== 环绕返回===== 环绕最终
　　　　异常情况：环绕前置===== 目标方法执行===== 环绕异常===== 环绕最终
②Spring5
　　　　正常情况：环绕前置===== 目标方法执行===== 环绕返回===== 环绕最终
　　　　异常情况：环绕前置===== 目标方法执行===== 环绕异常===== 环绕最终
（3）五大通知执行顺序

①Spring4.0
　　　　正常情况：环绕前置=====@Before====== 目标方法执行===== 环绕返回===== 环绕最终=====@After=====@AfterReturning
　　　　异常情况：环绕前置=====@Before====== 目标方法执行===== 环绕异常===== 环绕最终===== @After=====@AfterThrowing
②Spring5
　　　　正常情况：环绕前置===== @Before=目标方法执行= @AfterReturning===== @After ===== 环绕返回===== 环绕最终
　　　　异常情况：环绕前置===== @Before=目标方法执行= @AfterThrowing===== @After ===== 环绕异常===== 环绕最终

多个切面，通知的执行顺序：

多个切面时，定义不同的@Order(value = ?)

@Aspect
@Component
//可以使用@Order注解指定先后顺序，数字越小，优先级越高，先进后出
@Order(value = 1)
public class MyAspect {}

@Aspect
@Component
//可以使用@Order注解指定先后顺序，数字越小，优先级越高，先进后出
@Order(value = 5)
public class MyAspect02 {}

①Spring4.0
　　　　正常情况：切面1环绕前置=== 切面1@Before=== 切面2环绕前置=== 切面2@Before=== 目标方法执行=== 切面2环绕返回=== 切面2环绕最终=== 切面2@After=== 切面2@AfterReturning=== 切面1环绕返回=== 切面1环绕最终=== 切面1@After=== 切面1@AfterThrowing
　　　　异常情况：切面1环绕前置=== 切面1@Before=== 切面2环绕前置=== 切面2@Before=== 目标方法执行=== 切面2环绕异常=== 切面2环绕最终=== 切面2@After=== 切面2@AfteThrowing === 切面1环绕异常=== 切面1环绕最终=== 切面1@After=== 切面1@AfterThrowing
②Spring5
　　　　正常情况：切面1环绕前置=== 切面1@Before=== 切面2环绕前置=== 切面2@Before=== 目标方法执行=== 切面2@AfterReturning=== 切面2@After=== 切面2环绕返回=== 切面2环绕最终=== 切面1@AfterReturning=== 切面1@After=== 切面1环绕返回=== 切面1环绕最终
　　　　异常情况：切面1环绕前置=== 切面1@Before=== 切面2环绕前置=== 切面2@Before=== 目标方法执行=== 切面2@AfterThrowing=== 切面2@After === 切面2环绕异常=== 切面2环绕最终=== 切面1@AfterThrowing=== 切面1@After=== 切面1环绕异常===切面1环绕最终

多个切面的示例代码：

把MyAspect类的代码复制，新建个类且@Order(value = 5)，改一下输出的日志：

MyAspect02类代码：
package com.example.chang.aop;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;


//该注解表示声明该类为一个切面类
@Aspect
@Component
//可以使用@Order注解指定先后顺序，数字越小，优先级越高，先进后出
@Order(value = 5)
public class MyAspect02 {

    //定义一个切点，execution表达式可以灵活运用
    @Pointcut("execution(public * com.example.chang..*.*(..))")
    public void pointCut(){};

  //省略同MyAspect类的代码
}
运行结果

（ 对应上面的 结论–》 多个切面，通知的执行顺序–》 Spring5 --》正常情况 ）
在这里插入图片描述

参考：
执行顺序参考文件：https://www.cnblogs.com/orzjiangxiaoyu/p/13869747.html

胡萝卜说
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习spring ioc和aop
05-14
spring 核心功能演示项目 1. applicationContext xml方式和注解方式配置 2. pring bean循环依赖。 3. spring bean 启动顺序。 4. BeanDefinition编程式注入到容器。 5. spring aop 打印 6. spring 事务
Spring.html
03-23
注意:使用注解的方式,最终通知和后置通知顺序换了,建议使用环绕通知 注解 配置 声明式事务管理 PlatFormTransactionManager:平台事务管理器:定义了commit/rollback Mybatis/jdbc:...
【第六章】 AOP 之 6.7 通知顺序 ——跟我学spring3
jinnianshilongnian的专栏
02-25 490
       如果我们有多个通知想要在同一连接点执行，那执行顺序如何确定呢？Spring AOP使用AspectJ的优先级规则来确定通知执行顺序。总共有两种情况：同一切面中通知执行顺序、不同切面中的通知执行顺序。        首先让我们看下   1） 同一切面中通知执行顺序：如图6-6所示。   图6-6 同一切面中的通知执行顺序 而如果在同一切面中定义两个相同类...
Java框架学习：SpringAOP之注解方式实现SpringAOP、通知的执行顺序
weixin_45919908的博客
05-28 242
注解方式实现SpringAOP 配置文件 <context:component-scan base-package="com.young"/> <!--开启AOP注解解析--> <aop:aspectj-autoproxy/> 切面类LoggerAspect import org.aspectj.lang.ProceedingJoinPoint; impor...
关于Spring 基于注解的AOP通知执行顺序
子游丶
05-24 288
网上的一些教程，大多数是拿Spring4.x 跟5.x来对比，其实 这几个通知顺序是从Spring版本为5.2.7.RELEASE---SpringBoot版本为2.2.8.RELEASE时 AOP执行顺序才发生的改变。 Aop常用注解 @Before 前置通知：目标方法之前执行 @After 后置通知：目标方法之后执行（始终执行） @AfterReturning 返回后通知，执行方法结束前执行执行（异常不执行） @AfterThrowing 异常通知：出现异常时执行 @Around 环绕通知
Spring 注解Aop通知类型及执行顺序
weixin_43752167的博客
08-19 1438
1、通知类型 @Before — 前置通知 @AfterReturning — 后置通知 @Around — 环绕通知（目标对象默认不执行，需要手动执行） @After — 最终通知 @AfterThrowing — ...
十、SpringAOP基于注解的几种通知类型
学习笔记
05-29 373
首先要说明一点，spring基于注解的四种通知会有bug，所以实际开发，建议使用基于注解的环绕通知 首先pom依赖如下 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <v
Spring @Aspect注解
12-21
Spring boot @Aspect简介使用场景列子1 (演示基本过程切点表达式切点复合运算切点匹配方法通知注解切面类执行顺序 简介 在 Spring实现 AOP面向切面编程, 是通过 @Aspect注解来实现切面的 使用场景 常见用于记录日志,...
Spring.3.x企业应用开发实战（完整版）.part2
05-31
第7章 基于@AspectJ和Schema的AOP 7.1 Spring对AOP的支持 7.2 JDK 5.0注解知识快速进阶 7.2.1 了解注解 7.2.2 一个简单的注解类 7.2.3 使用注解 7.2.4 访问注解 7.3 着手使用@AspectJ 7.3.1 使用前的准备 7.3.2 一个...
spring源码解析-切面通知执行顺序
nickyyu的博客
03-22 618
应用开发过程中，针对同一个目标对象，可能会需要配置一个或多个切面进行AOP增强。 只有一个切面的情况下，各个通知的执行顺序如下： @Around>@Before>@After>@AfterReturning>@AfterThrowing 配置多个切面的情况下，需要为切面类继承Ordered接口或配置@Order注解手动定义两个切面的顺序大小，值越小越先执行 相关排序...
SpringAop注解版1 - 四种通知
stone的博客
02-01 442
什么是Aop aop被称为面向切面编程，使用动态代理的方式在执行前后或出现异常后做相关逻辑. aop 是oop的一种延续通过预编译方式和运行时期动态代理实现程序功能的一种技术，利用aop可以对业务逻辑的各个部分进行分离，从而使得业务逻辑部分之间的耦合度降低，提高程序的可重用性，同时提高代码的开发效率。在程序运行期间，不修改源码的对已有的方法进行增强 ...
AspectJ基础、切点表达式、通知类型
lady88888888的博客
05-07 368
1、概念 AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，也可以说 AspectJ 是一个基于 Java 语言的 AOP 框架。通常我们在使用 Spring AOP 的时候，都会导入 AspectJ 的相关 jar 包。 导包<添加依赖> <dependency> <groupId>org.aspectj&...
Spring的第十二阶段（03）：Spring实现AOP的简单使用
DKPT的博客
05-07 477
Spring实现AOP的简单使用
Java面试突击每日十题【Day04】——Spring下篇
weixin_49118892的博客
04-25 383
Spring的面试题，感觉写个多少篇都不会写完，只有对十分高频的做一些总结了，上篇和下篇的这些都搞明白了Spring的常规面试应该差不多了吧！！！ Notes:答案在图片下面！！！ Spring Bean的初始化方式有哪些，执行顺序是什么？ Spring依赖注入的方式有哪几种？ @Autowired和@Resource区别？ SpringBean的作用域及区别？ Spring事务支持的隔离级别？ Spring框架中的单例Bean是线程安全的么？如果线程不安全，如何处理？ Spring通知有哪些类型？ Sp
Spring使用注解式声明切面与使用
HiterCoder
05-09 2467
1 什么是面向切面 这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。 AOP是Spring提供的关键特性之一。AOP即面向切面编程，是OOP编程的有效补充。使用AOP技术，可以将一些系统性相关的编程工作，独立提取出来，独立实现，然后通过切面切入进系统。从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理，事物管理，日志记录等等。这些系统性的编程工作都可以独立编码实现，然后通过AOP技术切入进系统即可。从而达到了 将不同的关注点分离出来的效果。 2
测试AOP五种切面通知的优先级次序
热门推荐
scoful的专栏
11-30 3万+
目录通知类型通知执行顺序代码展示代码正常结束代码出现异常 通知类型 在基于Spring AOP编程的过程中，基于AspectJ框架标准，spring中定义了五种类型的通知，它们分别是： 前置通知 (@Before) 返回通知 (@AfterReturning) 异常通知 (@AfterThrowing) 后置通知 (@After) 环绕通知 (@Around) :（优先级最高） 通知执行顺序 将上面的所有通知类型写入同一个切面中，它的执行顺序为： 代码展示 package com.cy.pj.co
Spring的五大通知类型
weixin_49307896的博客
10-19 4005
Spring的五大通知类型 1.**前置通知** 在目标方法执行之前执行执行的通知前置通知方法，可以没有参数，也可以额外接收一个JoinPoint，Spring会自动将该对象传入，代表当前的连接点，通过该对象可以获取目标对象 和 目标方法相关的信息。 注意，如果接收JoinPoint，必须保证其为方法的第一个参数，否则报错。 2.环绕通知 在目标方法执行之前和之后都可以执行额外代码的通知。 在环绕通知中必须手动的调用目标方法，否则目标方法不会执行。这个手动调用是通过ProceedingJoi
Spring Aop的使用和通知注解的执行顺序
weixin_41979002的博客
03-18 2082
一、Aop 常用注解 @Before 前置通知: 目标方法之前执行 @After 后置通知: 目标方法之后执行（始终执行） @AfterReturning 返回后通知: 执行方法结束前执行(异常不执行) @AfterThrowing 异常通知: 出现异常时候执行 @Around 环绕通知: 环绕目标方法执行 spring4和spring5的全部通知执行顺序是不同的，下面用案例说明。 二、案例演示 2.1 业务类 创建业务接口类：CalcService /** * @InterfaceName CalS
RabbitMQ使用指南
weixin_39341215的博客
12-15 341
rabbit mq windows 安装 注意事项 erlang 安装 下载地址 http://www.erlang.org/downloads 环境变量配置 ERLANG_HOME 安装路径 注意事项 安装erlang 时注意 一致 C:\Windows\System32\config\systemprofile\.erlang.cookie C:\Users\用户名\.erlang.cook...
aop中通知的执行顺序
最新发布
07-25
具体来说，有两种情况需要考虑：同一切面中的通知执行顺序和不同切面中的通知执行顺序。在同一切面中，通知的执行顺序是按照它们在代码中的声明顺序来执行的。例如，如果在同一切面中定义了两个前置通知，那么它们将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值