Spring Boot 记录请求响应日志的常用手段

某些业务需求需要追踪我们的接口访问情况，也就是把请求和响应记录下来。基本的记录维度包含了请求入参(路径query参数，请求体)、请求路径(uri)、请求方法(method)、请求头(headers)以及响应状态、响应头、甚至包含了敏感的响应体等等。今天总结了几种方法，你可以按需选择。

成都创新互联电话联系：18982081108，为您提供成都网站建设网页设计及定制高端网站建设服务，成都创新互联网页制作领域10多年，包括成都PE包装袋等多个方面拥有多年的网站营销经验，选择成都创新互联，为网站锦上添花。

请求追踪的实现方式

网关层

很多网关设施都具有httptrace的功能，可以帮助我们集中记录请求流量的情况。Orange、Kong、Apache Apisix这些基于Nginx的网关都具有该能力，就连Nginx本身也提供了记录httptrace日志的能力。

优点是可以集中的管理httptrace日志，免开发;缺点是技术要求高，需要配套的分发、存储、查询的设施。

Spring Boot Actuator

在Spring Boot中，其实提供了简单的追踪功能。你只需要集成：

 
 
 
 
      
  
  
  
  1.  
    2.   
  
  
  
  2.     org.springframework.boot 
    3.   
  
  
  
  3.     spring-boot-starter-actuator 
    4.   
  
  
  
  4.  
    5.

开启/actuator/httptrace：

 
 
 
 
      
  
  
  
  1. management: 
    2.   
  
  
  
  2.   endpoints: 
    3.   
  
  
  
  3.     web: 
    4.   
  
  
  
  4.       exposure: 
    5.   
  
  
  
  5.         include: 'httptrace' 
    6.

就可以通过http://server:port/actuator/httptrace获取最近的Http请求信息了。

不过在最新的版本中可能需要显式的声明这些追踪信息的存储方式，也就是实现HttpTraceRepository接口并注入Spring IoC。

例如放在内存中并限制为最近的100条(不推荐生产使用)：

 
 
 
 
      
  
  
  
  1. @Bean 
    2.   
  
  
  
  2. public HttpTraceRepository httpTraceRepository(){ 
    3.   
  
  
  
  3.     return new InMemoryHttpTraceRepository(); 
    4.   
  
  
  
  4. } 
    5.

追踪日志以json格式呈现：

Spring Boot Actuator记录的httptrace

记录的维度不多，当然如果够用的话可以试试。

优点在于集成起来简单，几乎免除开发;缺点在于记录的维度不多，而且需要搭建缓冲消费这些日志信息的设施。

CommonsRequestLoggingFilter

Spring Web模块还提供了一个过滤器CommonsRequestLoggingFilter，它可以对请求的细节进行日志输出。配置起来也比较简单：

 
 
 
 
      
  
  
  
  1. @Bean 
    2.   
  
  
  
  2. CommonsRequestLoggingFilter  loggingFilter(){ 
    3.   
  
  
  
  3.     CommonsRequestLoggingFilter loggingFilter = new CommonsRequestLoggingFilter(); 
    4.   
  
  
  
  4.     // 记录 客户端 IP信息 
    5.   
  
  
  
  5.     loggingFilter.setIncludeClientInfo(true); 
    6.   
  
  
  
  6.     // 记录请求头 
    7.   
  
  
  
  7.     loggingFilter.setIncludeHeaders(true); 
    8.   
  
  
  
  8.     // 如果记录请求头的话，可以指定哪些记录，哪些不记录 
    9.   
  
  
  
  9.     // loggingFilter.setHeaderPredicate(); 
    10.   
  
  
  
  10.     // 记录 请求体  特别是POST请求的body参数 
    11.   
  
  
  
  11.     loggingFilter.setIncludePayload(true); 
    12.   
  
  
  
  12.     // 请求体的大小限制 默认50 
    13.   
  
  
  
  13.     loggingFilter.setMaxPayloadLength(10000); 
    14.   
  
  
  
  14.     //记录请求路径中的query参数  
    15.   
  
  
  
  15.     loggingFilter.setIncludeQueryString(true); 
    16.   
  
  
  
  16.     return loggingFilter; 
    17.   
  
  
  
  17. } 
    18.

