背景

在一些重要接口，可能需要打印出请求的参数信息和响应的结果信息

实现

spring boot 版本 2.4.4

使用到了 AOP 功能，所以需要添加依赖

  1. implementation 'org.springframework.boot:spring-boot-starter-aop'
  2. // hutool 工具使用了里面的一些工具类
  3. implementation 'cn.hutool:hutool-all:5.5.4'

实现只能在方法上写的注解

  1. package cn.mrcode.web.accesslog;
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  9. /**
  10.  * <pre>
  11.  * 访问 controller 日志注解
  12.  * </pre>
  13.  *
  14.  * @author mrcode
  15.  * @date 2021/2/4 10:13
  16.  */
  17. @Target(ElementType.METHOD)
  18. @Retention(RetentionPolicy.RUNTIME)
  19. @Documented
  20. public @interface AccessLog {
  22.     /**
  23.      * 该方法名称，业务名称
  24.      *
  25.      * @return
  26.      */
  27.     String value() default "";
  29.     /**
  30.      * 是否打印请求参数
  31.      *
  32.      * @return
  33.      */
  34.     boolean isPrintReqParams() default true;
  36.     /**
  37.      * 是否打印响应结果
  38.      *
  39.      * @return
  40.      */
  41.     boolean isPrintRes() default true;
  42. }

Aspect 编写

  1. package cn.mrcode.web.accesslog;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.reflect.MethodSignature;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.web.context.request.RequestAttributes;
  9. import org.springframework.web.context.request.RequestContextHolder;
  10. import org.springframework.web.context.request.ServletRequestAttributes;
  12. import java.lang.reflect.Method;
  13. import java.util.Arrays;
  15. import javax.servlet.http.HttpServletRequest;
  17. import cn.hutool.core.date.DateUtil;
  18. import cn.hutool.core.lang.Console;
  19. import cn.hutool.core.lang.Snowflake;
  20. import cn.hutool.core.util.IdUtil;
  21. import cn.hutool.core.util.StrUtil;
  23. /**
  24.  * 访问日志
  25.  *
  26.  * @author mrcode
  27.  * @date 2021/6/9 13:13
  28.  */
  29. @Component
  30. @Aspect
  31. public class AccessLogAspect {
  32.     Snowflake snowflake = IdUtil.getSnowflake(1, 1);
  34.     // 扫描 controller 结尾中的所有方法
  35.     // @Around("execution(* xxx.web.controller..*Controller.*(..))")
  36.     @Around("@annotation(AccessLog)")  // 或则直接使用扫描所有有注解的方法
  37.     public Object access(ProceedingJoinPoint point) throws Throwable {
  38.         Object[] args = point.getArgs();
  39.         MethodSignature signature = (MethodSignature) point.getSignature();
  40.         Method method = signature.getMethod();
  41.         final AccessLog annotation = method.getAnnotation(AccessLog.class);
  42.         String nextId = null;
  43.         if (annotation != null) {
  44.             // 使用雪花算法生成一个请求 ID, 在日志中使用该 ID 来关联响应结果信息
  45.             nextId = snowflake.nextIdStr();
  46.             String sign = method.getDeclaringClass().getName() + "." + method.getName();
  47.             String remoteHost = "N/A";
  49.             // 在 controller 中获取到访问的 ip
  50.             final RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
  51.             if (requestAttributes != null && requestAttributes instanceof ServletRequestAttributes) {
  52.                 final HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
  53.                 remoteHost = request.getRemoteHost();
  54.             }
  55.             if (annotation.isPrintReqParams()) {
  56.                 Console.log(StrUtil.format("{} INFO reqId={},title={},reqIp={}, params={},目标方法 {}",
  57.                         DateUtil.now(),
  58.                         nextId,
  59.                         annotation.value(),
  60.                         remoteHost,
  61.                         Arrays.toString(args), sign));
  62.             }
  63.         }
  65.         Object proceed = point.proceed();  // 类似于调用过滤器链一样
  66.         if (annotation != null) {
  67.             if (annotation.isPrintRes()) {
  68.                 Console.log(StrUtil.format("{} INFO reqId={},results={}", DateUtil.now(), nextId, proceed));
  69.             }
  70.         }
  72.         return proceed;
  73.     }
  74. }

使用方式：在 controller 中想要打印日志的请求接口方法上增加注解

  1. @AccessLog("测试-搜索")

测试结果输出

  1. 2021-07-30 10:07:32 INFO reqId=1420929021054685184,title=搜索,reqIp=192.168.1.107, params=[UserInfo(id=1007, name=小区, phone=18500000040, roles=[ROLE_NORMAL], accessToken=d901f1c110ff49eeab97377370b31892), DataSearchRequest()],目标方法 cn.mrcode.controller.data.DataController.search
  2. 2021-06-09 16:08:51 reqId=1402538164018614272,results=Result{code=0, msg='OK'}

拓展

  • 另外还可以参考 RuoYi 的实现，按配置进行记录到数据库
  • 去掉其中有关 Request 相关代码，这个注解可以作用在任何方法上，实现任何方法都可以打印入参和出参

