SpringBoot-AOP切面-接口请求时不走定时任务-发送通知-Aspect全解析-Before-Aspect-After-AfterThrowing

更多说明
https://blog.csdn.net/lmx125254/article/details/84398412
https://blog.csdn.net/weixin_45799178/article/details/114982934
https://www.cnblogs.com/cnndevelop/p/10531346.html 最好找到排版好的复制下来

《SpringBoot 三种拦截http请求方式Filter,interceptor和aop》
https://blog.csdn.net/u014496893/article/details/112286634

--------------------------------------------------------------------------------

EduMigrateTaskControlAspect.java

package cn.jiangjiesheng.edu.service.train.migrate.aspect;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
* 更多说明 https://blog.csdn.net/lmx125254/article/details/84398412
*/
@Aspect
@Component
@Slf4j
public class EduMigrateTaskControlAspect {

@Getter
@Setter
public static boolean isMigrateTraining = false;

// 第一个*代表返回类型不限
// 第二个*代表所有类(.java)
// 第三个*代表所有方法
// (..) 代表参数不限
// @Pointcut("execution(public * com.lmx.blog.controller.*.*(..))")

// @Before("execution(* cn.jiangjiesheng.edu.controller.handleOldData.train.EduTrainMigrateController.*(..)) && @annotation(org.springframework.web.bind.annotation.GetMapping)")
// public void before(JoinPoint joinPoint) throws Throwable {
// 有异步的情况
// EduMigrateTaskControlAspect.isMigrateTraining = true;
// }

// @After("execution(* cn.jiangjiesheng.edu.controller.handleOldData.train.EduTrainMigrateController.*(..)) && @annotation(org.springframework.web.bind.annotation.GetMapping)")
// public void after() throws Throwable {
// 有异步的情况
// EduMigrateTaskControlAspect.isMigrateTraining = false;
// }

@AfterThrowing("within(cn.jiangjiesheng.edu.controller.handleOldData.train.EduTrainMigrateController)")
public void afterThrowing() {
//执行afterThrowing时，after 也会执行
log.error("afterThrowing拦截到迁移接口出现异常（nginx超时可能也会走到这里）");
EduMigrateTaskControlAspect.isMigrateTraining = false;
}

/////////////////////////////////////////////////////////////////////

/**
* 配置织入点
*/
@Pointcut("@annotation(org.springframework.scheduling.annotation.Scheduled)")
public void taskControlPointCut() {
}

@Around("taskControlPointCut()")
public Object doAround(ProceedingJoinPoint point) throws Throwable {
// 如果不在迁移
if (!isMigrateTraining) {
// 执行当前任务
return point.proceed();
}
log.warn("迁移进行中，不走定时任务");
return null;
}
}
--------------------------------------------------------------------------------
EduTrainCourseOrExamChangeAspect.java

package cn.jiangjiesheng.edu.component.aspect;

import cn.jiangjiesheng.commons.utils.UserInfoUtil;
import cn.jiangjiesheng.edu.core.executor.AfterCommitExecutor;
import cn.jiangjiesheng.edu.entity.train.EduOfflineCourse;
import cn.jiangjiesheng.edu.service.train.EduTrainRemindService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

/**
* 结合 @Transactional 实现异步处理 ，不影响主流程
*/
@Aspect
@Configuration
@Slf4j
public class EduTrainCourseOrExamChangeAspect {

@Autowired
private EduTrainRemindService eduTrainRemindService;

@Autowired
private AfterCommitExecutor afterCommitExecutor;

@AfterReturning("@annotation(cn.jiangjiesheng.edu.component.aspect.annotation.EduTrainCourseOrExamChangeCut)")
public void eduTrainCourseOrExamChanged(JoinPoint joinPoint) throws Throwable {
String containerId = UserInfoUtil.getCurContainerId();
afterCommitExecutor.execute(() -> doEduTrainCourseOrExamChanged(containerId, joinPoint.getArgs()));
}

private void doEduTrainCourseOrExamChanged(String containerId, Object[] args) {
for (Object arg : args) {
if (arg instanceof EduOfflineCourse) {
EduOfflineCourse eduOfflineCourseVo = (EduOfflineCourse) arg;
if (eduOfflineCourseVo.getId() != null) {
//编辑场景
return;
}
log.info("线下课程增加入参：eduOfflineCourseVo：{}", eduOfflineCourseVo);
eduTrainRemindService.remindUserWhenChangeCourseOrExam(containerId, eduOfflineCourseVo.getImplementId());
}
}
}
}

