• 写了个牛逼的日志切面，甩锅更方便了

    最近项目进入联调阶段，服务层的接口需要和协议层进行交互，协议层需要将入参 [json 字符串] 组装成服务层所需的 json 字符串，组装的过程中很容易出错。

    入参出错导致接口调试失败问题在联调中出现很多次，因此就想写一个请求日志切面把入参信息打印一下，同时协议层调用服务层接口名称对不上也出现了几次，通过请求日志切面就可以知道上层是否有没有发起调用，方便前后端甩锅还能拿出证据。

    写在前面

    本篇文章是实战性的，对于切面的原理不会讲解，只会简单介绍一下切面的知识点

    切面介绍

    面向切面编程是一种编程范式，它作为 OOP 面向对象编程的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、权限控制、缓存控制、日志打印等等。

    AOP 把软件的功能模块分为两个部分：核心关注点和横切关注点。业务处理的主要功能为核心关注点，而非核心、需要拓展的功能为一切关注点。AOP 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点进行分离，使用切面有以下好处：

    • 集中处理某一关注点 / 横切逻辑
    • 可以很方便的添加 / 删除关注点
    • 侵入性少，增强代码可读性及可维护性 因此当想打印请求日志时很容易想到切面，对控制层代码 0 侵入

    切面的使用【基于注解】

    @Aspect => 声明该类为一个注解类

    切点注解：

    @Pointcut => 定义一个切点，可以简化代码

    通知注解：

    • @Before => 在切点之前执行代码
    • @After => 在切点之后执行代码
    • @AfterReturning => 切点返回内容后执行代码，可以对切点的返回值进行封装
    • @AfterThrowing => 切点抛出异常后执行
    • @Around => 环绕，在切点前后执行代码

    动手写一个请求日志切面

    使用 @Pointcut 定义切点

    @Pointcut 定义了一个切点，因为是请求日志切边，因此切点定义的是 Controller 包下的所有类下的方法。定义切点以后在通知注解中直接使用 requestServer 方法名就可以了

    使用 @Before 再切点前执行

    1. @Before("requestServer()")  
    2. public void doBefore(JoinPoint joinPoint) {  
    3.  ServletRequestAttributes attributes = (ServletRequestAttributes)  
    4. RequestContextHolder.getRequestAttributes();  
    5.  HttpServletRequest request = attributes.getRequest();  
    6.   
    7.  LOGGER.info("===============================Start========================");  
    8.  LOGGER.info("IP                 : {}", request.getRemoteAddr());  
    9.  LOGGER.info("URL                : {}", request.getRequestURL().toString());  
    10.  LOGGER.info("HTTP Method        : {}", request.getMethod());  
    11.  LOGGER.info("Class Method       : {}.{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());  
    12. }  

    在进入 Controller 方法前，打印出调用方 IP、请求 URL、HTTP 请求类型、调用的方法名

    使用 @Around 打印进入控制层的入参

    1. @Around("requestServer()")  
    2. public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
    3.  long start = System.currentTimeMillis();  
    4.  Object result = proceedingJoinPoint.proceed();  
    5.  LOGGER.info("Request Params       : {}", getRequestParams(proceedingJoinPoint));  
    6.  LOGGER.info("Result               : {}", result);  
    7.  LOGGER.info("Time Cost            : {} ms", System.currentTimeMillis() - start);  
    8.   
    9.  return result;  
    10. }  

    打印了入参、结果以及耗时

    • getRquestParams 方法
    1. private Map<String, Object> getRequestParams(ProceedingJoinPoint proceedingJoinPoint) {  
    2.   Map<String, Object> requestParams = new HashMap<>();  
    3.   
    4.    //参数名  
    5.   String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();  
    6.   //参数值  
    7.   Object[] paramValues = proceedingJoinPoint.getArgs();  
    8.   
    9.   for (int i = 0; i < paramNames.length; i++) {  
    10.   Object value = paramValues[i];  
    11.   
    12.   //如果是文件对象  
    13.   if (value instanceof MultipartFile) {  
    14.   MultipartFile file = (MultipartFile) value;  
    15.   value = file.getOriginalFilename();  //获取文件名  
    16.   }  
    17.   
    18.   requestParams.put(paramNames[i], value);  
    19.   }  
    20.   
    21.   return requestParams;  
    22.  }  

    通过 @PathVariable 以及 @RequestParam 注解传递的参数无法打印出参数名，因此需要手动拼接一下参数名，同时对文件对象进行了特殊处理，只需获取文件名即可

    • @After 方法调用后执行
    1. @After("requestServer()")  
    2. public void doAfter(JoinPoint joinPoint) {  
    3.  LOGGER.info("===============================End========================");  
    4. }  

    没有业务逻辑只是打印了 End

    • 完整切面代码
    1. @Component  
    2. @Aspect  
    3. public class RequestLogAspect {  
    4.  private final static Logger LOGGER = LoggerFactory.getLogger(RequestLogAspect.class);  
    5.   
    6.  @Pointcut("execution(* your_package.controller..*(..))")  
    7.  public void requestServer() {  
    8.  }  
    9.   
    10.  @Before("requestServer()")  
    11.  public void doBefore(JoinPoint joinPoint) {  
    12.  ServletRequestAttributes attributes = (ServletRequestAttributes)  
    13. RequestContextHolder.getRequestAttributes();  
    14.  HttpServletRequest request = attributes.getRequest();  
    15.   
    16.  LOGGER.info("===============================Start========================");  
    17.  LOGGER.info("IP                 : {}", request.getRemoteAddr());  
    18.  LOGGER.info("URL                : {}", request.getRequestURL().toString());  
    19.  LOGGER.info("HTTP Method        : {}", request.getMethod());  
    20.  LOGGER.info("Class Method       : {}.{}", joinPoint.getSignature().getDeclaringTypeName(),  
    21.  joinPoint.getSignature().getName());  
    22.  }  
    23.   
    24.   
    25.  @Around("requestServer()")  
    26.  public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
    27.  long start = System.currentTimeMillis();  
    28.  Object result = proceedingJoinPoint.proceed();  
    29.  LOGGER.info("Request Params     : {}", getRequestParams(proceedingJoinPoint));  
    30.  LOGGER.info("Result               : {}", result);  
    31.  LOGGER.info("Time Cost            : {} ms", System.currentTimeMillis() - start);  
    32.   
    33.  return result;  
    34.  }  
    35.   
    36.  @After("requestServer()")  
    37.  public void doAfter(JoinPoint joinPoint) {  
    38.  LOGGER.info("===============================End========================");  
    39.  }  
    40.   
    41.  /**  
    42.   * 获取入参  
    43.   * @param proceedingJoinPoint  
    44.   *  
    45.   * @return  
    46.   * */  
    47.  private Map<String, Object> getRequestParams(ProceedingJoinPoint proceedingJoinPoint) {  
    48.  Map<String, Object> requestParams = new HashMap<>();  
    49.   
    50.  //参数名  
    51.  String[] paramNames =  
    52. ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();  
    53.  //参数值  
    54.  Object[] paramValues = proceedingJoinPoint.getArgs();  
    55.   
    56.  for (int i = 0; i < paramNames.length; i++) {  
    57.  Object value = paramValues[i];  
    58.   
    59.  //如果是文件对象  
    60.  if (value instanceof MultipartFile) {  
    61.  MultipartFile file = (MultipartFile) value;  
    62.  value = file.getOriginalFilename();  //获取文件名  
    63.  }  
    64.   
    65.  requestParams.put(paramNames[i], value);  
    66.  }  
    67.   
    68.  return requestParams;  
    69.  }  
    70. }  

    高并发下请求日志切面

    写完以后对自己的代码很满意，但是想着可能还有完善的地方就和朋友交流了一下。emmmm

    果然还有继续优化的地方 每个信息都打印一行，在高并发请求下确实会出现请求之间打印日志串行的问题，因为测试阶段请求数量较少没有出现串行的情况，果然生产环境才是第一发展力，能够遇到更多 bug，写更健壮的代码 解决日志串行的问题只要将多行打印信息合并为一行就可以了，因此构造一个对象

    • RequestInfo.java

    • 环绕通知方法体
    1. @Around("requestServer()")  
    2. public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
    3.  long start = System.currentTimeMillis();  
    4.  ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();  
    5.  HttpServletRequest request = attributes.getRequest();  
    6.  Object result = proceedingJoinPoint.proceed();  
    7.  RequestInfo requestInfo = new RequestInfo();  
    8.  requestInfo.setIp(request.getRemoteAddr());  
    9.  requestInfo.setUrl(request.getRequestURL().toString());  
    10.  requestInfo.setHttpMethod(request.getMethod());  
    11.  requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),  
    12.  proceedingJoinPoint.getSignature().getName()));  
    13.  requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));  
    14.  requestInfo.setResult(result);  
    15.  requestInfo.setTimeCost(System.currentTimeMillis() - start);  
    16.  LOGGER.info("Request Info      : {}", JSON.toJSONString(requestInfo));  
    17.   
    18.  return result;  
    19. }  
    20.  

    将 url、http request 这些信息组装成 RequestInfo 对象，再序列化打印对象
    打印序列化对象结果而不是直接打印对象是因为序列化有更直观、更清晰，同时可以借助在线解析工具对结果进行解析

    是不是还不错

    在解决高并发下请求串行问题的同时添加了对

    异常请求信息的打印，通过使用 @AfterThrowing 注解对抛出异常的方法进行处理

    • RequestErrorInfo.java

    • 异常通知环绕体
    1. @AfterThrowing(pointcut = "requestServer()", throwing = "e")  
    2. public void doAfterThrow(JoinPoint joinPoint, RuntimeException e) {  
    3.  ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();  
    4.  HttpServletRequest request = attributes.getRequest();  
    5.  RequestErrorInfo requestErrorInfo = new RequestErrorInfo();  
    6.  requestErrorInfo.setIp(request.getRemoteAddr());  
    7.  requestErrorInfo.setUrl(request.getRequestURL().toString());  
    8.  requestErrorInfo.setHttpMethod(request.getMethod());  
    9.  requestErrorInfo.setClassMethod(String.format("%s.%s", joinPoint.getSignature().getDeclaringTypeName(),  
    10.  joinPoint.getSignature().getName()));  
    11.  requestErrorInfo.setRequestParams(getRequestParamsByJoinPoint(joinPoint));  
    12.  requestErrorInfo.setException(e);  
    13.  LOGGER.info("Error Request Info      : {}", JSON.toJSONString(requestErrorInfo));  
    14. }  

    对于异常，耗时是没有意义的，因此不统计耗时，而是添加了异常的打印

    最后放一下完整日志请求切面代码：

    1. @Component  
    2. @Aspect  
    3. public class RequestLogAspect {  
    4.     private final static Logger LOGGER = LoggerFactory.getLogger(RequestLogAspect.class);  
    5.   
    6.     @Pointcut("execution(* your_package.controller..*(..))")  
    7.     public void requestServer() {  
    8.     }  
    9.   
    10.     @Around("requestServer()")  
    11.     public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {  
    12.         long start = System.currentTimeMillis();  
    13.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();  
    14.         HttpServletRequest request = attributes.getRequest();  
    15.         Object result = proceedingJoinPoint.proceed();  
    16.         RequestInfo requestInfo = new RequestInfo();  
    17.                 requestInfo.setIp(request.getRemoteAddr());  
    18.         requestInfo.setUrl(request.getRequestURL().toString());  
    19.         requestInfo.setHttpMethod(request.getMethod());  
    20.         requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),  
    21.                 proceedingJoinPoint.getSignature().getName()));  
    22.         requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));  
    23.         requestInfo.setResult(result);  
    24.         requestInfo.setTimeCost(System.currentTimeMillis() - start);  
    25.         LOGGER.info("Request Info      : {}", JSON.toJSONString(requestInfo));  
    26.   
    27.         return result;  
    28.     }  
    29.   
    30.   
    31.     @AfterThrowing(pointcut = "requestServer()", throwing = "e")  
    32.     public void doAfterThrow(JoinPoint joinPoint, RuntimeException e) {  
    33.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();  
    34.         HttpServletRequest request = attributes.getRequest();  
    35.         RequestErrorInfo requestErrorInfo = new RequestErrorInfo();  
    36.         requestErrorInfo.setIp(request.getRemoteAddr());  
    37.         requestErrorInfo.setUrl(request.getRequestURL().toString());  
    38.         requestErrorInfo.setHttpMethod(request.getMethod());  
    39.         requestErrorInfo.setClassMethod(String.format("%s.%s", joinPoint.getSignature().getDeclaringTypeName(),  
    40.                 joinPoint.getSignature().getName()));  
    41.         requestErrorInfo.setRequestParams(getRequestParamsByJoinPoint(joinPoint));  
    42.         requestErrorInfo.setException(e);  
    43.         LOGGER.info("Error Request Info      : {}", JSON.toJSONString(requestErrorInfo));  
    44.     }  
    45.   
    46.     /**  
    47.      * 获取入参  
    48.      * @param proceedingJoinPoint  
    49.      *  
    50.      * @return  
    51.      * */  
    52.     private Map<String, Object> getRequestParamsByProceedingJoinPoint(ProceedingJoinPoint proceedingJoinPoint) {  
    53.         //参数名  
    54.         String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();  
    55.         //参数值  
    56.         Object[] paramValues = proceedingJoinPoint.getArgs();  
    57.   
    58.         return buildRequestParam(paramNames, paramValues);  
    59.     }  
    60.   
    61.     private Map<String, Object> getRequestParamsByJoinPoint(JoinPoint joinPoint) {  
    62.         //参数名  
    63.         String[] paramNames = ((MethodSignature)joinPoint.getSignature()).getParameterNames();  
    64.         //参数值  
    65.         Object[] paramValues = joinPoint.getArgs();  
    66.   
    67.         return buildRequestParam(paramNames, paramValues);  
    68.     }  
    69.   
    70.     private Map<String, Object> buildRequestParam(String[] paramNames, Object[] paramValues) {  
    71.         Map<String, Object> requestParams = new HashMap<>();  
    72.         for (int i = 0; i < paramNames.length; i++) {  
    73.             Object value = paramValues[i];  
    74.   
    75.             //如果是文件对象  
    76.             if (value instanceof MultipartFile) {  
    77.                 MultipartFile file = (MultipartFile) value;  
    78.                 value = file.getOriginalFilename();  //获取文件名  
    79.             }  
    80.   
    81.             requestParams.put(paramNames[i], value);  
    82.         }  
    83.   
    84.         return requestParams;  
    85.     }  
    86.   
    87.     @Data  
    88.     public class RequestInfo {  
    89.         private String ip;  
    90.         private String url;  
    91.         private String httpMethod;  
    92.         private String classMethod;  
    93.         private Object requestParams;  
    94.         private Object result;  
    95.         private Long timeCost;  
    96.     }  
    97.   
    98.     @Data  
    99.     public class RequestErrorInfo {  
    100.         private String ip;  
    101.         private String url;  
    102.         private String httpMethod;  
    103.         private String classMethod;  
    104.         private Object requestParams;  
    105.         private RuntimeException exception;  
    106.     }  
    107. }  

    赶紧给你们的应用加上吧【如果没加的话】，没有日志的话，总怀疑上层出错，但是却拿不出证据

    关于 traceId 跟踪定位，可以根据 traceId 跟踪整条调用链，以 log4j2 为例介绍如何加入 traceId

    • 添加拦截器
    1. public class LogInterceptor implements HandlerInterceptor {  
    2.  private final static String TRACE_ID = "traceId";  
    3.   
    4.  @Override  
    5.  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {  
    6.  String traceId = java.util.UUID.randomUUID().toString().replaceAll("-", "").toUpperCase();  
    7.  ThreadContext.put("traceId", traceId);  
    8.   
    9.  return true;  
    10.  }  
    11.   
    12.  @Override  
    13.  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)  
    14.  throws Exception {  
    15.  }  
    16.   
    17.  @Override  
    18.  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)  
    19.  throws Exception {  
    20.  ThreadContext. remove(TRACE_ID);  
    21.  }  
    22. }  

    在调用前通过 ThreadContext 加入 traceId，调用完成后移除

    • 修改日志配置文件 在原来的日志格式中
      添加 traceId 的占位符
    <property >[TRACEID:%X{traceId}] %d{HH:mm:ss.SSS} %-5level %class{-1}.%M()/%L - %msg%xEx%n</property>  
    • 执行效果

    日志跟踪更方便

    DMC 是配置 logback 和 log4j 使用的，使用方式和 ThreadContext 差不多，将 ThreadContext.put 替换为 MDC.put 即可，同时修改日志配置文件。

    推荐使用 log4j2，为什么推荐使用 log4j2 可以看下这篇文章：日志框架，选择 Logback Or Log4j2？

    log4j2 也是可以配合 MDC 一起使用的

    MDC 是 slf4j 包下的，其具体使用哪个日志框架与我们的依赖有关。

     

  • 相关阅读:
    php之 角色的权限管理（RBAC）详解
    Qt实用技巧：在CentOS上使用linuxdeployqt打包发布qt程序
    开源协作开发者内容平台Vrite
    Java8新特性
    JavaScript LocalStorage 完整指南
    DevicData-D-XXXXXXXX勒索病毒数据怎么处理|数据解密恢复
    力扣739：每日温度 （Java多种方法）
    Python基础教程（三十一）：pyecharts模块
    线性回归
    linux系统编程6-守护进程、线程
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/125520937