SpringBoot 中的 Aop + 自定义注解（内含源代码）
源代码下载链接地址：https://download.csdn.net/download/weixin_46411355/87553544
目录
- SpringBoot 中的 Aop + 自定义注解（内含源代码）
- `源代码下载链接地址：`[https://download.csdn.net/download/weixin_46411355/87553544](https://download.csdn.net/download/weixin_46411355/87553544)
- 1. @AspectJ
- 1.1 `@AspectJ` 切面类
- 1.2 `@Pointcut` 创建切入点
- 1.3 通知
- 1.4 Spring AOP 和 AspectJ AOP 有什么区别？
- 2. 在 SpringBoot 中使用 Aop 功能
- 2.0 创建一个SpringBoot项目
- 2.1 引入 POM 依赖
- 2.1.1 引入springboot aop依赖
- 2.1.2 引入fastjson依赖
- 2.2 .编写配置类SpringConfig.java
- 2.3.编写测试Controller
- 2.4 编写切面类（使用注解 `@Aspect`）：
- 2.5 测试类（注意该类必须写在java目录下）
- 2.6 切面类代码优化
- 3.AOP 中使用自定义注解
- 3.0 创建一个SpringBoot项目
- 3.1 引入 POM 依赖
- 3.1.1 引入springboot aop依赖
- 3.1.2 引入fastjson依赖
- 3.2 .编写配置类SpringConfig.java
- 3.3 添加一个自定义注解 @MyAop
- 3.4 将此注解添加到Controller需要拦截的方法上
- 3.5 定义一个切面类：
- 3.6 测试类
- 3.7 测试效果
- 4.Aop + 自定义注解实现日志记录
- 4.0 创建一个SpringBoot工程
- 4.1 导入相关依赖
- 4.2 编写配置类SpringConfig,java
- 4.2 vo类MyOperationLogVO
- 4.3 Service层
- 4.3.1 Service接口
- 4.3.2 Service层实现类记录日志
- 4.4 定义一个自定义注解 @MyOperationLog
- 4.5 定义一个 Controller
- 4.6 AspectUtil工具类
- 4.7 定义一个切面类 @MyLogAspect
- 4.8测试类
- 4.9 测试效果
- 5.Aop + 自定义注解实现日志记录（优化）
- 5.0 创建一个SpringBoot工程
- 5.1 导入相关依赖
- 5.2 编写配置类
- 5.3 vo类MyOperationLogVO.java
- 5.4 定义一个自定义注解 MyOperationLog
- 5.4 定义一个Controller
- 5.5 定义一个切面类（重要）
- 5.6 测试类
- 5.7 测试结果
- 6. Aop + 自定义注解实现统一打印出入参日志
- 6.1 创建一个SpringBoot项目
- 6.2 导入依赖
- 6.3 定义一个自定义注解：
- 6.4 定义一个切面类，声明一个切入点
- 6.5 定义一个 Controller
- 6.6 运行启动类
1. @AspectJ
1.1 @AspectJ 切面类
Spring 提供了四种aop切面的支持
- 基于代理的经典的 Spring Aop
- 纯POJO切面
- @AspectJ 注解驱动切面（底层也是 Spring 的动态代理）
- 注入式 Aspectj 切面
而本此使用的就是 @AspectJ 注解驱动切面的方式。
在配置 AOP 切面之前，我们需要了解下 aspectj 相关注解的作用：
- @Aspect：声明该类为一个切面类；
- @Pointcut：定义一个切点，后面跟随一个表达式，表达式可以定义为切某个注解；也可以切某个 package 下的方法；
1.2 @Pointcut 创建切入点
切入点方法不用写代码，返回类型为 void
execution：用于匹配表达式。
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)
表达式含义：
- modifier-pattern?：修饰符
- ret-type-pattern：返回值。可以为
*，表示任何返回值,全路径的类名等 - declaring-type-pattern?：类路径
- name-pattern：方法名。可以指定方法名 或者 代表所有，set 代表以set开头的所有方法
- param-pattern：参数。可以指定具体的参数类型，多个参数间用
“,”隔开，各个参数也可以用“*”来表示匹配任意类型的参数。如：(String) 表示匹配一个 String 参数的方法；(*, String)表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(..)表示零个或多个任意参数 - throws-pattern?：异常类型。其中后面跟着
“?”的是可选项
举例：
execution(* *(..))表示匹配所有方法execution(public * com. example.controller.*(..))表示匹配com. example.controller中所有的 public 方法execution(* com. example.controller..*.*(..))表示匹配com. example.controller包及其子包下的所有方法
1.3 通知
通知有 5 种：
- @Before：前置通知。目标方法调用前被调用
- @After：最终通知。目标方法执行完之后执行
- @AfterReturning：后置返回通知。如果参数中的第一个参数为 JoinPoint，则第二个参数为返回值的信息；如果参数中的第一个参数不为 JoinPoint，则第一个参数为 returning 中对应的参数；returning 只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行
- @AfterThrowing：后置异常通知。
- @Around：环绕通知。环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。环绕通知第一个参数必须是
org.aspectj.lang.ProceedingJoinPoint类型
执行顺序：@Around => @Before => 接口中的逻辑代码 => @After => @AfterReturning
除 @Around 外，每个方法里都可以加或者不加参数 JoinPoint。JoinPoint 包含了类名、被切面的方法名、参数等属性。
@Around 参数必须为 ProceedingJoinPoint。
1.4 Spring AOP 和 AspectJ AOP 有什么区别？
Spring AOP 属于运行时增强，而 AspectJ 是编译时增强。
Spring AOP 基于代理(Proxying)，而 AspectJ 基于字节码操作(Bytecode Manipulation)。
Spring AOP 已经集成了 AspectJ ，AspectJ 应该算的上是 Java 生态系统中最完整的 AOP 框架了。
AspectJ 相比于 Spring AOP 功能更加强大，但是 Spring AOP 相对来说更简单。
如果我们的切面比较少，那么两者性能差异不大。但是，当切面太多的话，最好选择 AspectJ ，它比Spring AOP 快很多。
2. 在 SpringBoot 中使用 Aop 功能
2.0 创建一个SpringBoot项目
2.1 引入 POM 依赖
2.1.1 引入springboot aop依赖
<!-- springboot-aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
2.1.2 引入fastjson依赖
<!-- fastjson -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.23</version>
</dependency>
2.2 .编写配置类SpringConfig.java
package com.tedu.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("com.tedu")
@Configuration
public class SpringConfig {
}
2.3.编写测试Controller
package com.tedu.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/aop")
public class AopController {
@GetMapping("/testHello")
public String testHello(String params){
return "Hello World";
}
}
2.4 编写切面类（使用注解 @Aspect）：
package com.tedu.aop;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Slf4j
@Component
@Aspect
public class AopAspect {
/**
* @Before("execution(public * com.tedu.controller.AOPController.*(..))")
* 修饰符：public
* 返回值类型：任意返回值
* 类路径： com.tedu.controller.AOPController
* 方法名：所有方法
* 参数：任意参数
* @param joinPoint
*/
@Before("execution(public * com.tedu.controller.AopController.*(..))")
public void doBefore(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
log.info("调用前连接点方法为："+methodName+"，参数为："+ JSON.toJSONString(args));
}
@AfterReturning(value = "execution(public * com.tedu.controller.AopController.*(..))", returning = "returnValue")
public void doAfterReturning(JoinPoint joinPoint,Object returnValue){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
log.info("调用前连接点方法为：" + methodName + ",参数为：" + JSON.toJSONString(args) + ",返回值为：" + JSON.toJSONString(returnValue));
}
}
2.5 测试类（注意该类必须写在java目录下）
package com.tedu;
import com.tedu.config.SpringConfig;
import com.tedu.controller.AopController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
AopController aopController = applicationContext.getBean(AopController.class);
aopController.testHello("HHH");
}
}
说明：
- @Before：定义了前置通知方法。打印出入参
- @AfterReturning：定义了后置返回通知方法。打印出入参、返参
运行测试类，查看控制台
2.6 切面类代码优化
将上述的两个通知方法抽出一个切入点（两个通知方法的 execution 重复，提取出来）：
package com.tedu.aop;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Slf4j
@Component
@Aspect
public class AopAspect2 {
//切入点
@Pointcut("execution(public * com.tedu.controller.AopController.*(..))")
public void doPointCut(){
}
@Before("doPointCut()")
public void doBefore(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
log.info("调用前连接点方法为："+methodName+"，参数为："+ JSON.toJSONString(args));
}
@AfterReturning(value = "doPointCut()",returning = "returnValue")
public void doAfterReturing(JoinPoint joinPoint,Object returnValue){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
log.info("调用前连接点方法为："+methodName+"，参数为："+JSON.toJSONString(args)+"，返回值为："+JSON.toJSONString(returnValue));
}
}
测试效果
依旧能达到之前的效果。
3.AOP 中使用自定义注解
3.0 创建一个SpringBoot项目
3.1 引入 POM 依赖
3.1.1 引入springboot aop依赖
<!-- springboot-aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
3.1.2 引入fastjson依赖
<!-- fastjson -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.23</version>
</dependency>
3.2 .编写配置类SpringConfig.java
package com.tedu.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("com.tedu")
@Configuration
public class SpringConfig {
}
3.3 添加一个自定义注解 @MyAop
package com.tedu.anno;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAop {
String value() default "自定义注解拦截";
}
3.4 将此注解添加到Controller需要拦截的方法上
package com.tedu.controller;
import com.tedu.anno.MyAop;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/aop")
public class AopController {
@MyAop
@GetMapping("/MyApp")
public String MyAop(String params){
return "MyAop";
}
}
3.5 定义一个切面类：
package com.tedu.aop;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Slf4j
@Component
@Aspect
public class AopAspect {
@Before("@annotation(com.tedu.anno.MyAop)")
public void doBefore(JoinPoint joinPoint){
String methodName = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
log.info("调用前连接点方法为：" + methodName + ",参数为：" + JSON.toJSONString(args));
}
}
3.6 测试类
package com.tedu;
import com.tedu.config.SpringConfig;
import com.tedu.controller.AopController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestSpringAOPCustomAnnotation {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
AopController aopController = applicationContext.getBean(AopController.class);
aopController.MyAop("HHH");
}
}
3.7 测试效果
4.Aop + 自定义注解实现日志记录
4.0 创建一个SpringBoot工程
4.1 导入相关依赖
<!-- fastjson -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.23</version>
</dependency>
<!-- springboot-aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
4.2 编写配置类SpringConfig,java
package com.tedu.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("com.tedu")
@Configuration
public class SpringConfig {
}
4.2 vo类MyOperationLogVO
MyOperationLogVO.java
package vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@NoArgsConstructor
@Data
public class MyOperationLogVO {
private String methodName;
private String currentUser;
private String operate;
}
4.3 Service层
4.3.1 Service接口
package service;
import anno.MyOperationLog;
import vo.MyOperationLogVO;
public interface LogService {
void addLog(MyOperationLogVO myOperationLogVO);
}
4.3.2 Service层实现类记录日志
package service.impl;
import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import service.LogService;
import vo.MyOperationLogVO;
@Slf4j
@Service
public class LogServiceImpl implements LogService {
@Override
public void addLog(MyOperationLogVO myOperationLogVO) {
log.info("{}", JSON.toJSONString(myOperationLogVO));
}
}
4.4 定义一个自定义注解 @MyOperationLog
package anno;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyOperationLog {
//方法名称
String methodName() default "";
//当前操作人
String currentUser() default "";
//操作
String operate() default "";
}
4.5 定义一个 Controller
package controller;
import anno.MyOperationLog;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/aop")
public class AopController {
@GetMapping("/testLog")
@MyOperationLog(methodName = "testLog",currentUser = "admin",operate = "查询")
public String testLog(){
return "Log";
}
}
4.6 AspectUtil工具类
package com.tedu.util;
import com.tedu.anno.MyOperationLog;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Component
public class AspectUtil {
/**
*
* 功能描述:通过JoinPoint获取注解MyOperationLog
*
* 访问目标方法参数,有三种方法(实际有四种):
* 1.joinpoint.getargs():获取带参方法的参数
* 2.joinpoint.getTarget():.获取他们的目标对象信息
* 3.joinpoint.getSignature():(signature是信号,标识的意思):获取被增强的方法相关信息
*
*/
public MyOperationLog getMyOperationLogByJoinPoint(JoinPoint joinPoint){
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod();
if(null==method){
return null;
}
return method.getAnnotation(MyOperationLog.class);
}
}
4.7 定义一个切面类 @MyLogAspect
package com.tedu.aop;
import com.tedu.anno.MyOperationLog;
import com.tedu.service.LogService;
import com.tedu.util.AspectUtil;
import com.tedu.vo.MyOperationLogVO;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;
import javax.lang.model.util.SimpleAnnotationValueVisitor6;
import java.lang.reflect.Method;
import java.util.Arrays;
@Slf4j
@Component
@Aspect
public class MyLogAspect {
@Autowired
private AspectUtil aspectUtil;
@Autowired
private LogService logService;
//定义一个切入点
@Pointcut("@annotation(com.tedu.anno.MyOperationLog)")
public void doPointcut(){
log.info("进入切入点");
}
//定义一个通知
@Before("doPointcut()")
public void doBefore(JoinPoint joinPoint){
log.info("进入前置通知");
doHandlerLog(joinPoint);
}
private void doHandlerLog(JoinPoint joinPoint) {
//获取自定义注解@MyOperationLog
MyOperationLog myOperationLog = aspectUtil.getMyOperationLogByJoinPoint(joinPoint);
if(null==myOperationLog){
return;
}
//获取签名
String signature = joinPoint.getSignature().toString();
// System.out.println("signature = " + signature);//signature = String com.tedu.controller.AopController.testLog()
//获取方法名
String methodName = signature.substring(signature.lastIndexOf(".") + 1, signature.indexOf("("));
// System.out.println("methodName = " + methodName);
//获取方法的execution
String longTemp = joinPoint.getSignature().toLongString();
// System.out.println("longTemp = " + longTemp);
String classType = joinPoint.getTarget().getClass().getName();
// System.out.println("classType = " + classType);
try{
Class<?> clazz = Class.forName(classType);
Method[] methods = clazz.getDeclaredMethods();
// System.out.println("methods="+Arrays.toString(methods));
for (Method method : methods) {
//注释是否在方法上 且 方法的名字是否等于获取的方法名
if(method.isAnnotationPresent(MyOperationLog.class)&&method.getName().equals(methodName));
//解析
MyOperationLogVO myOperationLogVO = parseAnnotation(method);
//日志添加
logService.addLog(myOperationLogVO);
}
}catch (Exception e){
e.printStackTrace();
}
}
/**
*解析方法上注解中的值
* @param method
* @return
*/
private MyOperationLogVO parseAnnotation(Method method) {
MyOperationLog myOperationLog = method.getAnnotation(MyOperationLog.class);
if(null==myOperationLog){
return null;
}
MyOperationLogVO myOperationLogVO = new MyOperationLogVO();
myOperationLogVO.setMethodName(myOperationLog.methodName());
myOperationLogVO.setCurrentUser(myOperationLog.currentUser());
myOperationLogVO.setOperate(myOperationLog.operate());
return myOperationLogVO;
}
}
4.8测试类
package com.tedu;
import com.tedu.config.SpringConfig;
import com.tedu.controller.AopController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
AopController aopController = applicationContext.getBean(AopController.class);
aopController.testLog();
}
}
4.9 测试效果
5.Aop + 自定义注解实现日志记录（优化）
5.0 创建一个SpringBoot工程
.
5.1 导入相关依赖
<!-- fastjson -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.23</version>
</dependency>
<!-- springboot-aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
5.2 编写配置类
package com.tedu.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@ComponentScan("com.tedu")
@Configuration
public class SpringConfig {
}
5.3 vo类MyOperationLogVO.java
package com.tedu.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
public class MyOperationLogVO {
private String methodName;
private String currentUser;
private String operate;
}
5.4 定义一个自定义注解 MyOperationLog
package com.tedu.anno;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)`package com.tedu.controller;
import com.tedu.anno.MyOperationLog;
import com.tedu.vo.MyOperationLogVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/aop")
public class AopController{
@GetMapping("/testLog")
@MyOperationLog(methodName = "testLog",currentUser = "admin",operate = "查询")
public String testLog(){
return "Log";
}
}
`
public @interface MyOperationLog {
//方法名称
String methodName() default "";
//当前操作人
String currentUser() default "";
//操作
String operate() default "";
}
5.4 定义一个Controller
package com.tedu.controller;
import com.tedu.anno.MyOperationLog;
import com.tedu.vo.MyOperationLogVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/aop")
public class AopController{
@GetMapping("/testLog")
@MyOperationLog(methodName = "testLog",currentUser = "admin",operate = "查询")
public String testLog(){
return "Log";
}
}
5.5 定义一个切面类（重要）
package com.tedu.aop;
import com.alibaba.fastjson2.JSON;
import com.tedu.anno.MyOperationLog;
;
import com.tedu.vo.MyOperationLogVO;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Slf4j
@Component
@Aspect
public class MyLogAspect {
@Autowired
private MyOperationLogVO myOperationLogVO;
//定义一个通知
@Before("@annotation(myOperationLog)")
public void doBefore(JoinPoint joinPoint,MyOperationLog myOperationLog){
log.info("进入前置通知");
myOperationLogVO.setMethodName(myOperationLog.methodName());
myOperationLogVO.setCurrentUser(myOperationLog.currentUser());
myOperationLogVO.setOperate(myOperationLog.operate());
log.info("{}",JSON.toJSONString(myOperationLogVO));
}
}
5.6 测试类
package com.tedu;
import com.tedu.config.SpringConfig;
import com.tedu.controller.AopController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
AopController aopController = applicationContext.getBean(AopController.class);
aopController.testLog();
}
}
5.7 测试结果
6. Aop + 自定义注解实现统一打印出入参日志
6.1 创建一个SpringBoot项目
6.2 导入依赖
<!-- fastjson -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.23</version>
</dependency>
<!-- springboot-aop -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
6.3 定义一个自定义注解：
package com.tedu.anno;
import java.lang.annotation.*;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyLog {
String value() default "";
}
6.4 定义一个切面类，声明一个切入点
package com.tedu.aop;
import com.alibaba.fastjson2.JSON;
import com.tedu.anno.MyLog;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
/**
* 定义一个切面类
*/
@Slf4j
@Component
@Aspect
public class MyAspect {
private static final String LINE_SEPARATOR = System.lineSeparator();
/**
* 声明一个切入点
*/
@Pointcut("@annotation(com.tedu.anno.MyLog)")
public void doPointCut(){
}
@After("doPointCut()")
public void doAfter(JoinPoint joinPoint){
log.info("======================END======================"+LINE_SEPARATOR);
}
/**
* 定义一个环绕通知：用于何时执行切入点
* @param proceedingJoinPoint
* @return
* @throws Throwable
*/
@Around("doPointCut()")
public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
// 执行切入点
Object result = proceedingJoinPoint.proceed();
// 出参
log.info("方法返参为：{}", JSON.toJSONString(result));
// 执行耗时
log.info("Time-Consuming:{} ms", System.currentTimeMillis() - startTime);
return result;
}
/**
* 定义一个前置通知
* @param joinPoint
* @throws Exception
*/
@Before("doPointCut()")
public void doBefore(JoinPoint joinPoint) throws Exception{
ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = servletRequestAttributes.getRequest();
// 获取注解信息
String value = getAspectLogValue(joinPoint);
// 请求相关信息
log.info("========================== START ==========================");
log.info("URL : {}", request.getRequestURL().toString());
log.info("VALUE : {}", value);
log.info("HTTP Method : {}", request.getMethod());
log.info("Class Method : {}.{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
log.info("IP : {}", request.getRemoteAddr());
log.info("Request Args : {}", JSON.toJSONString(joinPoint.getArgs()));
}
/**
* 获取注解信息
* @param joinPoint
* @return
* @throws ClassNotFoundException
*/
private String getAspectLogValue(JoinPoint joinPoint) throws ClassNotFoundException {
String targetName = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] arguments = joinPoint.getArgs();
Class targetClass = Class.forName(targetName);
Method[] methods = targetClass.getMethods();
StringBuilder value = new StringBuilder();
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs.length == arguments.length) {
value.append(method.getAnnotation(MyLog.class).value());
break;
}
}
}
return value.toString();
}
}
6.5 定义一个 Controller
因为我们的切点是自定义注解 @MyLog，所以我们仅仅需要在 Controller 控制器的每个接口方法添加 @MyLog 注解即可，如果我们不想某个接口打印出入参日志，不加注解就可以了：
package com.tedu.controller;
import com.tedu.anno.MyLog;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/aop")
public class AopController {
@GetMapping("/testMyLog")
@MyLog("请求了testMyLog方法")
public String testMyLog() {
return "My Log";
}
}
执行切点后，会去依次调用@Around-> @Before -> 接口逻辑代码 -> @After -> @AfterReturning
6.6 运行启动类
浏览器访问：http://localhost:8080/aop/testMyLog
从上图中可以看到，每个对于每个请求，开始与结束一目了然，并且打印了以下参数：
-
URL: 请求接口地址；
-
VALUE: 接口的中文说明信息；
-
HTTP Method: 请求的方法，是 POST、 GET、 还是 DELETE 等；
-
Class Method: 被请求的方法路径 : 包名 + 方法名;
-
IP: 请求方的 IP 地址；
-
Request Args: 请求入参，以 JSON 格式输出；
-
Response Args: 响应出参，以 JSON 格式输出；
-
Time-Consuming: 请求耗时，以此估算每个接口的性能指数；
