Springboot AOP开发

时间:2024-02-19 20:48:57

Springboot 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 类,用于演示各种通知类型

  1. @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 {
    @AfterThrowing("execution(* com.shawn.springboot03.service.*.*(..))")
    public void afterThrowing(){
        //方法执行时抛出异常的业务逻辑
        //code..
    }
}

4.定义切入点

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

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

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

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

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

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

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

@Aspect
@Component
public class TestAspect {
    @Pointcut("@annotation(com.shawn.springboot03.annotation.OperationLog)")
    private void point(){};

    @AfterThrowing("point()")
    public void afterThrowing(){
        //方法执行时抛出异常的业务逻辑
        //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));
}