而且必须开启对CommonsRequestLoggingFilter的debug日志：

 
 
 
 
      
  
  
  
  1. logging: 
    2.   
  
  
  
  2.   level: 
    3.   
  
  
  
  3.     org: 
    4.   
  
  
  
  4.       springframework: 
    5.   
  
  
  
  5.         web: 
    6.   
  
  
  
  6.           filter: 
    7.   
  
  
  
  7.             CommonsRequestLoggingFilter: debug 
    8.

一次请求会输出两次日志，一次是在第一次经过过滤器前;一次是完成过滤器链后。

CommonsRequestLoggingFilter记录请求日志

这里多说一句其实可以改造成输出json格式的。

优点是灵活配置、而且对请求追踪的维度全面，缺点是只记录请求而不记录响应。

ResponseBodyAdvice

Spring Boot统一返回体其实也能记录，需要自行实现。这里借鉴了CommonsRequestLoggingFilter解析请求的方法。响应体也可以获取了，不过响应头和状态因为生命周期还不清楚，这里获取还不清楚是否合适，不过这是一个思路。

 
 
 
 
      
  
  
  
  1. /** 
    2.   
  
  
  
  2.  * @author felord.cn 
    3.   
  
  
  
  3.  * @since 1.0.8.RELEASE 
    4.   
  
  
  
  4.  */ 
    5.   
  
  
  
  5. @Slf4j 
    6.   
  
  
  
  6. @RestControllerAdvice(basePackages = {"cn.felord.logging"}) 
    7.   
  
  
  
  7. public class RestBodyAdvice implements ResponseBodyAdvice {   
  
  
  
  8.     private static final int DEFAULT_MAX_PAYLOAD_LENGTH = 10000; 
    9.   
  
  
  
  9.     public static final String REQUEST_MESSAGE_PREFIX = "Request ["; 
    10.   
  
  
  
  10.     public static final String REQUEST_MESSAGE_SUFFIX = "]"; 
    11.   
  
  
  
  11.     private ObjectMapper objectMapper = new ObjectMapper(); 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.     @Override 
    14.   
  
  
  
  14.     public boolean supports(MethodParameter returnType, Class> converterType) { 
    15.   
  
  
  
  15.         return true; 
    16.   
  
  
  
  16.     } 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.     @SneakyThrows 
    19.   
  
  
  
  19.     @Override 
    20.   
  
  
  
  20.     public Object beforeBodyWrite(Object body, 
    21.   
  
  
  
  21.                                   MethodParameter returnType, 
    22.   
  
  
  
  22.                                   MediaType selectedContentType, 
    23.   
  
  
  
  23.                                   Class> selectedConverterType, 
    24.   
  
  
  
  24.                                   ServerHttpRequest request, 
    25.   
  
  
  
  25.                                   ServerHttpResponse response) { 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.         ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) request; 
    28.   
  
  
  
  28.  
    29.   
  
  
  
  29.         log.debug(createRequestMessage(servletServerHttpRequest.getServletRequest(), REQUEST_MESSAGE_PREFIX, REQUEST_MESSAGE_SUFFIX)); 
    30.   
  
  
  
  30.         Rest objectRest;   
  
  
  
  31.         if (body == null) { 
    32.   
  
  
  
  32.             objectRest = RestBody.okData(Collections.emptyMap()); 
    33.   
  
  
  
  33.         } else if (Rest.class.isAssignableFrom(body.getClass())) { 
    34.   
  
  
  
  34.             objectRest = (Rest) body;   
  
  
  
  35.         } 
    36.   
  
  
  
  36.         else if (checkPrimitive(body)) { 
    37.   
  
  
  
  37.             return RestBody.okData(Collections.singletonMap("result", body)); 
    38.   
  
  
  
  38.         }else { 
    39.   
  
  
  
  39.             objectRest = RestBody.okData(body); 
    40.   
  
  
  
  40.         } 
    41.   
  
  
  
  41.         log.debug("Response Body ["+ objectMapper.writeValueAsString(objectRest) +"]"); 
    42.   
  
  
  
  42.         return objectRest; 
    43.   
  
  
  
  43.     } 
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45.  
    46.   
  
  
  
  46.     private boolean checkPrimitive(Object body) { 
    47.   
  
  
  
  47.         Class clazz = body.getClass(); 
    48.   
  
  
  
  48.         return clazz.isPrimitive() 
    49.   
  
  
  
  49.                 || clazz.isArray() 
    50.   
  
  
  
  50.                 || Collection.class.isAssignableFrom(clazz) 
    51.   
  
  
  
  51.                 || body instanceof Number 
    52.   
  
  
  
  52.                 || body instanceof Boolean 
    53.   
  
  
  
  53.                 || body instanceof Character 
    54.   
  
  
  
  54.                 || body instanceof String; 
    55.   
  
  
  
  55.     } 
    56.   
  
  
  
  56.  
    57.   
  
  
  
  57.  
    58.   
  
  
  
  58.     protected String createRequestMessage(HttpServletRequest request, String prefix, String suffix) { 
    59.   
  
  
  
  59.         StringBuilder msg = new StringBuilder(); 
    60.   
  
  
  
  60.         msg.append(prefix); 
    61.   
  
  
  
  61.         msg.append(request.getMethod()).append(" "); 
    62.   
  
  
  
  62.         msg.append(request.getRequestURI()); 
    63.   
  
  
  
  63.  
    64.   
  
  
  
  64.  
    65.   
  
  
  
  65.         String queryString = request.getQueryString(); 
    66.   
  
  
  
  66.         if (queryString != null) { 
    67.   
  
  
  
  67.             msg.append('?').append(queryString); 
    68.   
  
  
  
  68.         } 
    69.   
  
  
  
  69.  
    70.   
  
  
  
  70.  
    71.   
  
  
  
  71.         String client = request.getRemoteAddr(); 
    72.   
  
  
  
  72.         if (StringUtils.hasLength(client)) { 
    73.   
  
  
  
  73.             msg.append(", client=").append(client); 
    74.   
  
  
  
  74.         } 
    75.   
  
  
  
  75.         HttpSession session = request.getSession(false); 
    76.   
  
  
  
  76.         if (session != null) { 
    77.   
  
  
  
  77.             msg.append(", session=").append(session.getId()); 
    78.   
  
  
  
  78.         } 
    79.   
  
  
  
  79.         String user = request.getRemoteUser(); 
    80.   
  
  
  
  80.         if (user != null) { 
    81.   
  
  
  
  81.             msg.append(", user=").append(user); 
    82.   
  
  
  
  82.         } 
    83.   
  
  
  
  83.  
    84.   
  
  
  
  84.         HttpHeaders headers = new ServletServerHttpRequest(request).getHeaders(); 
    85.   
  
  
  
  85.         msg.append(", headers=").append(headers); 
    86.   
  
  
  
  86.  
    87.   
  
  
  
  87.         String payload = getMessagePayload(request); 
    88.   
  
  
  
  88.         if (payload != null) { 
    89.   
  
  
  
  89.             msg.append(", payload=").append(payload); 
    90.   
  
  
  
  90.         } 
    91.   
  
  
  
  91.  
    92.   
  
  
  
  92.         msg.append(suffix); 
    93.   
  
  
  
  93.         return msg.toString(); 
    94.   
  
  
  
  94.     } 
    95.   
  
  
  
  95.  
    96.   
  
  
  
  96.     protected String getMessagePayload(HttpServletRequest request) { 
    97.   
  
  
  
  97.         ContentCachingRequestWrapper wrapper = 
    98.   
  
  
  
  98.                 WebUtils.getNativeRequest(request, ContentCachingRequestWrapper.class); 
    99.   
  
  
  
  99.         if (wrapper != null) { 
    100.   
  
  
  
  100.             byte[] buf = wrapper.getContentAsByteArray(); 
    101.   
  
  
  
  101.             if (buf.length > 0) { 
    102.   
  
  
  
  102.                 int length = Math.min(buf.length, DEFAULT_MAX_PAYLOAD_LENGTH); 
    103.   
  
  
  
  103.                 try { 
    104.   
  
  
  
  104.                     return new String(buf, 0, length, wrapper.getCharacterEncoding()); 
    105.   
  
  
  
  105.                 } catch (UnsupportedEncodingException ex) { 
    106.   
  
  
  
  106.                     return "[unknown]"; 
    107.   
  
  
  
  107.                 } 
    108.   
  
  
  
  108.             } 
    109.   
  
  
  
  109.         } 
    110.   
  
  
  
  110.         return null; 
    111.   
  
  
  
  111.     } 
    112.   
  
  
  
  112. } 
    113.  
 
 

    别忘记配置ResponseBodyAdvice的logging级别为DEBUG。
    logstash-logback-encoder
    这个是logstash的logback编码器，可以结构化输出httptrace为json。引入：
     
 
 
 
        
  
  
  
    1.  
      2.   
  
  
  
    2.     net.logstash.logback 
      3.   
  
  
  
    3.     logstash-logback-encoder 
      4.   
  
  
  
    4.     6.6 
      5.   
  
  
  
    5.  
      6.  
 
 

    配置logback的ConsoleAppender为LogstashEncoder:
     
 
 
 
        
  
  
  
    1.  
      2.   
  
  
  
    2.      
      3.   
  
  
  
    3.          
      4.   
  
  
  
    4.      
      5.   
  
  
  
    5.      
      6.   
  
  
  
    6.          
      7.   
  
  
  
    7.      
      8.   
  
  
  
    8.  
      9.  
 
 

    然后同样实现一个解析的Filter:
     
 
 
 
        
  
  
  
    1. import org.slf4j.Logger; 
      2.   
  
  
  
    2. import org.slf4j.LoggerFactory; 
      3.   
  
  
  
    3. import org.slf4j.MDC; 
      4.   
  
  
  
    4. import org.springframework.core.annotation.Order; 
      5.   
  
  
  
    5. import org.springframework.stereotype.Component; 
      6.   
  
  
  
    6.  
      7.   
  
  
  
    7. import javax.servlet.*; 
      8.   
  
  
  
    8. import javax.servlet.http.HttpServletRequest; 
      9.   
  
  
  
    9. import javax.servlet.http.HttpServletResponse; 
      10.   
  
  
  
    10. import java.io.IOException; 
      11.   
  
  
  
    11. import java.util.UUID; 
      12.   
  
  
  
    12.  
      13.   
  
  
  
    13. /** 
      14.   
  
  
  
    14.  * @author felord.cn 
      15.   
  
  
  
    15.  * @since 1.0.8.RELEASE 
      16.   
  
  
  
    16.  */ 
      17.   
  
  
  
    17. @Order(1) 
      18.   
  
  
  
    18. @Component 
      19.   
  
  
  
    19. public class MDCFilter implements Filter { 
      20.   
  
  
  
    20.  
      21.   
  
  
  
    21.     private final Logger LOGGER = LoggerFactory.getLogger(MDCFilter.class); 
      22.   
  
  
  
    22.     private final String X_REQUEST_ID = "X-Request-ID"; 
      23.   
  
  
  
    23.  
      24.   
  
  
  
    24.     @Override 
      25.   
  
  
  
    25.     public void doFilter(ServletRequest request, 
      26.   
  
  
  
    26.                          ServletResponse response, 
      27.   
  
  
  
    27.                          FilterChain chain) throws IOException, ServletException { 
      28.   
  
  
  
    28.         HttpServletRequest req = (HttpServletRequest) request; 
      29.   
  
  
  
    29.         HttpServletResponse res = (HttpServletResponse) response; 
      30.   
  
  
  
    30.         try { 
      31.   
  
  
  
    31.             addXRequestId(req); 
      32.   
  
  
  
    32.             LOGGER.info("path: {}, method: {}, query {}", 
      33.   
  
  
  
    33.                     req.getRequestURI(), req.getMethod(), req.getQueryString()); 
      34.   
  
  
  
    34.             res.setHeader(X_REQUEST_ID, MDC.get(X_REQUEST_ID)); 
      35.   
  
  
  
    35.             chain.doFilter(request, response); 
      36.   
  
  
  
    36.         } finally { 
      37.   
  
  
  
    37.             LOGGER.info("statusCode {}, path: {}, method: {}, query {}", 
      38.   
  
  
  
    38.                     res.getStatus(), req.getRequestURI(), req.getMethod(), req.getQueryString()); 
      39.   
  
  
  
    39.             MDC.clear(); 
      40.   
  
  
  
    40.         } 
      41.   
  
  
  
    41.     } 
      42.   
  
  
  
    42.  
      43.   
  
  
  
    43.     private void addXRequestId(HttpServletRequest request) { 
      44.   
  
  
  
    44.         String xRequestId = request.getHeader(X_REQUEST_ID); 
      45.   
  
  
  
    45.         if (xRequestId == null) { 
      46.   
  
  
  
    46.             MDC.put(X_REQUEST_ID, UUID.randomUUID().toString()); 
      47.   
  
  
  
    47.         } else { 
      48.   
  
  
  
    48.             MDC.put(X_REQUEST_ID, xRequestId); 
      49.   
  
  
  
    49.         } 
      50.   
  
  
  
    50.     } 
      51.   
  
  
  
    51.  
      52.   
  
  
  
    52. } 
      53.  
 
 

    这里解析方式其实还可以更加精细一些。
    然后所有的日志都可以结构化为json了：
     
 
 
 
        
  
  
  
    1. {"@timestamp":"2021-08-10T23:48:51.322+08:00","@version":"1","message":"statusCode 200, path: /log/get, method: GET, query foo=xxx&bar=ooo","logger_name":"cn.felord.logging.MDCFilter","thread_name":"http-nio-8080-exec-1","level":"INFO","level_value":20000,"X-Request-ID":"7c0db56c-b1f2-4d85-ad9a-7ead67660f96"} 
      2.  
 
 

    总结
    今天介绍了不少记录追踪接口请求响应的方法，总有一款适合你。
    本文转载自微信公众号「码农小胖哥」，可以通过以下二维码关注。转载本文请联系码农小胖哥公众号。
                
    
                新闻标题：Spring Boot 记录请求响应日志的常用手段
                
    
                文章URL：http://www.shufengxianlan.com/qtweb/news25/536975.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
    
        
        
    
            
    猜你还喜欢下面的内容
    
            
        
    
    
    
    
        
    
            
    网站收录知识
    
            
        
    
        
    
            
    分类信息网站
    
            
        
    
    
    


    
    
    
        乐至网站建设　　 　成都服务器托管　　 　机柜租用　　 　成都多线机房　　 　蜀锦在线　　 　成都网络营销　　 　广告媒介投放　　 　成都网站建设　　 　seo网络营销推广　　 　东方电机技改服务有限公司　　 　网站推广　　 　泽君科技　　 　成都广告设计公司　　 　ssl数字证书　　 　绵阳梓潼网站建设　　 　香港空间腾讯云　　 　成都网站设计　　 　成都VI设计　　 　三台网站建设　　 　买链接