Springboot AOP切面

SpringBoot Aop

切面(Aop)

一、什么是切面

AOP（Aspect OrientedProgramming）：面向切面编程，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

二、切面的用途

日志记录，性能统计，安全控制，权限管理，事务处理，异常处理，资源池管理。

三、AOP切面常用注解

四、详细内容

1、切面（Aspect）

2、连接点（Joinpoint）

程序执行过程中的某一行为动作，例如，某一个方法的调用或者抛出异常等行为。

3、通知（Advice）

“切面”对于某个“连接点”所产生的动作。比如，切面类对项目中service包下的所有类的方法进行日志记录的动作就是一个Advice。一个切面可以包含多个Advice：

1. 前置通知：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。注解中使用@Before声明。
2. 后通知：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。注解中使用@After声明。
3. 返回后通知：在某连接点正常完成后执行的通知，不包括抛出异常的情况。注解中使用@AfterReturning声明。
4. 环绕通知：包围一个连接点的通知，可以在方法的调用前后完成自定义的行为，也可以选择不执行。注解中使用@Around声明。
5. 抛出异常后通知： 在方法抛出异常退出时执行的通知。注解中使用@AfterThrowing声明。

通知执行顺序：

前置通知 → 环绕通知连接点之前 → 连接点执行 → 环绕通知连接点之后 → 返回通知 → 后通知 → (如果发生异常)异常通知 → 后通知。

4.切入点（Pointcut）

匹配连接点的断言，在AOP中通知和一个切入点表达式关联。

五、代码操作

Maven依赖

<!--        切面依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

1、定义一个切面类

2、在需要切面的方法上加入@Pointcut注解

@Pointcut使用有两种。

1. 方式一：execution()

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class AopAspect {

    /**
     *  @Pointcut：定义一个切面，所关注的某件事入口
     *  execution()：表达式主体
     *  第一个 *：表示返回值类型， *表示所有类型
     *  com.sapphire.common.service：包名
     *  ..：表示当前包和当前包子包
     *  第二个*：表示类名，*表示所有类
     *  *（..）：*表示方法名，括弧里边表示参数，..表示任何参数
     */
    @Pointcut("execution(* com.sapphire.common.service..*.*(..))")
    public void pointCut(){
    
//        业务逻辑

    }
}

2. 方式二： @annotation()

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class AopAspect {

    /**
     * @annotation()：针对否个注解来定义切面，如下根据@GetMapping进行切面 比如：@GetMapping、@PostMapping、@DeleteMapping
     */
    @Pointcut("@annotation(org.springframework.web.bind.annotation.GetMapping)")
    public void pointCut() {
//        业务逻辑
    }
}

3、指定切面方法之前 @Before

import org.aspectj.lang.annotation.Before;

/**
     *  @Before：在之前做什么，指定的方法在切面切入目标方法之前执行
     *  pointcut()：定义切面入口方法
     */
    @Before("pointCut()")
    public void before(){
//        业务逻辑
    }

4、在指定方法之后做什么@After

import org.aspectj.lang.annotation.After;

 /**
     *   @After：指定的方法在切面切入目标方法之后执行、和@Before注解对应
     *   pointcut()：定义切面入口方法
     */
    @After("pointCut()")
    public void after(){
//        业务逻辑
    }

5、数据增强处理@AfterReturning

/**
     * @AfterReturning ：和 `@After` 有些类似，区别在于 `@AfterReturning` 注解可以用来捕获切入方法执行完之后的返回值，对返回值进行业务逻辑上的增强处理
     * pointcut：切面方法名
     * returning:被切方法的返回值，必须要和参数保持一致，否则会检测不到
     */
    @AfterReturning(pointcut = "pointCut()", returning = "result")
    public void afterReturning(String result) {
//        业务逻辑
    }

