【AOP】Spring AOP基础 + 实践 完整记录

　　 <!-- 自动扫描注解 -->
    <context:component-scan base-package="com.sxd" />
    <!--Spring aop 使用注解的方式-->
    <aop:aspectj-autoproxy />

package com.sxd.aop;

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

import java.util.Objects;


/**
 * 切面定义
 * ①在类上定义@Aspect和@Component
 * ②@Pointcut()定义切点
 * ③adive方法上，声明在哪一个切点上切入 加入增强逻辑
 */
@Aspect
@Component
public class Aspects {

    /**
     * execution()    表达式:用来匹配执行方法的连接点
     * 【..（两个点）代表零个或多个】
     * 【本例子中  第一个*代表方法的返回值类型可以为任何类型 如果本方法为void，也符合切入条件】
     * 【本例子中  第一个..代表controller包以及子包下】
     * 【本例子中  第二个*代表这个包下的任意类】
     * 【本例子中  第三个*代表这个包下的任意类中的任意方法】
     * 【本例子中  第二个..代表有无参数都可以被切入】
     *
     * args     如果想要切入的方法的参数要符合什么类型的话
     * 【本例子代表入参中，第一个参数类型需要为String类型的才会被切入，之后有零个入参或多个入参】
     *
     */
    @Pointcut(value = "execution(* com.sxd.controller..*.*(..)) && args(String,..)")
    public void pointCut1(){}


    /**
     * within()     表达式用于匹配这个包下的任意类
     */
    @Pointcut(value = "within(com.sxd.controller.*)")
    public void pointCut2(){}

    /**
     * this()       表达式限定了匹配这个类的实例下的方法
     */
    @Pointcut(value = "this(com.sxd.controller.MainController)")
    public void pointCut3(){}

    /**
     * bean()       匹配IOC容器中的bean的名称
     */
    @Pointcut(value = "bean(memberService)")
    public void pointCut4(){}












    /**
     * 下面是各种advice的展示
     *
     * 1》advice的执行优先级：  around方法执行前》before》【方法自己】》around方法执行后》after》afterReturning
     * 2》若有异常
     * advice的执行优先级：around方法执行前》before》【方法自己】》around方法执行后》after》afterReturning
     * 很奇怪为什么两次都是一样的执行优先级，为什么没有进afterThrowing().因为使用了around。
     * 3》注意：Spring AOP的环绕通知会影响到AfterThrowing通知的运行,不要同时使用!
     *
     * 4》注意：在切面的advice里面，一定不要让异常抛出去，影响原方法的执行和返回。
     * 5》JoinPoint 即原方法的入参
     * 6》returning即原方法的返回值
     * 7》如果原方法没有返回值，而这里的advice定义了returning，即使pointCut可以匹配上切点，也不会切入原方法
     */


    @Before("pointCut1()")
    public void justBefore(JoinPoint joinPoint){
        System.out.println("切入方法前");
    }


    @After("pointCut1()")
    public void justAfter(JoinPoint joinPoint){
       Object[] arr = joinPoint.getArgs();
       if(Objects.nonNull(arr) && arr.length >0){
           System.out.println((String)arr[0]);
           System.out.println((Integer)arr[1]);
       }
        System.out.println("切入方法后");
    }

    @AfterReturning(pointcut = "pointCut1()",returning = "returnVal")
    public  void justAfterReturn(JoinPoint joinPoint,Object returnVal){
        System.out.println(returnVal.toString());
        System.out.println("在方法执行完，并未抛异常，能正确返回值的情况下，在返回值之前切入");
    }

    @AfterThrowing(pointcut = "pointCut1()",throwing = "err")
    public  void justAfterThrow(JoinPoint joinPoint,Throwable err){
        System.out.println("在方法执行，抛异常的情况下，切入");
    }

    @Around("pointCut1()")
    public Object justAround(ProceedingJoinPoint proceedingJoinPoint){
        System.out.println("环绕型切入，方法执行前");
        Object a = null;
        try {
             a =  proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("环绕型切入，方法执行后");
        return  a;
    }

}