Spring中AOP的通知类型有以下⼏种:

• @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏
• @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏
• @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏
• @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏
•  @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

@Aspect
@Slf4j
public class AspectDemo {
    /**
     * 前置通知
     */
    @Before("execution(* com.cl.springaop.controller.*.*(..))")
    public void doBefore(){
        log.info("AspectDemo do before......");
    }//是否发生异常，都会执行（再执行方法前）优先级小于around

    /**
     * 后置通知
     */
    @After("execution(* com.cl.springaop.controller.*.*(..))")
    public void doAfter(){
        log.info("AspectDemo do after......");
    }//是否发生异常，都会执行（再执行方法后） 优先级小于around

    /**
     *添加环绕通知
     */
    //around必须有返回值，需要将目标返回值返回，否则会没有返回值
    @Around("execution(* com.cl.springaop.controller.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
               log.info("AspectDemo do around before......");
        Object result=null;
        result=joinPoint.proceed();
        log.info("AspectDemo do around after.......");
        return  result;
    }//发生异常就不会返回结果

    /**
     * 返回后通知
     */
    @AfterReturning("execution(* com.cl.springaop.controller.*.*(..))")
    public void doAfterReturning(){
        log.info("AspectDemo do AfterReturning......");
    }//没有异常执行

    /**
     * 抛出异常后通知
     */
    @AfterThrowing("execution(* com.cl.springaop.controller.*.*(..))")
    public void doAfterThrowing(){
        log.info("AspectDemo do AfterThrowing......");
    }//有异常执行
}

写一些测试程序：

@RestController
@Slf4j
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/t1")
    public String t1(){
        log.info("执行t1方法");
        return "t1";
    }

    @RequestMapping("/t2")
    public String t2(){
        log.info("执行t2方法.......");
        int a=10/0;
        return "t2";
    }
}

1. 正常运⾏的情况

程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执⾏

从上图也可以看出来,

@Around 标识的通知⽅法包含两部分, ⼀个"前置逻辑", ⼀个"后置逻辑". 其中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏, "后置逻辑" 会晚于 @After 标识的通知⽅法执⾏

2.异常时的情况

程序发⽣异常的情况下：

• • @AfterReturning 标识的通知⽅法不会执⾏， @AfterThrowing 标识的通知⽅法执⾏了
• • @Around 环绕通知中原始⽅法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执⾏了(因为原始⽅法调⽤出异常了)

注意事项:

• • @Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他 ​​​​​​​通知不需要考虑⽬标⽅法执⾏.
• • @Around 环绕通知⽅法的返回值, 必须指定为Object, 来接收原始⽅法的返回值, 否则原始⽅法执⾏完毕, 是获取不到返回值的.
• • ⼀个切⾯类可以有多个切点.

 @Pointcut("execution(* com.cl.springaop.controller.*.*(..))")
    public void pt(){};

    @Pointcut("execution(* com.cl.springaop.controller.*.*(..))")
    public void pt(){};

    /**
     * 前置通知
     */
    @Before("pt()")
    public void doBefore(){
        log.info("AspectDemo do before......");
    }//是否发生异常，都会执行（再执行方法前）优先级小于around

    /**
     * 后置通知
     */
    @After("pt()")
    public void doAfter(){
        log.info("AspectDemo do after......");
    }//是否发生异常，都会执行（再执行方法后） 优先级小于around

当切点定义使⽤private修饰时, 仅能在当前切⾯类中使⽤,

当其他切⾯类也要使⽤当前切点定义时, 就需要把 private改为public. 

引⽤⽅式为: 全限定类名.⽅法名()

@Component
@Aspect
@Slf4j
public class AspectDemo2 {
    @Before("com.cl.springaop.aspect.AspectDemo.pt()")
    public void doBefore(){
        log.info(" AspectDemo2 do before......");
    }
}

🎓切⾯优先级 @Order

为防⽌⼲扰, 我们把AspectDemo这个切⾯先去掉(把 @Component 注解去掉就可以 )

🎓切点表达式

上⾯的代码中, 我们⼀直在使⽤切点表达式来描述切点. 下⾯我们来介绍⼀下切点表达式的语法.

切点表达式常⻅有两种表达⽅式

• 1. execution(RR)：根据⽅法的签名来匹配
• 2. @annotation(RR) ：根据注解匹配

📝execution表达式

execution(< 访问修饰符 > < 返回类型 > < 包名 . 类名 . ⽅法 ( ⽅法参数 )> < 异常 >)

📝@annotation

实现步骤：

• 1. 编写⾃定义注解
• 2. 使⽤ @annotation 表达式来描述切点
• 3. 在连接点的⽅法上添加⾃定义注解

UserController

@Component
@RestController
@Slf4j
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/u1")
    public String u1(){
        log.info("执行u1方法");
        return "u1";
    }//由于没有引入注解，所以没有

    @RequestMapping("/u2")
    public String u2(){
        log.info("执行u2方法");
        return "u2";
    }
}

TestController

@RestController
@Slf4j
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/t1")
    public String t1(){
        log.info("执行t1方法");
        return "t1";
    }

    @RequestMapping("/t2")
    public String t2(){
        log.info("执行t2方法.......");
        int a=10/0;
        return "t2";
    }
}

🎈⾃定义注解 @MyAspect

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MyAspect {
}

@Aspect
@Component
@Slf4j
public class MyAspectDemo {
    @Around("@annotation(com.cl.springaop.config.MyAspect)")
    public Object doAround(ProceedingJoinPoint joinPoint)  {
        log.info("MyAspectDemo do around before.....");
        Object result= null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            log.error("发生异常，e："+e);
        }
        log.info("MyAspectDemo do around after.....");
        return result;
    }
}

   @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public Object doAround2(ProceedingJoinPoint joinPoint)  {
        log.info("RequestMapping do around before.....");
        Object result= null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            log.error("发生异常，e："+e);
        }
        log.info("RequestMapping do around after.....");
        return result;
    }

🎈添加⾃定义注解

对testController中的t2测试

没有打印结果。

🚩Spring AOP的实现⽅式(常⻅⾯试题)

• 1. 基于注解 @Aspect
• 2. 基于⾃定义注解 (参考⾃定义注解 @annotation 部分的内容)
• 3. 基于Spring API (通过xml配置的⽅式, ⾃从SpringBoot ⼴泛使⽤之后, 这种⽅法⼏乎看不到了)
• 4. 基于代理来实现(更加久远的⼀种实现⽅式, 写法笨重, 不建议使⽤)

背挺直一点，向前靠一点。