EduTrainCourseOrExamChangeCut.java
package cn.jiangjiesheng.edu.component.aspect.annotation;

import java.lang.annotation.*;

/**
* 发布后课程或考试发生变化
*/
@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface EduTrainCourseOrExamChangeCut {
}
--------------------------------------------------------------------------------
@Aspect 切面注解使用
来自 https://www.cnblogs.com/dd1992dd/p/12851620.html
https://blog.csdn.net/u012326462/article/details/82529835

Spring AOP面向切面编程，可以用来配置事务、做日志、权限验证、在用户请求时做一些处理等等。用@Aspect做一个切面，就可以直接实现。

1.首先定义一个切面类，加上@Component @Aspect这两个注解

@Component
@Aspect
public class LogAspect {

private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

}

2.定义切点
1 private final String POINT_CUT = "execution(public * com.xhx.springboot.controller.*.*(..))";
2
3 @Pointcut(POINT_CUT)
4 public void pointCut(){}
切点表达式中，..两个点表明多个，*代表一个， 上面表达式代表切入com.xhx.springboot.controller包下的所有类的所有方法，方法参数不限，返回类型不限。 其中访问修饰符可以不写，不能用*，，第一个*代表返回类型不限，第二个*表示所有类，第三个*表示所有方法，..两个点表示方法里的参数不限。 然后用@Pointcut切点注解，想在一个空方法上面，一会儿在Advice通知中，直接调用这个空方法就行了，也可以把切点表达式卸载Advice通知中的，单独定义出来主要是为了好管理。

3.Advice，通知增强，主要包括五个注解Before,After,AfterReturning,AfterThrowing,Around，下面代码中关键地方都有注释，我都列出来了。
@Before 在切点方法之前执行
@After 在切点方法之后执行
@AfterReturning 切点方法返回后执行
@AfterThrowing 切点方法抛异常执行
@Around 属于环绕增强，能控制切点执行前，执行后，，用这个注解后，程序抛异常，会影响@AfterThrowing这个注解


