SpringBoot切面使用

package com.zhangqi.aop.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Objects;

/**
 * @Description: <br/>
 * AOP
 * <p>
 * <br/>
 * @Author: Qz1997
 * @create 2021/6/27 18:48
 */
@Aspect
@Component
public class AopAdvice {

    private final Logger log = LoggerFactory.getLogger(AopAdvice.class);


    // -----------以下是切点的定义-----------

    /**
     * 方法执行时触发
     * execution (* com.zhangqi.aop.controller.*.*(..))
     * <p>
     * 方法类型包含Public，Protected等，可省略
     * 方法返回值类型，*可以包含所有的返回值类型
     * 包路径，如“com.demo…*”,表示"com.demo"包以及该包之下子包的所有类型
     * 方法名称，如“add*”,表示所有以add开头的方法，参数：(*)表示任意一个参数，(…)表示所有参数
     * 异常类型，如execution(* *(…) throws Exception)”匹配所有抛出Exception的方法。
     */
    @Pointcut("execution (* com.zhangqi.aop.controller.*.*(..))")
    public void pointCut1() {

    }

    /**
     * 带有注解的方法触发
     * 针对的方法
     */
    @Pointcut("@annotation(com.zhangqi.aop.annotion.ListReturnCheck)")
    public void pointCut2() {

    }

    /**
     * 通过参数
     * args() 匹配不带参数的方法
     * args(java.lang.String) 匹配方法参数是String类型的
     * args(…) 带任意参数的方法
     * args(java.lang.String,…) 匹配第一个参数是String类型的，其他参数任意。最后一个参数是String的同理。
     */
    @Pointcut("args(java.lang.String)")
    public void pointCut3() {

    }

    /**
     * 目标对象使用aop之后生成的代理对象必须是指定的类型才会被拦截，注意是目标对象被代理之后生成的代理对象和指定的类型匹配才会被拦截
     * <p>
     * 若spring创建的对象如果实现了接口，默认使用jdk动态代理，如果没有实现接口，使用cglib创建代理对象
     * <p>
     * 所以 service 是使用jdk动态代理生成的对象，service instanceof ServiceImpl 为 false
     * <p>
     * - @Pointcut("this(com.zhangqi.aop.service.impl.ServiceImpl)")
     * 表示被spring代理之后生成的对象必须为ccom.zhangqi.aop.service.impl.ServiceImpl才会被拦截，
     * 但是service不是ServiceImpl类型的对象了，所以不会被拦截
     * <p>
     */
    @Pointcut("this(com.zhangqi.aop.controller.MyController)")
    public void pointCut4() {

    }

    /**
     * this作用于代理对象，target作用于目标对象
     * this表示目标对象被代理之后生成的代理对象和指定的类型匹配会被拦截，匹配的是代理对象
     * target表示目标对象和指定的类型匹配会被拦截，匹配的是目标对象
     */
    @Pointcut("target(com.zhangqi.aop.controller.MyController)")
    public void pointCut5() {

    }


    /**
     * 是用来指定类型的，指定类型中的所有方法将被拦截是用来指定类型的，指定类型中的所有方法将被拦截
     * <p>
     * within(com.demo.service.impl.UserServiceImpl) 匹配UserServiceImpl类对应对象的所有方法调用，并且只能是UserServiceImpl对象，不能是它的子对象
     * 拦截包中任意方法，不包含子包中的方法
     * within(com.xyz.service.*)
     * 拦截service包及子包中任意类的任意方法
     * within(com.xyz.service..*)
     */
    @Pointcut("within(com.zhangqi.aop.controller.MyController)")
    public void pointCut6() {

    }

    /**
     * 匹配的目标对象的类有一个指定的注解
     * 目标对象中包含com.zhangqi.aop.annotion.ListReturnCheck注解，调用该目标对象的任意方法都会被拦截
     */
    @Pointcut("@target(com.zhangqi.aop.annotion.ListReturnCheck)")
    public void pointCut7() {

    }

    /**
     * 指定匹配必须包含某个注解的类里的所有连接点
     * 目标对象中包含com.zhangqi.aop.annotion.ListReturnCheck注解的类中的所有方法都会被拦截
     * <p>
     * - @target 和 @within 的不同点
     * - @target(注解A)：判断被调用的目标对象中是否声明了注解A，如果有，会被拦截
     * - @within(注解A)： 判断被调用的方法所属的类中是否声明了注解A，如果有，会被拦截
     * - @target关注的是被调用的对象，@within关注的是调用的方法所在的类
     */
    @Pointcut("@within(com.zhangqi.aop.annotion.ListReturnCheck)")
    public void pointCut8() {

    }

