Springboot AOP开发教程

2024-03-02 09:53:17 作者：我不配拥有55kg的你

AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型,本文给大家介绍Springboot AOP开发教程,感兴趣的朋友跟随小编一起看看吧

Springboot AOP开发

简介

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

一 AOP概述

AOP，即面向切面编程，简言之，面向方法编程。

针对方法，在方法的执行前或执行后使用，用于增强方法，或拓展。

二 AOP开发

1.引入 spring-boot-starter-aop

在SpringBoot项目的pom文件中，引入 spring-boot-starter-aop依赖。

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

2.示例：计算方法执行时间

1.创建实体类，通过注解来申明该类的类型，并将该类交给Spring的IOC容器来管理。

通过注解 @Aspect 申明这是一个AOP类

通过 @Component 将其交给IOC容器管理

@Aspect
@Component
public class TimeAspect {
    //code
}

2.创建方法并且实现

@Aspect
@Component
@Slf4j
public class TimeAspect {
    // 针对 com.shawn.springboot03.service 包下所有的方法进行编程，
    // * com.shawn.springboot03.service.*.*(..)) 为切入点表达式
    @Around("execution(* com.shawn.springboot03.service.*.*(..))")
    public Object recordTime(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long startTime=System.currentTimeMillis();
        // 切面对象，执行具体的业务方法
        Object object = proceedingJoinPoint.proceed();
        long endTime=System.currentTimeMillis();
        log.info("方法耗时为{}ms",endTime-startTime);
        return object;
    }
}

通过以上方法，当用户调用 service 层接口的任一方法时都会计算方法的运行时间。

3.AOP编程的优点：

代码无侵入：无需修改原始方法
减少代码重复，提高开发效率：只需编写一次
维护方便：根据业务需求，调整切入点表达式即可

三 AOP详解

1.AOP核心概念

1.连接点（JoinPoint）：连接点指的是可以被AOP控制的方法，以及方法执行时的相关信息。

2.通知（Advice）：Advice指的是被抽取出来的共性功能，即重复的那部分逻辑。

3.切入点（PointCut）：匹配连接点的条件，通知仅会在切入点方法执行时被应用

4.切面（Aspcet）:描述通知与切入点的关系

5.目标对象（Target）：通知所应用的对象

2.AOP通知类型

@Around：环绕通知，此注解标注的方法在目标方法前后都会执行
@Before：前置通知，此注解标注的方法仅在方法执行前被执行
@After：后置通知，此注解在方法执行完成后执行，不论是否抛出异常
@AfterReturning：返回后通知，此注解标注的方法在目标方法后被执行，有异常不通知
@AfterThrowing：异常后通知，此注解的通知方法发生异常后执行

3.各通知类型演示

创建一个 TestAspect 类，用于演示各种通知类型

@Around 通知类型

介绍：在方法前后均执行

切入点表达式格式：返回值包名.方法名（形参）

其中 * 代表全部，.. 代表任意多的参数

切入点表达式示例说明：

* com.shawn.test.server.*(..) 表示任意返回值的 com.shawn.test.server包下任意返回值，任意多参数的全部方法。

@Aspect
@Component
@Slf4j
public class TestAspect {
    @Around("execution(* com.shawn.springboot03.service.impl.DeptServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //方法执行前的业务逻辑
        //code..
        //执行原始方法（即连接点），并且接收原始方法的返回值
        Object proceed = proceedingJoinPoint.proceed();
        //方法执行后的业务逻辑
        //code..
        //返回原始方法的返回值
        return proceed;
    }
}

ProceedingJoinPoint是一个接口类，指代程序执行过程中的一个特定点，其中包含了原始方法的全部内容，包括方法名，参数值等。

在使用 @Around通知类型时，需要将该对象作为参数传递进来，用于后续执行原始方法或获取原始方法的其他信息。

ProceedingJoinPoint仅能作用于 @Around 类型的通知上。

2.@Before 通知类型

介绍：此注解标注的方法仅在原始方法执行前执行

@Aspect
@Component
@Slf4j
public class TestAspect {
    @Before("execution(* com.shawn.springboot03.service.*.*(..))")
    public void before(){
        // 方法执行前的业务逻辑
        //code..
    }
}

3.@After 通知类型

介绍：此注解标注的方法，仅在原始方法执行后执行，且不论原始方法是否执行，该通知都会执行

@Aspect
@Component
@Slf4j
public class TestAspect {
    @After("execution(* com.shawn.springboot03.service.*.*(..))")
    public void after(){
        // 方法执行后的业务逻辑
        //code..
    }
}

4.@AfterReturning 通知类型

介绍：此注解标注的方法，仅在原始方法执行完成后通知，即当原始方法执行发生异常时，@AfterReturning 通知不会被执行。

@Aspect
@Component
@Slf4j
public class TestAspect {
    @AfterReturning("execution(* com.shawn.springboot03.service.*.*(..))")
    public void afterReturning(){
        //方法执行完成的业务逻辑
        //code..
    }
}

5.@AfterThrowing通知类型

介绍：次注解标注的方法，仅在原始方法执行过程中发生了异常，才会执行。

@Aspect
@Component
@Slf4j
public class TestAspect {
    /**
     * 声明一个空的方法体来定义切入点表达式
     * 使用 @Pointcut 注解来定义切入点表达式
     */
    @Pointcut("execution(* com.shawn.springboot03.service.impl.DeptServiceImpl.*(..))")
    private void point(){};
    @After("point()")
    public void after(){
        // 方法执行后的业务逻辑
        //code..
    }
}

4.定义切入点

以上示例中的切入点表达式均相似，可以利用封装的思想，将切入点表达式全部抽取出来，在需要的时候直接使用即可。