1 package com.xhx.springboot.config;
2
3 import com.fasterxml.jackson.core.JsonProcessingException;
4 import com.fasterxml.jackson.databind.ObjectMapper;
5 import org.aspectj.lang.JoinPoint;
6 import org.aspectj.lang.ProceedingJoinPoint;
7 import org.aspectj.lang.Signature;
8 import org.aspectj.lang.annotation.*;
9 import org.aspectj.lang.reflect.SourceLocation;
10 import org.slf4j.Logger;
11 import org.slf4j.LoggerFactory;
12 import org.springframework.stereotype.Component;
13 import org.springframework.web.context.request.RequestContextHolder;
14 import org.springframework.web.context.request.ServletRequestAttributes;
15
16 import javax.servlet.http.HttpServletRequest;
17 import java.util.Arrays;
18
19 @Component
20 @Aspect
21 public class LogAspect {
22
23 private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
24 private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
25
26 private final String POINT_CUT = "execution(public * com.xhx.springboot.controller.*.*(..))";
27
28 @Pointcut(POINT_CUT)
29 public void pointCut(){}
30
31 @Before(value = "pointCut()")
32 public void before(JoinPoint joinPoint){
33 logger.info("@Before通知执行");
34 //获取目标方法参数信息
35 Object[] args = joinPoint.getArgs();
36 Arrays.stream(args).forEach(arg->{ // 大大
37 try {
38 logger.info(OBJECT_MAPPER.writeValueAsString(arg));
39 } catch (JsonProcessingException e) {
40 logger.info(arg.toString());
41 }
42 });
43
44
45 //aop代理对象
46 Object aThis = joinPoint.getThis();
47 logger.info(aThis.toString()); //com.xhx.springboot.controller.HelloController@69fbbcdd
48
49 //被代理对象
50 Object target = joinPoint.getTarget();
51 logger.info(target.toString()); //com.xhx.springboot.controller.HelloController@69fbbcdd
52
53 //获取连接点的方法签名对象
54 Signature signature = joinPoint.getSignature();
55 logger.info(signature.toLongString()); //public java.lang.String com.xhx.springboot.controller.HelloController.getName(java.lang.String)
56 logger.info(signature.toShortString()); //HelloController.getName(..)
57 logger.info(signature.toString()); //String com.xhx.springboot.controller.HelloController.getName(String)
58 //获取方法名
59 logger.info(signature.getName()); //getName
60 //获取声明类型名
61 logger.info(signature.getDeclaringTypeName()); //com.xhx.springboot.controller.HelloController
62 //获取声明类型 方法所在类的class对象
63 logger.info(signature.getDeclaringType().toString()); //class com.xhx.springboot.controller.HelloController
64 //和getDeclaringTypeName()一样
65 logger.info(signature.getDeclaringType().getName());//com.xhx.springboot.controller.HelloController
66
67 //连接点类型
68 String kind = joinPoint.getKind();
69 logger.info(kind);//method-execution
70
71 //返回连接点方法所在类文件中的位置 打印报异常
72 SourceLocation sourceLocation = joinPoint.getSourceLocation();
73 logger.info(sourceLocation.toString());
74 //logger.info(sourceLocation.getFileName());
75 //logger.info(sourceLocation.getLine()+"");
76 //logger.info(sourceLocation.getWithinType().toString()); //class com.xhx.springboot.controller.HelloController
77
78 ///返回连接点静态部分
79 JoinPoint.StaticPart staticPart = joinPoint.getStaticPart();
80 logger.info(staticPart.toLongString()); //execution(public java.lang.String com.xhx.springboot.controller.HelloController.getName(java.lang.String))
81
82
83 //attributes可以获取request信息 session信息等
84 ServletRequestAttributes attributes =
85 (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
86 HttpServletRequest request = attributes.getRequest();
87 logger.info(request.getRequestURL().toString()); //http://127.0.0.1:8080/hello/getName
88 logger.info(request.getRemoteAddr()); //127.0.0.1
89 logger.info(request.getMethod()); //GET
90
91 logger.info("before通知执行结束");
92 }
93
94
95 /**
96 * 后置返回
97 * 如果第一个参数为JoinPoint，则第二个参数为返回值的信息
98 * 如果第一个参数不为JoinPoint，则第一个参数为returning中对应的参数
99 * returning：限定了只有目标方法返回值与通知方法参数类型匹配时才能执行后置返回通知，否则不执行，
100 * 参数为Object类型将匹配任何目标返回值
101 */
102 @AfterReturning(value = POINT_CUT,returning = "result")
103 public void doAfterReturningAdvice1(JoinPoint joinPoint,Object result){
104 logger.info("第一个后置返回通知的返回值："+result);
105 }
106
107 @AfterReturning(value = POINT_CUT,returning = "result",argNames = "result")
108 public void doAfterReturningAdvice2(String result){
109 logger.info("第二个后置返回通知的返回值："+result);
110 }
111 //第一个后置返回通知的返回值：姓名是大大
112 //第二个后置返回通知的返回值：姓名是大大
113 //第一个后置返回通知的返回值：{name=小小, id=1}
114
115
116 /**
117 * 后置异常通知
118 * 定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法；
119 * throwing:限定了只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行，
120 * 对于throwing对应的通知方法参数为Throwable类型将匹配任何异常。
121 * @param joinPoint
122 * @param exception
123 */
124 @AfterThrowing(value = POINT_CUT,throwing = "exception")
125 public void doAfterThrowingAdvice(JoinPoint joinPoint,Throwable exception){
126 logger.info(joinPoint.getSignature().getName());
127 if(exception instanceof NullPointerException){
128 logger.info("发生了空指针异常!!!!!");
129 }
130 }
131
132 @After(value = POINT_CUT)
133 public void doAfterAdvice(JoinPoint joinPoint){
134 logger.info("后置通知执行了!");
135 }
136
137 /**
138 * 环绕通知：
139 * 注意:Spring AOP的环绕通知会影响到AfterThrowing通知的运行,不要同时使用
140 *
141 * 环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。
142 * 环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型
143 */
144 @Around(value = POINT_CUT)
145 public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint){
146 logger.info("@Around环绕通知："+proceedingJoinPoint.getSignature().toString());
147 Object obj = null;
148 try {
149 obj = proceedingJoinPoint.proceed(); //可以加参数
150 logger.info(obj.toString());
151 } catch (Throwable throwable) {
152 throwable.printStackTrace();
153 }
154 logger.info("@Around环绕通知执行结束");
155 return obj;
156 }
157 }