6、数据异常处理@AfterThrowing

 /**
     * @AfterThrowing：被切方法执行时抛出异常时会进入 
     * pointcut：切面方法名
     * throwing：属性的值必须要和参数一致
     */
    @AfterThrowing(pointcut = "pointCut()", throwing = "ex")
    public void afterThrowing(Throwable ex) {
//        业务处理
    }

六、Aspect切面类完整示例

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class AopAspect {

    /**
     * @annotation()：针对否个注解来定义切面，如下根据@GetMapping进行切面 比如：@GetMapping、@PostMapping、@DeleteMapping
     */
    @Pointcut("@annotation(org.springframework.web.bind.annotation.GetMapping)")
    public void pointCut() {
        System.out.println("@Pointcut：定义一个切面，所关注的某件事入口\n");
    }

    /**
     *  @Before：在之前做什么，指定的方法在切面切入目标方法之前执行
     *  pointcut()：定义切面入口方法
     */
    @Before("pointCut()")
    public void before(){
//        业务逻辑
    }

    /**
     *   @After：指定的方法在切面切入目标方法之后执行、和@Before注解对应
     *   pointcut()：定义切面入口方法
     */
    @After("pointCut()")
    public void after(){
//        业务逻辑
    }


    /**
     * @AfterReturning ：和 `@After` 有些类似，区别在于 `@AfterReturning` 注解可以用来捕获切入方法执行完之后的返回值，对返回值进行业务逻辑上的增强处理
     * pointcut：切面方法名
     * returning:被切方法的返回值，必须要和参数保持一致，否则会检测不到
     */
    @AfterReturning(pointcut = "pointCut()", returning = "result")
    public void afterReturning(String result) {
//        业务逻辑
    }

    /**
     * @AfterThrowing：被切方法执行时抛出异常时会进入
     * pointcut：切面方法名
     * throwing：属性的值必须要和参数一致
     */
    @AfterThrowing(pointcut = "pointCut()", throwing = "ex")
    public void afterThrowing(Throwable ex) {
//        业务处理
    }
}

七、切面实际业务实现 —— 拦截功能

（一）基于注解拦截

1、引入Maven依赖

<!--        web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
<!--        切面依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2、定义拦截注解 @InterceptAnnotation

package com.sapphire.common.annotation;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InterceptAnnotation {

}

附加：关于自定义注解，参考如下链接

Java自定义注解

3、定义切面类及方法

package com.sapphire.common.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class InterceptAnnotationAspect {

    @Pointcut("@annotation(com.sapphire.common.annotation.InterceptAnnotation)")
    public void interceptPointcut(){

    }

    @Around("interceptPointcut()")
    public Object interceptAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("基于注解拦截的切面类");
        return joinPoint.proceed();
    }
}

其中joinPoint.proceed()执行目标方法，如果没有调用，则不执行目标方法；

proceed传参数的方法可以动态的改变传入目标方法的参数：

（二）基于表达式拦截

表达式：* com.sapphire.common.controller..*.*(..)

1、定义切面类

package com.sapphire.common.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class InterceptControllerAspect {

    @Pointcut("execution(* com.sapphire.common.controller..*.*(..))")
    public void controllerIntercept(){

    }


    @Around("controllerIntercept()")
    public Object controllerInterceptAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("基于表达式进行拦截切面类");
        return joinPoint.proceed();
    }
}

2、切点多个表达式或注解示例

 @Pointcut("execution(* com.example.demo.controller..*.*(..))||@annotation(com.example.demo.anot.PermissionAnnotation)")

（三）测试

1、基于表达式测试

控制台打印结果：

此时执行了基于表达式的切面类中的方法。

2、接口加注解

控制台打印结果：

3、通过@Order注解规定切面类执行顺序

上图控制台打印结果可以看到先执行了注解切面类然后执行表达式切面类，现实中，可以通过@Order(0)注解规定切面类执行顺序，数字越小，执行越靠前。

如下图所示：

测试结果：

表达式切面类先于注解切面类执行。

八、定义切面步骤总结