当前位置：首页 > article >正文

Spring AOP的概念与使用

article 2024/10/25 4:46:47

（一）什么是AOP

我们之前说spring的两个核心是 IOC,AOP，那IOC我们说了是控制反转那么AOP又是什么呢？

1.AOP的概念

• Aspect Oriented Programming（⾯向切⾯编程）

我们看到面向切面编程一定会感到熟悉，因为我们学习的java叫做面向对象编程。那唯一不同的就是面向的事物不同，所以这里我们就会有疑问，什么是切面呢？

切面就是指某一类特定的问题，所以AOP又叫做面向特定方法编程（就比如spring中的拦截器和统一处理，就是AOP的应用），AOP是一种思想，上述的应用就是思想的实现

总的来说：AOP是一种思想，是对某一类问题的统一处理

2.AOP思想的优点

首先AOP是对一类问题的处理，所以他可以减少我们的重复代码，提高开发效率，并且方便我们日后对代码的更改

3.AOP的不同实现

我们说AOP是一种思想，那思想就需要我们去实现，所以这么久以来就有很多实现了AOP的思想，就比如Spring AOP，也有AspectJ、CGLIB等. 那这里我们就来说一下Spring AOP.

我们上文说了spring中给我们提供的拦截器，拦截器的作用维度是一次url请求和响应，但是AOP作用的维度就更加的细致，可以对更小的细节进行拦截，比如：包、类、⽅法名、参数等（所以能实现更加复杂的业务逻辑）

AOP应用的一个例子

假设现在我们有一个项目，项目中有很多的业务功能，但是我们执行后发现，项目的执行效率比较低，耗时很长，这时我们就需要优化，但是优化前我们需要找到耗时最长的方法。这时我们可以记录这个方法运行前后的时间，来计算这个方法的耗时

但是虽然这样可以计算出这个方法的耗时，但是如果我们每个方法都这样写不仅代码重复度提高，也会浪费我们很多时间，所以AOP这时就可以再不修改这些方法的基础上，针对特定的一类方法进行功能的增强

AOP的作⽤：在程序运⾏期间在不修改源代码的基础上对已有⽅法进⾏增强（⽆侵⼊性:解耦）

（二）Spring AOP的入门

1.引入依赖

我们需要在pom文件中添加配置

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.通过AOP来记录每个方法的执行时间

因为我们这里的方法就是个打印，所以这里耗时是0ms，其实是没有问题的

那接下来我们对这个代码进行一个简单的讲解

拆分：

1. 注解

@Aspect：声明了这是一个切面类

@Around：环绕通知，再目标方法的前后都会执行（如果我们想的话，这个注解可以完成跟之后不同的通知类型一样的功能），后面跟着的表达式一会我们再说（暂时可以理解为对这些目录下的方法进行统一处理）

其他的注解都是我们之前反复说的了，这里就不再多说了

2. 参数和返回值

joinpoint：就是相当于我们的方法，我们可以通过这个对象的proceed方法来执行我们的方法

返回值：因为我们在这个统一处理中执行的我们的方法，我们的方法返回值已经被接收了，如果想要正常返回，就需要我们手动的去返回

整体

如果我们整体来看这个代码，其实就分成了三个部分：

1.方法执行前逻辑 2.原始方法执行 3.方法执行后逻辑

（三）Spring AOP详解

1.Spring AOP的核心概念

1）切点（Pointcut）：切点的作用就是提供一组规则，来告诉程序对那种路径下的方法来进行统一处理

2）连接点（Join Point）：这个很好理解，满足切点提供的规则就是连接点

3）通知（Advice）：通知就是具体要做的工作，就是我们AOP的主体（也就是要如何统一处理）

4）切面（Aspect) :就是切点＋通知

汇总

2.通知类型

我们刚刚说注解的时候说到了@Around注解我们说这个注解是环绕通知，那除了环绕通知，还有什么通知类型？

• @Around:环绕通知,此注解标注的通知⽅法在⽬标⽅法前,后都被执⾏

• @Before:前置通知,此注解标注的通知⽅法在⽬标⽅法前被执⾏

• @After:后置通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,⽆论是否有异常都会执⾏

• @AfterReturning:返回后通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,有异常不会执⾏

• @AfterThrowing:异常后通知,此注解标注的通知⽅法发⽣异常后执⾏

接下来我们写一些测试用例来试一下这些注解

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo1 {
    @Before("execution(* com.example.demo.Controller.*.*(..))")
    public void doBefore(){
        log.info("doBefore");
    }
    @After("execution(* com.example.demo.Controller.*.*(..))")
    public void doAfter(){
        log.info("doAfter");
    }
    @Around("execution(* com.example.demo.Controller.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("AspectDemo do around before....");
        Object proceed = joinPoint.proceed();
        log.info("AspectDemo do around after....");
        return proceed;
    }
    @AfterThrowing("execution(* com.example.demo.Controller.*.*(..))")
    public void doAfterThrowing(){
        log.info("doAfterThrowing");
    }
    @AfterReturning("execution(* com.example.demo.Controller.*.*(..))")
    public void doAfterReturning(){
        log.info("doAfterReturning");
    }

}

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/time1")
    public String CalTime1(){
        log.info("计算时间Time1");
        return "计算时间Time1";
    }
    @RequestMapping("/time2")
    public String CalTime2(){
        log.info("执行");
        int a=10/0;
        return "CalTime2";
    }
}

那我们可以看到这些打印的日志

我们发现确实如上面所说，如果我们的程序没有异常，那么 @AfterThrowing这个注解是不会执行的

程序发⽣异常的情况下： • @AfterReturning 标识的通知⽅法不会执⾏， @AfterThrowing 标识的通知⽅法执⾏了 • @Around 环绕通知中原始⽅法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执⾏了(因为原始⽅法调⽤出异常了)

3.@PointCut

上述代码我们会发现一个问题，我们的切点表达式，重复的次数太多了，我们可不可以把他给提出来？

这时就需要我们Spring 提供的@PointCut注解，通过这个注解，我们可以提出公共的切点表达式，需要时再进行引入

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo1 {
    @Pointcut("execution(* com.example.demo.Controller.*.*(..))")
    public void pt(){
    }
    @Before("pt()")
    public void doBefore(){
        log.info("doBefore");
    }
    @After("pt()")
    public void doAfter(){
        log.info("doAfter");
    }
    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("AspectDemo do around before....");
        Object proceed = joinPoint.proceed();
        log.info("AspectDemo do around after....");
        return proceed;
    }
    @AfterThrowing("pt()")
    public void doAfterThrowing(){
        log.info("doAfterThrowing");
    }
    @AfterReturning("pt()")
    public void doAfterReturning(){
        log.info("doAfterReturning");
    }
}

这时我们的代码就变成了这个样子

而且这个切点的定义不仅仅可以再当前的切面类中使用我们在其他切面类也可以使用（但是注意我们如果使用private就只能在当前切面类中使用）