执行前后顺序是这样

1 : @Around环绕通知
2 : @Before通知执行
3 : @Before通知执行结束
4 : @Around环绕通知执行结束
5 : @After后置通知执行了!
6 : @AfterReturning第一个后置返回通知的返回值：18

org.aspectj.lang.JoinPoint ： 方法中的参数JoinPoint为连接点对象，它可以获取当前切入的方法的参数、代理类等信息，因此可以记录一些信息，验证一些信息等。
org.aspectj.lang.ProceedingJoinPoint： 为JoinPoint的子类，多了两个方法
public Object proceed() throws Throwable; //调用下一个advice或者执行目标方法，返回值为目标方法返回值，因此可以通过更改返回值，修改方法的返回值
public Object proceed(Object[] args) throws Throwable; //参数为目标方法的参数 因此可以通过修改参数改变方法入参
可以用下面的方式获取request、session等对象
1 //attributes可以获取request信息 session信息等
2 ServletRequestAttributes attributes =
3 (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
4 HttpServletRequest request = attributes.getRequest();
下面介绍一下切点表达式：
1.execution(方法修饰符 返回类型 方法全限定名(参数)) 主要用来匹配整个方法签名和返回值的
"execution(public * com.xhx.springboot.controller.*.*(..))"
*只能匹配一级路径
..可以匹配多级，可以是包路径，也可以匹配多个参数
+ 只能放在类后面，表明本类及所有子类
还可以按下面这么玩，所有get开头的，第一个参数是Long类型的
@Pointcut("execution(* *..get*(Long,..))")


2. within(类路径) 用来限定类，同样可以使用匹配符
下面用来表示com.xhx.springboot包及其子包下的所有类方法
"within(com.xhx.springboot..*)"
3. this与target
this与target在用法上有些重合，理解上有对比性。
this表示当前切入点表达式所指代的方法的对象的实例，即代理对象是否满足this类型
target表示当前切入点表达式所指代的方法的目标对象的实例 即是否是为target类做的代理
如果当前对象生成的代理对象符合this指定的类型，则进行切面，target是匹配业务对象为指定类型的类，则进行切面。
生成代理对象时会有两种方法，一个是CGLIB一个是jdk动态代理。
用下面三个例子进行说明：
this(SomeInterface)或target(SomeInterface)：这种情况下，无论是对于Jdk代理还是Cglib代理，其目标对象和代理对象都是实现SomeInterface接口的（Cglib生成的目标对象的子类也是实现了SomeInterface接口的），因而this和target语义都是符合的，此时这两个表达式的效果一样；
this(SomeObject)或target(SomeObject)，这里SomeObject没实现任何接口：这种情况下，Spring会使用Cglib代理生成SomeObject的代理类对象，由于代理类是SomeObject的子类，子类的对象也是符合SomeObject类型的，因而this将会被匹配，而对于target，由于目标对象本身就是SomeObject类型，因而这两个表达式的效果一样；
this(SomeObject)或target(SomeObject)，这里SomeObject实现了某个接口：对于这种情况，虽然表达式中指定的是一种具体的对象类型，但由于其实现了某个接口，因而Spring默认会使用Jdk代理为其生成代理对象，Jdk代理生成的代理对象与目标对象实现的是同一个接口，但代理对象与目标对象还是不同的对象，由于代理对象不是SomeObject类型的，因而此时是不符合this语义的，而由于目标对象就是SomeObject类型，因而target语义是符合的，此时this和target的效果就产生了区别；这里如果强制Spring使用Cglib代理，因而生成的代理对象都是SomeObject子类的对象，其是SomeObject类型的，因而this和target的语义都符合，其效果就是一致的。

4.args(paramType)
args无论其类路径或者是方法名是什么,表达式的作用是匹配指定参数类型和指定参数数量的方法，类型用全路径
args(java.lang.String,..,java.lang.Integer)


5.@within(annotationType) 匹配带有指定注解的类，，within为配置指定类型的类实例
下面匹配含有 @Component注解的类
"@within(org.springframework.stereotype.Component)"
6.@annotation(annotationType) 匹配带有指定注解的方法

7.@args(annotationType)
@args表示使用指定注解标注的类作为某个方法的参数时该方法将会被匹配

可以使用&&、||、!、三种运算符来组合切点表达式，表示与或非的关系。

@Around(value = "pointcut1() || pointcut2()")