脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Springboot AOP开发

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开发内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 深入理解 Java 中的 Switch 语句示例详解

    深入理解 Java 中的 Switch 语句示例详解

    在Java编程中,switch语句通过表达式值来执行不同代码块,本文介绍switch语法、案例、注意事项,以及与if语句的对比,包括基本语法、关键字、表达式、case常量、break和default的使用,以及如何根据输入的字符输出星期、大小写转换、成绩判断和季节判断等实际应用场景
    2024-10-10
  • java中不定长参数的实例用法

    java中不定长参数的实例用法

    在本篇文章里小编给大家分享的是关于java中不定长参数的使用方法以及相关代码内容，有兴趣的朋友们可以学习参考下。
    2020-02-02
  • Java中常用的日期类图文详解

    Java中常用的日期类图文详解

    Java提供了Date类来处理日期、时间（此处的Date是指java.util包下的Date类,而不是java.sql包下的Date类）,Date对象既包含日期，也包含时间,下面这篇文章主要给大家介绍了关于Java中常用的日期类的相关资料,需要的朋友可以参考下
    2022-11-11
  • IntelliJ IDEA 2020.2 全家桶及以下版本激活工具大全【喜讯】

    IntelliJ IDEA 2020.2 全家桶及以下版本激活工具大全【喜讯】

    这篇文章主要介绍了IntelliJ IDEA 2020.2 全家桶及以下版本激活工具大全【喜讯】,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-09-09
  • Spring实现内置监听器

    Spring实现内置监听器

    这篇文章主要介绍了Spring 实现自定义监听器案例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧，希望能给你带来帮助
    2021-07-07
  • Java Excel Poi字体颜色自定义设置代码

    Java Excel Poi字体颜色自定义设置代码

    最近项目使用POI按模板导出Excel,需要设置单元格的字体为红色,下面这篇文章主要给大家介绍了关于Java Excel Poi字体颜色自定义设置的相关资料,需要的朋友可以参考下
    2024-01-01
  • 深入理解Spring事务及传播机制之原理解析与实际应用

    深入理解Spring事务及传播机制之原理解析与实际应用

    Spring事务管理机制提供了多种传播行为，可以控制事务的范围和隔离级别，保证数据一致性和完整性。在实际应用中，需要根据具体业务场景选择合适的传播行为实现事务控制
    2023-04-04
  • springboot启动时候报错mongodb问题

    springboot启动时候报错mongodb问题

    这篇文章主要介绍了springboot启动时候报错mongodb问题及解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-05-05
  • java使double保留两位小数的多方法 java保留两位小数

    java使double保留两位小数的多方法 java保留两位小数

    这篇文章主要介绍了java使double类型保留两位小数的方法，大家参考使用吧
    2014-01-01
  • javax.validation包里@NotNull等注解的使用方式

    javax.validation包里@NotNull等注解的使用方式

    这篇文章主要介绍了javax.validation包里@NotNull等注解的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-01-01

最新评论