前言

Aop 是面向切面编程，项目中一般都使用aop做日志、权限等操作，比如我们想要打印所有接口的日志，就可以用Aop来实现。
下面用一个打印接口的日志来讲述Aop的快速使用。

如果你不想知道Aop的一些具体注解的单独讲述，可以直接进入到案例，案例中也会对Aop的注解做讲述和使用。

1、相关注解

类注解

• @Aspect ：表明是一个切面类；

方法注解

• @Pointcut ：切入点，该注解表示从哪里做切入；
• @Before ：前置通知，在切入点之前执行，可以理解成调用接口或者方法之前执行；
• @After ：后置通知，在切入点之后执行，可以理解成调用完该接口或者方法之后执行；
• @AfterRuturning ：返回通知，可以理解成调用完该接口或者方法返回结果之后执行；
• @AfterThrowing ：异常通知，可以理解成调用该接口或者方法时出现异常之后执行；
• @Around ：环绕通知，可以理解成这一个注解用来控制调用接口或方法；

2、execution 表达式

execution 表达式 写法是：访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)

例一【execution 表达式 的限制使用】

下面这个例子，展示一些详细的使用

execution(public com.api.controller.User.findUserByUserId(..))

public 是该方法的返回值
com.api.controller 是该类所在的包位置
User 是类名
findUserByUserId 是该类的方法名
(..) 这个是参数，.. 表示通配所有参数

例二【execution 表达式 的通配使用】

execution(* com.api.controller..*.*(..))

第一个 * 是通配返回值
com.api.controller 是该类所在的包位置
.* 是通配com.api.controller这个包下所有的类
* 是类中所有方法
(..) 表示通配所有参数

3、相关pom依赖

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

4、案例

在做案例之前，先创建一个测试接口，方便测试Aop。

创建接口

package com.api.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {

    @GetMapping("/findUserByUserId")
    public String findUserByUserId(@RequestParam(value = "userId") String userId) {
        log.info("进入 findUserByUserId 接口 参数userId: {}", userId);
        return "findUserByUserId 接口 返回的数据";
    }

}

Aop使用 方式一【@Before 、@After 、@AfterRuturning、@AfterThrowing版】

package com.api.aop;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;


@Component
@Aspect
@Slf4j
public class AOPTest {

    // @Pointcut 注解的作用就是要根据一种规则切入到某个位置, 我在这里使用的是 execution 表达式规则
    @Pointcut("execution(* com.api.controller..*.*(..))")
    public void pointcut() {
    }

    /***
     * 前置通知
     */
    @Before("pointcut()")
    public void deBefore(JoinPoint joinPoint) {
        log.info("前置通知");
        log.info("参数 {}", joinPoint.getArgs());
        final Signature signature = joinPoint.getSignature();
        log.info("接口名称 name {}", signature.getName());
        log.info("类名 declaringTypeName {}", signature.getDeclaringTypeName());

        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        log.info("接口地址 {}", request.getRequestURL().toString());
        log.info("接口请求方式 {}", request.getMethod());

    }

    /***
     * 后置通知
     */
    @After("pointcut()")
    public void after(JoinPoint joinPoint){
        log.info("后置通知");
    }

    /***
     * 返回结果通知
     */
    @AfterReturning(returning = "o", pointcut = "pointcut()")
    public void afterReturning(Object o) {
        log.info("返回结果通知");
        log.info("结果 {}", o);
    }

    /***
     * 异常通知
     */
    @AfterThrowing(throwing = "e", pointcut = "pointcut()")
    public void afterThrowing(JoinPoint joinPoint, Exception e){
        log.info("异常通知");
        log.info("产生异常的方法 {}", joinPoint);
        log.info("异常种类 {}", e);
    }
}

接下来调用一下刚刚写的接口，打印日志如下：

执行顺序图如下：

先进入前置通知，执行接口，如果接口中出现异常就进入异常通知，无异常进入结果通知，最后进入后置通知。

Aop使用 方式二【@Around版】

package com.api.aop;

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


@Component
@Aspect
@Slf4j
public class AOPTest {

    // @Pointcut 注解的作用就是要根据一种规则切入到某个位置, 我在这里使用的是 execution 表达式
    @Pointcut("execution(* com.api.controller..*.*(..))")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object Around(ProceedingJoinPoint joinPoint) {
        log.info("前置通知");
        log.info("参数 {}", joinPoint.getArgs());
        final Signature signature = joinPoint.getSignature();
        log.info("接口名称 name {}", signature.getName());
        log.info("类名 declaringTypeName {}", signature.getDeclaringTypeName());
        Object proceed = null;
        try {
            // 进入接口
            proceed = joinPoint.proceed();
            log.info("返回结果通知");
            
        } catch (Throwable throwable) {
            log.info("异常通知");
            throw new RuntimeException(throwable);
            
        } finally {
            log.info("后置通知");
            
        }

        return proceed;
    }
}

接下来调用一下刚刚写的接口，打印日志如下：

End