想要实现以上需求，则需要自定义切入点表达式

通过 @Pointcut 注解，来定义切入点表达式，然后在需要编写切入点表达式的地方调用即可。

@Aspect
@Component
public class TestAspect {
    @Pointcut("@annotation(com.shawn.springboot03.annotation.OperationLog)")
    private void point(){};
    @AfterThrowing("point()")
    public void afterThrowing(){
        //方法执行时抛出异常的业务逻辑
        //code..
    }
}

注意：如果自定义的切入点访问修饰符为 public ,则该表达式还可以在其他切面类中被引用。具体使用可根据实际业务情况决定。

定义切入点总共有两种办法，一种是通过方法名来定义切入点，还可以通过注解来定义切入点。

示例：以下示例使用自定义注解作为切入点，使用了以下自定义注解的方法会执行通知。

@Aspect
@Component
@Slf4j
@Order(3)
public class TestAspect {
    @Pointcut("execution(* com.shawn.springboot03.service.impl.DeptServiceImpl.*(..))")
    private void point(){};
    @After("point()")
    public void after(){
        // 方法执行后的业务逻辑
        //code..
    }
}

5.通知顺序

当有多个切入点都匹配到了目标方法，目标方法运行时，多个通知都会被执行。

某些情况下则需要控制通知的顺序，可以在切面类上使用 @Order 注解来控制顺序

@Aspect
@Component
@Slf4j
@Order(3)
public class TestAspect {
    @Pointcut("execution(* com.shawn.springboot03.service.impl.DeptServiceImpl.*(..))")
    private void point(){};
    @After("point()")
    public void after(){
        // 方法执行后的业务逻辑
        //code..
    }
}

注意：@Order(number) 注解中，数字越小的越先运行，越大的越后运行。

默认情况下，按照切面类的类名排序顺序执行。

四切入点表达式

1.execution

execution 主要根据方法的返回值，包名类名，方法名，方法参数等信息来匹配，语法为：

execution（访问修饰符? 返回值包名.类名.?方法名(方法参数) throw 异常? ）

其中带 ? 的表示可以省略的部分

访问修饰符：可省略（比如：public，protected）
包名.类名：可省略
throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

以下是一个完整示例：

@Before ("execution(public void com.itheima.service.impl.DeptserviceImpl.delete (java.lang.Integer)) throws Exception")
private void point(){};

省略后的示例：

@Before ("execution(void delete (java.lang.Integer))")
private void point(){};

此时，所有 void delete (java.lang.Integer) 方法都将被匹配到。

注意： * 用于描述匹配单个， … 可以用来匹配多个连续，？表示可省略

在这里插入图片描述

2.@annotation

@annotation 切入点表达式，用于匹配标识有特定注解的方法。

示例：

@Pointcut("@annotation(com.shawn.annotation.OperationLog)")
private void point(){};

五连接点

在Spring中使用JoinPoint抽象了连接点，使用它可以获取方法执行时的相关信息，入目标类名，方法名，方法参数等。

1.对于 @Around 通知，获取连接点信息只能使用 ProceedingJoinPoint

@Around("point()")
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    //获取目标类名
    String name = proceedingJoinPoint.getTarget().getClass().getName();
    log.info("获取目标类名:"+name);
    //获取方法执行参数
    Object[] args = proceedingJoinPoint.getArgs();
    log.info("获取方法执行参数:"+JSON.toJSONString(args));
    //获取目标方法名
    String methodName = proceedingJoinPoint.getSignature().getName();
    log.info("获取目标方法名:"+methodName);
    //执行原始方法（即连接点），并且接收原始方法的返回值
    Object proceed = proceedingJoinPoint.proceed();
    //获取方法的返回值
    log.info("获取方法的返回值:"+JSON.toJSONString(proceed));
    //返回原始方法的返回值
    return proceed;
}

proceedingJoinPoint.proceed()得到目标方法的结果再返回，此处可以对目标方法执行的结果进行篡改。

2.对于其他四种通知，获取连接点信息只能使用 JoinPoint , 它是 ProceedingJoinPoint 的父类。

@Before("point()")
public void before(JoinPoint joinPoint){
    // 获取目标方法的类名
    String name = joinPoint.getTarget().getClass().getName();
    log.info("获取目标方法的类名："+name);
    String methodName = joinPoint.getSignature().getName();
    log.info("获取目标方法的方法名："+methodName);
    //获取目标方法的运行参数
    Object[] args = joinPoint.getArgs();
    log.info("获取目标方法的参数："+JSON.toJSONString(args));
}

3.除@Around 通知外，还可以获取到方法执行结果的通知类型为 @AfterReturning，@AfterReturning 在方法执行完成并且无异常时通知。

在定义@AfterReturning通知类型时，使用 pointcut 属性定义切入点，returning属性定义返回值对象，然后在方法参数中传入即可。

@AfterReturning(pointcut = "point()",returning = "object")
public void afterReturning(JoinPoint joinPoint, Object object){
    // 获取目标方法的类名
    String name = joinPoint.getTarget().getClass().getName();
    log.info("获取目标方法的类名："+name);
    String methodName = joinPoint.getSignature().getName();
    log.info("获取目标方法的方法名："+methodName);
    //获取目标方法的运行参数
    Object[] args = joinPoint.getArgs();
    log.info("获取目标方法的参数："+JSON.toJSONString(args));
    //获取方法返回值
    log.info("获取方法返回值:"+JSON.toJSONString(object));
}

到此这篇关于Springboot AOP开发的文章就介绍到这了,更多相关Springboot AOP开发内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

Springboot AOP开发教程