    /**
     * 方法参数所属的类型上有指定的注解，被匹配
     * 注意：是方法参数所属的类型上有指定的注解，不是方法参数中有注解
     * <p>
     * 匹配1个参数，且第1个参数所属的类中有Anno1注解
     * <p>
     * - @args(ccom.zhangqi.aop.annotion.ListReturnCheck) 匹配多个参数，且多个参数所属的类型上都有指定的注解
     * - @args(com.zhangqi.aop.annotion.ListReturnCheck,cocom.zhangqi.aop.annotion.ListReturnCheck) 匹配多个参数，且第一个参数所属的类中有Anno1注解
     * - @args(com.zhangqi.aop.annotion.ListReturnCheck,..)
     */
    @Pointcut("@args(com.zhangqi.aop.annotion.ListReturnCheck)")
    public void pointCut9() {

    }

    /**
     * PointCut中可以使用&&、||、!运算
     */
    @Pointcut("pointCut7() && pointCut8()")
    public void pointCut10() {
    }

    // -----------以上是切点的定义-----------


    // -----------以下是通知定义-----------

    /**
     * 前置通知（@Before）：在目标方法调用之前调用通知
     * argNames 切点的方法的参数名
     */
    @Before(value = "pointCut1()", argNames = "id,username")
    public void beforeAdvice(JoinPoint joinPoint, String id, String username) {
        // 这个RequestContextHolder是Springmvc提供来获得请求的东西
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(requestAttributes)).getRequest();

        // 记录下请求内容
        log.info("请求地址 : " + request.getRequestURL().toString());
        log.info("请求方式 : " + request.getMethod());
        log.info("请求IP : " + request.getRemoteAddr());
        log.info("请求的参数 : " + Arrays.toString(joinPoint.getArgs()));

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        // 获取这个被代理的方法
        Method method = signature.getMethod();
        // 是获取包+类名的
        String declaringTypeName = signature.getDeclaringTypeName();
        // 获取了方法名
        String name = signature.getName();
        // 返回的是需要加强的目标类的对象
        Object target = joinPoint.getTarget();
        // 返回的是经过加强后的代理类的对象
        Object aThis = joinPoint.getThis();

    }

    /**
     * 后置通知（@After）：在目标方法完成之后调用通知
     */
    @After("pointCut1()")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("afterAdvice...");
    }

    /**
     * 环绕通知（@Around）：在目标方法完成之后调用通知
     */
    @Around("pointCut1()")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) {
        System.out.println("Around -- before");
        try {
            return proceedingJoinPoint.proceed();
        } catch (Throwable t) {
            return "";
        }
 		System.out.println("Around -- after");
    }

    /**
     * 返回通知（@AfterReturning）：在目标方法成功执行之后调用通知
     *
     * @param result 代理方法执行的结果
     */
    @AfterReturning(returning = "result", pointcut = "pointCut1())")
    public void doAfterReturning(JoinPoint joinPoint, Object result) throws Exception {

    }


    /**
     * 异常通知（@AfterThrowing）：在目标方法出现异常调用通知
     *
     * @param e 异常信息
     */
    @AfterThrowing(throwing = "e", pointcut = "pointCut1())")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) throws Exception {

    }


    // -----------以上是通知定义-----------


    /*
     * 最后，再记录一下各个不同的advice的拦截顺序的问题。
     *
     * 情况一，只有一个Aspect类：
     *
     * 　　无异常：@Around（proceed()之前的部分） → @Before → 方法执行 → @Around（proceed()之后的部分） → @After → @AfterReturning
     *
     * 　　有异常：@Around（proceed(之前的部分)） → @Before → 扔异常ing → @After → @AfterThrowing
     * （大概是因为方法没有跑完抛了异常，没有正确返回所有@Around的proceed()之后的部分和@AfterReturning两个注解的加强没有能够织入）
     *
     *
     *
     * 情况二，同一个方法有多个@Aspect类拦截：
     *
     * 　　单个Aspect肯定是和只有一个Aspect的时候的情况是一样的，但不同的Aspect里面的advice的顺序呢？？
     * 答案是不一定，像是线程一样，没有谁先谁后，除非你给他们分配优先级，同样地，在这里你也可以为@Aspect分配优先级，这样就可以决定谁先谁后了。
     *
     * 优先级有两种方式：
     *
     * 实现org.springframework.core.Ordered接口，实现它的getOrder()方法
     * 给aspect添加@Order注解，该注解全称为：org.springframework.core.annotation.Order
     * 不管是哪种，都是order的值越小越先执行：
     *
     * 复制代码
     * @Order(5)
     * @Component
     * @Aspect
     * public class Aspect1 {
     *     // ...
     * }
     *
     * @Order(6)
     * @Component
     * @Aspect
     * public class Aspect2 {
     *     // ...
     * }
     * 复制代码
     *
     *
     * 这样Aspect1就永远比Aspect2先执行了。
     *
     *
     * 注意点：
     *
     * 如果在同一个 aspect 类中，针对同一个 pointcut，定义了两个相同的 advice(比如，定义了两个 @Before)，那么这两个 advice
     * 的执行顺序是无法确定的，哪怕你给这两个 advice 添加了 @Order 这个注解，也不行。这点切记。
     * 对于@Around这个advice，不管它有没有返回值，但是必须要方法内部，调用一下 pjp.proceed();否则，Controller
     * 中的接口将没有机会被执行，从而也导致了 @Before这个advice不会被触发。
     *
     */
}