对任何方法进行日志入参出参打印

  1. import org.aspectj.lang.ProceedingJoinPoint;
  2. import org.aspectj.lang.annotation.Around;
  3. import org.aspectj.lang.annotation.Aspect;
  4. import org.aspectj.lang.reflect.MethodSignature;
  5. import org.springframework.stereotype.Component;
  7. import java.lang.reflect.Method;
  8. import java.util.Arrays;
  10. import cn.hutool.core.lang.Console;
  11. import cn.hutool.core.lang.Snowflake;
  12. import cn.hutool.core.util.IdUtil;
  13. import cn.hutool.core.util.StrUtil;
  14. import lombok.extern.slf4j.Slf4j;
  16. /**
  17.  * 访问日志
  18.  *
  19.  * @author mrcode
  20.  * @date 2021/6/9 13:13
  21.  */
  22. @Component
  23. @Aspect
  24. @Slf4j
  25. public class AccessLogAspect {
  26.     private static Snowflake snowflake = IdUtil.getSnowflake(1, 1);
  28.     @Around("@annotation(AccessLog)")
  29.     public Object access(ProceedingJoinPoint point) throws Throwable {
  30.         Object[] args = point.getArgs();
  31.         MethodSignature signature = (MethodSignature) point.getSignature();
  32.         Method method = signature.getMethod();
  33.         final AccessLog annotation = method.getAnnotation(AccessLog.class);
  34.         String nextId = null;
  35.         if (annotation != null) {
  36.             // 使用雪花算法生成一个请求 ID, 在日志中使用该 ID 来关联响应结果信息
  37.             nextId = snowflake.nextIdStr();
  38.             String sign = method.getDeclaringClass().getName() + "." + method.getName();
  39.             if (annotation.isPrintReqParams()) {
  40.                 log.info("tarckId={},title={}, params={},目标方法 {}",
  41.                         nextId,
  42.                         annotation.value(),
  43.                         Arrays.toString(args), sign);
  44.             }
  45.         }
  47.         Object proceed = point.proceed();  // 类似于调用过滤器链一样
  48.         if (annotation != null) {
  49.             if (annotation.isPrintRes()) {
  50.                 Console.log(StrUtil.format("tarckId={},results={}", nextId, proceed));
  51.             }
  52.         }
  54.         return proceed;
  55.     }
  56. }

对任何方法进行日志入参出参打印 - ThreadLocal

使用 ThreadLocal 来实现在方法内也能获取到 tarckId，主要目的是：为了让方法内部打印日志的时候，能和入口参数一一对应上

  1. import org.aspectj.lang.ProceedingJoinPoint;
  2. import org.aspectj.lang.annotation.Around;
  3. import org.aspectj.lang.annotation.Aspect;
  4. import org.aspectj.lang.reflect.MethodSignature;
  5. import org.hsqldb.lib.StringUtil;
  6. import org.springframework.stereotype.Component;
  8. import java.lang.reflect.Method;
  9. import java.util.Arrays;
  11. import cn.hutool.core.lang.Console;
  12. import cn.hutool.core.lang.Snowflake;
  13. import cn.hutool.core.util.IdUtil;
  14. import cn.hutool.core.util.StrUtil;
  15. import lombok.extern.slf4j.Slf4j;
  17. /**
  18.  * 访问日志
  19.  *
  20.  * @author mrcode
  21.  * @date 2021/6/9 13:13
  22.  */
  23. @Component
  24. @Aspect
  25. @Slf4j
  26. public class AccessLogAspect {
  27.     private static Snowflake snowflake = IdUtil.getSnowflake(1, 1);
  28.     private static final ThreadLocal<String> threadIds = ThreadLocal.withInitial(() -> snowflake.nextIdStr());
  30.     @Around("@annotation(AccessLog)")  // 或则直接使用扫描所有有注解的方法
  31.     public Object access(ProceedingJoinPoint point) throws Throwable {
  32.         try {
  34.             Object[] args = point.getArgs();
  35.             MethodSignature signature = (MethodSignature) point.getSignature();
  36.             Method method = signature.getMethod();
  37.             final AccessLog annotation = method.getAnnotation(AccessLog.class);
  38.             String nextId = null;
  39.             if (annotation != null) {
  40.                 // 使用雪花算法生成一个请求 ID, 在日志中使用该 ID 来关联响应结果信息
  41.                 nextId = threadIds.get();
  42.                 String sign = method.getDeclaringClass().getName() + "." + method.getName();
  43.                 if (annotation.isPrintReqParams()) {
  44.                     log.info("tarckId={},title={}, params={},目标方法 {}",
  45.                             nextId,
  46.                             annotation.value(),
  47.                             Arrays.toString(args), sign);
  48.                 }
  49.             }
  51.             Object proceed = point.proceed();  // 类似于调用过滤器链一样
  52.             if (annotation != null) {
  53.                 if (annotation.isPrintRes()) {
  54.                     Console.log(StrUtil.format("tarckId={},results={}", nextId, proceed));
  55.                 }
  56.             }
  58.             return proceed;
  59.         } finally {
  60.             threadIds.remove();
  61.         }
  62.     }
  64.     /**
  65.      * 获取当前线程的请求 ID; 请注意，需要在有 @AccessLog 主键的方法中使用，否则可能会导致内存溢出问题
  66.      *
  67.      * @return
  68.      */
  69.     public static String trackId() {
  70.         return threadIds.get();
  71.     }
  72. }