【Spring Boot】Spring AOP 快速上手指南:开启面向切面编程新旅程

前言

🌟🌟本期讲解关于spring aop的入门介绍~~~

🌈感兴趣的小伙伴看一看小编主页:GGBondlctrl-CSDN博客

🔥 你的点赞就是小编不断更新的最大动力

🎆那么废话不多说直接开整吧~~

目录

📚️1.AOP概述

1.1什么是AOP

[1.2什么是Spring AOP](#1.2什么是Spring AOP)

[📚️2.Spring AOP入门](#📚️2.Spring AOP入门)

2.1环境设置

2.2代码编写

[📚️3.Spring AOP详细](#📚️3.Spring AOP详细)

[3.1Spring AOP核心概念](#3.1Spring AOP核心概念)

1.切点

2.连接点

3.通知

4.切面

[3.2Spring AOP通知类型](#3.2Spring AOP通知类型)

3.3@pointcut注解

3.4@order切面优先级

📚️4.总结

📚️1.AOP概述

1.1什么是AOP

AOP是Spring框架的第⼆⼤核⼼(第⼀⼤核⼼是IoC),说明AOP也是非常重要的;

AOP:Aspect Oriented Programming(⾯向切⾯编程)

面向切面编程:所谓的这里的切面就是表示一类特殊的问题,所以也叫面向特定方法编程;

这里特定的方法,在之前学习过的spring统一功能处理中,涉及到登录校验问题,而拦截器就是对这类问题的统一求解,AOP是一种求解问题的思想,那么拦截器就是一种思想的实现;

总结:

简单来说: AOP是⼀种思想, 是对某⼀类事情的集中处理

1.2什么是Spring AOP

AOP是⼀种思想, 它的实现⽅法有很多, 有Spring AOP,也有AspectJ、CGLIB等.Spring AOP是其中的⼀种实现⽅式;

在日常的代码编写中,有以下列子:

假如,我们要对这里面的接口实现改良,让执行时间减少,这里就定位到某些业务代码逻辑等改进,但是不是所有都是不好的,所以我们需要进行测试每个接口,业务执行的时间,那么就有如下的代码,来进行时间检测:

此时的方法固然是可以的,但是那么多接口都需要这样写吗??答案是不可能的,此时这就是一类特定的问题,此时我们就可以使用AOP思想来进行解决~~~

AOP就可以做到在不改动这些原始⽅法的基础上, 针对特定的⽅法进⾏功能的增强.
AOP的作⽤:在程序运⾏期间在不修改源代码的基础上对已有⽅法进⾏增强(⽆侵⼊性: 解耦)

📚️2.Spring AOP入门

2.1环境设置

首先创建一个springboot项目,设置Maven,然后引入如下的依赖

XML 复制代码
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

这里还可以引入lombok来进行slf4j日志打印,但是在新版本中要将引入的lombok中一部分给注释掉,如下所示:

XML 复制代码
           <plugins>
           <!-- <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>-->
            <plugin>

2.2代码编写

具体的代码如下所示:

java 复制代码
@Slf4j
@Aspect
@Component
//交给spring进行管理
public class TimeAspect {

    @Around("execution(* com.example.springaop.controller.*.*(..))")
    public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
        //记录开始时间
        long start = System.currentTimeMillis();
        //执行目标方法
        Object proceed = joinPoint.proceed();
        //记录结束时间
        long end = System.currentTimeMillis();
        //日志打印耗时
        log.info("耗时时间: "+ (end-start) + "ms");
        return proceed;
    }
}

解释:

  1. @Aspect: 标识这是⼀个切⾯类

  2. @Around: 环绕通知, 在⽬标⽅法的前后都会被执⾏. 后⾯的表达式表⽰对哪些⽅法进⾏增强.

  3. ProceedingJoinPoint.proceed() 让原始⽅法执⾏

那么上述代码大致分为如下:

总结优势:

• 代码⽆侵⼊: 不修改原始的业务⽅法, 就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变

• 减少了重复代码

• 提⾼开发效率

• 维护⽅便

📚️3.Spring AOP详细

3.1Spring AOP核心概念

1.切点

切点(Pointcut), 也称之为"切⼊点"

Pointcut 的作⽤就是提供⼀组规则 (使⽤ AspectJ pointcut expression language 来描述), 告诉程序对哪些⽅法来进⾏功能增强

如下所示:

java 复制代码
execution(* com.example.springaop.controller.*.*(..))

这个就是切点表达式;

2.连接点

满⾜切点表达式规则的⽅法, 就是连接点. 也就是可以被AOP控制的⽅法,上述切点表达式中的类就是controller,说明这里面的所有方法都是AOP控制方法;

解释:直白来说就是我们需要操作的解决的一类问题接口,就是受到AOP管理的;

这个就是连接点;

3.通知

通知就是具体要做的⼯作, 指哪些重复的逻辑,也就是共性功能(最终体现为⼀个⽅法)⽐如上述程序中记录业务⽅法的耗时时间, 就是通知;

具体的部分就是如下:

在AOP⾯向切⾯编程当中, 我们把这部分重复的代码逻辑抽取出来单独定义, 这部分代码就是通知的内容.

4.切面

切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)

通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法, 在什么时候执⾏什么样的操作,切面包含了通知中要执行的逻辑,以及连接点的定义

3.2Spring AOP通知类型

Spring中AOP的通知类型有以下⼏种:
• @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏
• @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏
• @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏
• @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏
• @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

那么这里主要是通过代码来进行实验;

每个通知类型的代码如下所示:

java 复制代码
@Slf4j
@Component
@Aspect
public class AspectDemo1 {
    
    @Around("execution(* com.example.springaop.controller.*.*(..))")
    public Object aroundTest(ProceedingJoinPoint point) throws Throwable {
        //通知
        log.info("Around 开始执行");
        //执行目标函数
        Object result = point.proceed();
        //结束打印
        log.info("Around 结束执行");
        return result;
    }

    @Before("execution(* com.example.springaop.controller.*.*(..))")
    public void beforeTest(){
        log.info("before 开始执行");
    }

    @After("execution(* com.example.springaop.controller.*.*(..))")
    public void afterTest(){
        log.info("after 开始执行");
    }

    @AfterReturning("execution(* com.example.springaop.controller.*.*(..))")
    public void afterReturnTest(){
        log.info("afterReturn 开始执行");
    }

    @AfterThrowing("execution(* com.example.springaop.controller.*.*(..))")
    public void afterThrowTest(){
        log.info("afterThrow 开始执行");
    }
}

解释:

从上到下依次的通知类型,就是注解所表示,但是对于环绕通知中,要包含这里的连接点,即目标执行方法,以及返回类型是object;环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他通知不需要考虑⽬标⽅法执⾏;

此时运行如下的测试类:

java 复制代码
@Slf4j
@RestController
@RequestMapping("/test")
public class AspectTest {
    @RequestMapping("/t1")
    public String test1(){
        log.info("这是目标方法,开始执行");
        return "t1";
    }
   @RequestMapping("/t2")
    public String test2(){
        log.info("这是目标方法,开始执行");
        int a=10/0;
        return "t2";
    }
}

那么此时我们先运行这里没有算数异常的代码,输出的情况如下所示:

解释:

程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执⾏

从上图也可以看出来, @Around 标识的通知⽅法包含两部分, ⼀个"前置逻辑", ⼀个"后置逻辑".其

中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏, "后置逻辑" 会晚于 @After 标识的通知⽅法执

此时运行异常代码,结果如下所示:

解释:

@AfterReturning 标识的通知⽅法不会执⾏, @AfterThrowing 标识的通知⽅法执⾏了

• @Around 环绕通知中原始⽅法调⽤时有异常,通知中的环绕后的代码逻辑也不会在执⾏了(因为

原始⽅法调⽤出异常了

3.3@pointcut注解

上⾯代码存在⼀个问题, 就是存在⼤量重复的切点表达式 execution(* com.example.demo.controller.*.*(..)) , Spring提供了 @PointCut 注解, 把公共的切点

表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可

代码如下所示:

java 复制代码
 @Pointcut("execution(* com.example.springaop.controller.*.*(..))")
     public void pt(){}

    @Around("pt()")
    public Object aroundTest(ProceedingJoinPoint point) throws Throwable {
        //通知
        log.info("Around 开始执行");
        //执行目标函数
        Object result = point.proceed();
        //结束打印
        log.info("Around 结束执行");
        return result;
    }

解释:

此时就是通过@pointcut注解,对于切点表达式进行了提取,那么之后再次进行通知注解的切点表达式编写时,就可以直接使用提取的方法;

这里的方法若设置为私有类,那么只能在这一个类中进行使用,但是如果其他类要使用,这里必须变成public访问限定符;

代码如下所示:

java 复制代码
@Slf4j
@Aspect
public class AspectDemo2 {
    @Before("com.example.springaop.aspect.AspectDemo1.pt()")
    public void beforeTest() {
        log.info("AspectDemo2 before 开始执行...");
    }

其中@before注解中的切点编写就是,提取方法的全限定路径+类名+方法名;

3.4@order切面优先级

假如定义了多个切⾯类时, 并且这些切⾯类的多个切⼊点都匹配到了同⼀个⽬标⽅法.情况如下所示

首先定义三个切面类,里面的通知方法大致如下:

java 复制代码
public class AspectDemo3 {
    @Before("com.example.springaop.aspect.AspectDemo1.pt()")
    public void doBefore(){
        log.info("AspectDemo3 do before...");
    }

    @After("com.example.springaop.aspect.AspectDemo1.pt()")
    public void doAfter(){
        log.info("AspectDemo3 do after...");
    }

}

此时进行路由访问后,打印的日志如下所示:

解释:

存在多个切⾯类时, 默认按照切⾯类的类名字⺟排序

• @Before 通知:字⺟排名靠前的先执⾏

• @After 通知:字⺟排名靠前的后执⾏

那么此时我们可以通过@order注解实现顺序的逆转,代码如下所示:

java 复制代码
@Component
@Aspect
@Order(3)
public class AspectDemo3 {
}

解释:

我们设置 AspectDemo3order为3,AspectDemo4的order为2,AspectDemo5的order为1,输出的结果如下所示:

通过上述程序的运⾏结果, 得出结论:

@Order 注解标识的切⾯类, 执⾏顺序如下:

• @Before 通知:数字越⼩先执⾏

• @After 通知:数字越⼤先执⾏

@Order 控制切⾯的优先级, 先执⾏优先级较⾼的切⾯, 再执⾏优先级较低的切⾯, 最终执⾏⽬标⽅法

📚️4.总结

本期主要讲解了关于Spring AOP入门概念,以及快速入门,以及Spring AOP的代码的详细介绍:切点,连接点,通知,以及切面的概念,还有通知类型等其他注解的介绍~~~

🌅🌅🌅~~~~最后希望与诸君共勉,共同进步!!!


💪💪💪以上就是本期内容了, 感兴趣的话,就关注小编吧。

😊😊 期待你的关注~~~

相关推荐
yuren_xia34 分钟前
Spring XML 配置
xml·java·spring
风象南1 小时前
SpringBoot中3种内容协商策略实现
java·spring boot·后端
不知疲倦的仄仄2 小时前
跨域 同源策略通俗讲解
前端·后端·spring·edge浏览器
细心的莽夫8 小时前
SpringCloud 微服务复习笔记
java·spring boot·笔记·后端·spring·spring cloud·微服务
普if加的帕10 小时前
java Springboot使用扣子Coze实现实时音频对话智能客服
java·开发语言·人工智能·spring boot·实时音视频·智能客服
爱喝一杯白开水11 小时前
SpringMVC从入门到上手-全面讲解SpringMVC的使用.
java·spring·springmvc
〆、风神11 小时前
Spring Boot 整合 Lock4j + Redisson 实现分布式锁实战
spring boot·分布式·后端
橘猫云计算机设计12 小时前
springboot基于hadoop的酷狗音乐爬虫大数据分析可视化系统(源码+lw+部署文档+讲解),源码可白嫖!
数据库·hadoop·spring boot·爬虫·python·数据分析·毕业设计
卓怡学长12 小时前
w304基于HTML5的民谣网站的设计与实现
java·前端·数据库·spring boot·spring·html5
敖云岚13 小时前
【AI】SpringAI 第五弹:接入千帆大模型
java·大数据·人工智能·spring boot·后端