实操:一个日志监听的例子
首先,确认项目中是否包含AOP的依赖(不同的SpringBoot版本情况不一,如果无法使用AOP,则需要手动补入AOP的依赖)
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
下面我们实现一个日志监听的注解,使用该注解,记录方法的调用情况;实现步骤就三步,即
- 定义注解
- 定义切面
- 将切面与注解进行切入点融合
定义注解
直接创建 @interface
的类,使用注解@Target
和 @Retention
指定其适用范围及保留时长,如下:
@Target(ElementType.METHOD) // 指定注解的适用范围
@Retention(RetentionPolicy.RUNTIME) //指定运行时
public @interface LogNote {
//方法描述
String desc() default "";
//是否记录方法执行耗时
boolean timeSpan() default true;
}
注解类的内容一般很简单,类似于Enum类一样,里面是简单的方法及属性
定义切面
通过@Aspect
注解指定一个类为切面类:
@Component
@Aspect
@Slf4j(topic = "LogNote")
public class LogNoteAspect {
public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable {
MethodSignature signature = (MethodSignature) point.getSignature();
//获取被调用方法
Method method = signature.getMethod();
//取出被调用方法的注解,方便后续使用注解中的属性
ApiLog loglinstener = method.getAnnotation(ApiLog.class);
log.info("----------------------method[{}]start--------------------",method.getName());
log.info("方法描述:{}",loglinstener.desc());
log.info("参数 :{}",point.getArgs());
long startTime = System.currentTimeMillis();
Object proceed = point.proceed();
long endTime = System.currentTimeMillis();
log.info("耗时:{}ss",endTime-startTime);
log.info("----------------------method[{}] end--------------------\n",method.getName())
return proceed;
}
}
将切面与注解进行关联
在切面类实现的aroundAdvice方法上,补充@Around()注解
@Component
@Aspect
@Slf4j(topic = "LogNote")
public class LogNoteAspect {
@Around("@annotation(com.gcc.LogNote)")
public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable {
MethodSignature signature = (MethodSignature) point.getSignature();
//获取被调用方法
Method method = signature.getMethod();
//取出被调用方法的注解,方便后续使用注解中的属性
ApiLog loglinstener = method.getAnnotation(ApiLog.class);
log.info("----------------------method[{}]start--------------------",method.getName());
log.info("方法描述:{}",loglinstener.desc());
log.info("参数 :{}",point.getArgs());
long startTime = System.currentTimeMillis();
Object proceed = point.proceed();
long endTime = System.currentTimeMillis();
log.info("耗时:{}ss",endTime-startTime);
log.info("----------------------method[{}] end--------------------\n",method.getName())
return proceed;
}
}
这里因为的注解是使用在方法上,需要记录方法的执行时间,所以需要使用环绕的切入方式,即:使用注解的方法会被整个记录,以代理的方式对其执行前、执行后都进行记录。
使用该注解
因为此例子使用的类型为METHOD
即方法级的注解,直接在public的方法上使用即可:
@LogNote(desc = "执行Es查询")
public JSONObject seachEsData(String indexName, SearchSourceBuilder searchSourceBuilder) {
JSONObject resultMap = new JSONObject();
.......
return resultMap;
}
输出:
2023-06-05 20:00:00 [LogNote] :--------------------method[searchESData]start---------------
2023-06-05 20:00:00 [LogNote] :方法描述:执行Es查询
2023-06-05 20:00:00 [LogNote] :参数 :{"query":{"match_all:{}","size":1,"from":0}},log
2023-06-05 20:00:00 [LogNote] :耗时 : 58ss
2023-06-05 20:00:00 [LogNote] :--------------------method[searchESData] end---------------
知识点补充
关于Target注解
注解@Target
常常配合枚举类ElementType
来指定注解的作用位置,也叫合法位置,即你定义了一个注解,这个注解是类注解还是方法注解还是XX注解等,具体作用的范围,取决于@Target({ElementType.TYPE})
中,ElementType
的枚举值,在进行自定义枚举时,根据自己的需求,决定定义的注解是哪类层级使用的注解,例如上面的例子中,@ApiLog这个自定义的注解就是方法级的注解
ElementType的枚举值有
枚举值 | 含义 |
---|---|
TYPE | 类, 接口 (包括注解类型), 或 枚举 声明 |
FIELD | 字段、包括枚举常量 |
METHOD | 方法声明 |
PARAMETER | 正式的参数声明 |
CONSTRUCTOR | 构造函数的声明 |
LOCAL_VARIABLE | 局部变量的声明 |
ANNOTATION_TYPE | 注解类型的声明 |
PACKAGE | 包声明 |
注解@Retention
常常配合枚举类RetentionPolic
来指定注解的各种策略,注解的保留时间,也就是何时生效,即你定义了一个注解,这个注解是编译时生效还是仅仅只是在代码中标记等等,具体作用的范围,取决于@Retention({RetentionPolic.TYPE})
中,RetentionPolic
的枚举值,在进行自定义枚举时,大多数都是使用RUNTIME(编译时生效)
RetentionPolic的枚举值
枚举值 | 含义 |
---|---|
SOURCE | 解只在源代码级别保留,编译时被忽略 |
CLASS | 注解将被编译器在类文件中记录 , 但在运行时不需要JVM保留。这是默认的 |
RUNTIME | 注解将被编译器记录在类文件中,在运行时保留VM,也是使用最多的(一般自定义均使用这个) |
关于AOP的补充
这种在运行时,动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程
切面 (Aspect)
切面是一个横切关注点的模块化,一个切面能够包含同一个类型的不同增强方法,比如说事务处理和日志处理可以理解为两个切面。切面由切入点和通知组成,它既包含了横切逻辑的定义,也包括了切入点的定义。 Spring AOP就是负责实施切面的框架,它将切面所定义的横切逻辑织入到切面所指定的连接点中。简单点理解,在SpringBoot中使用了Aspect注解的类就是切面
@Component
@Aspect
public class LogAspect {
}
目标对象(Target)
目标对象指将要被增强的对象,即包含主业务逻辑的类对象。或者说是被一个或者多个切面所通知的对象。
在我们的例子中,即是使用了@ApiLog注解的地方 searchEsData()
连接点(JoinPoint)
程序执行过程中明确的点,如方法的调用或特定的异常被抛出。连接点由两个信息确定:
- 方法(表示程序执行点,即在哪个目标方法)
- 相对点(表示方位,即目标方法的什么位置,比如调用前,后等)
简单来说,连接点就是被拦截到的程序执行点,因为Spring只支持方法类型的连接点,所以在Spring中连接点就是被拦截到的方法。
切入点 (PointCut)
切入点是对连接点进行拦截的条件定义。切入点表达式如何和连接点匹配是AOP的核心,Spring缺省使用AspectJ切入点语法。 一般认为,所有的方法都可以认为是连接点,但是我们并不希望在所有的方法上都添加通知,而切入点的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述) 来匹配连接点,给满足规则的连接点添加通知。
//此处的匹配规则是 com.remcarpediem.test.aop.service包下的所有类的所有函数。
@Pointcut("execution(* com.remcarpediem.test.aop.service..*(..))")
public void pointcut() {
}
这里切入点的概念其实就是确定对哪些目标对象进行切面插入功能,一开始的例子是采用注解的方式来达到切入点的作用:
@Around("@annotation(com.gcc.LogNote)")
通知(Advice)
通知是指拦截到连接点之后要执行的代码,包括了“around”、“before”和“after”等不同类型的通知。Spring AOP框架以拦截器来实现通知模型,并维护一个以连接点为中心的拦截器链。
// @Before说明这是一个前置通知,log函数中是要前置执行的代码,JoinPoint是连接点,
@Before("pointcut()")
public void log(JoinPoint joinPoint) {
}
//@After 为后置通知
//@Around 为环绕通知
织入(Weaving)
这里的织入概念是个动作,即Spring将前面的切面、连接点、切入点关联起来并创建通知代理的过程。织入可以在编译时,类加载时和运行时完成。在编译时进行织入就是静态代理,而在运行时进行织入则是动态代理。也就是例子中操作的第三步,将切面与注解进行关联
增强器(Advisor)
Advisor是切面的另外一种实现,能够将通知以更为复杂的方式织入到目标对象中,是将通知包装为更复杂切面的装配器。Advisor由切入点和Advice组成。 Advisor这个概念来自于Spring对AOP的支撑,在AspectJ中是没有等价的概念的。Advisor就像是一个小的自包含的切面,这个切面只有一个通知。切面自身通过一个Bean表示,并且必须实现一个默认接口。
简单来讲,整个 aspect 可以描述为: 满足 pointcut 规则的 joinpoint 会被添加相应的 advice 操作。
将上方通过注解使用切面的方式改写一下:
@Component
@Aspect
@Sl4fj
public class LogNote {
// 不使用注解,而通过基础的规则配置选择切入点,表达式是指com.gcc.controller
// 包下的所有类的所有方法
@Pointcut("execution(* com.gcc.controller..*(..))")
public void aspect() {}
// 通知,在符合aspect切入点的方法前插入如下代码,并且将连接点作为参数传递
@Before("aspect()")
public void log(JoinPoint joinPoint) { //连接点作为参数传入
// 获得类名,方法名,参数和参数名称。
Signature signature = joinPoint.getSignature();
String className = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] arguments = joinPoint.getArgs();
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
String[] argumentNames = methodSignature.getParameterNames();
StringBuilder sb = new StringBuilder(className + "." + methodName + "(");
for (int i = 0; i< arguments.length; i++) {
Object argument = arguments[i];
sb.append(argumentNames[i] + "->");
sb.append(argument != null ? argument.toString() : "null ");
}
sb.append(")");
log.info(sb.toString());
}
}
关于SpringBoot的AOP中的对象及方法
JoinPoint对象
JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象.
方法 | 作用 | 返回对象 |
---|---|---|
getSignature() | 获取封装了署名信息的对象,在该对象中可以获取到目标方法名,所属类的Class等信息 | Signature |
getArgs() | 获取 获取传入目标方法的参数对象 | Object[] |
getTarget() | 获取被代理的对象 | Object |
proceedingJoinPoin对象
proceedingJoinPoin对象是JoinPoint的子类,在原本JoinPoint的基础上,放开了Proceeed()的使用,一般在环绕通知@Around
时使用:
Object proceed() throws Throwable //执行目标方法
Object proceed(Object[] var1) throws Throwable //传入的新的参数去执行目标方法