Spring MVC利用过滤器打印日志

作者: 艺术类架构师 | 来源:发表于2019-08-06 14:12 被阅读0次

Spring MVC利用过滤器打印日志
Spring MVC表单防重复提交
Spring MVC表单防重复提交
Spring MVC禁止对CSS,JS,IMAGE等静态资源过滤
使用Traceld实现系统请求跟踪
2019-07-18 SpringMVC 数据绑定
Spring Boot - 过滤器
Spring MVC 拦截器（HandlerIntercepto
Java 面试系列：Spring MVC 核心组件 + 面试题
Spring MVC原理

在微服务架构体系中,利用SpringMVC打印单服务日志的实现形式有多种方式，本人了解的如下几种。

1.继承DispatcherServlet.

2.利用拦截器。

3.利用过滤器。

本章直接介绍用过滤器实现简单的打印请求上的输入输出日志,废话不多说了，直接贴干货吧，代码简单易懂!

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;

import javax.servlet.DispatcherType;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;

import static java.nio.charset.StandardCharsets.UTF_8;

/**
 * 在过滤器中打印输入输出日志
 * @Author
 * @Date 2019-08-06
 */
@Component
@Slf4j
public class LoggingFilter extends OncePerRequestFilter {

    ObjectMapper objectMapper=new ObjectMapper();

    /**
     * 支持打印的MediaType
     */
    private static final Set<MediaType> supportMediaTypes=new HashSet<>();
    {
        supportMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
        supportMediaTypes.add(MediaType.APPLICATION_JSON);
        supportMediaTypes.add(MediaType.TEXT_HTML);
        supportMediaTypes.add(MediaType.TEXT_PLAIN);
        supportMediaTypes.add(MediaType.APPLICATION_ATOM_XML);

    }

    final  List<String> resourceRequestsURI = Arrays.asList(
            "/css/", "/js/", "/scss/", "/fonts/",
            ".css", ".js", ".scss", ".eot",
            ".svg", ".ttf", ".woff", ".otf", ".ico", ".png");

    final List<String> swaggerRequestURI = Arrays.asList(
            "/v2/api-docs", "/swagger-resources","swagger-ui");

    @Override
    protected void doFilterInternal( HttpServletRequest httpServletRequest,
                                     HttpServletResponse httpServletResponse,
                                     FilterChain filterChain)  {

       try {

           doLog(httpServletRequest,httpServletResponse,filterChain);
       }
       catch (Exception e){
           log.error("do log filter has a error:{} ", ExceptionUtils.getRootCause(e));
       }
    }

    void doLog(final HttpServletRequest httpServletRequest,
               final HttpServletResponse httpServletResponse,
               final FilterChain filterChain) throws IOException, ServletException {

        ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper(httpServletRequest);
        ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(httpServletResponse);

        filterChain.doFilter(requestWrapper, responseWrapper);

        String requestUrl = requestWrapper.getRequestURL().toString();
        String requestId=UUID.randomUUID().toString();
        HttpMethod httpMethod = HttpMethod.valueOf(requestWrapper.getMethod());

        log.info(" request id is: {},http method is:{}",requestId,httpMethod.name());
        log.info("request id is: {},requestUrl  is:{}",requestId, requestUrl);

        Enumeration<String> parameterEnum=requestWrapper.getParameterNames();
        if(!ObjectUtils.isEmpty(parameterEnum)) {
            log.info("request id is: {},request param   is:{}",requestId,getRequestParamJSON(requestWrapper));

        }
        log.info("request id is: {},request header  is:{}", requestId,getRequestHeader(requestWrapper));


        if(HttpMethod.valueOf(httpServletRequest.getMethod())!=HttpMethod.GET) {
            if(supportMediaTypes.contains(MediaType.valueOf(httpServletRequest.getContentType()))) {
                log.info("request id is: {},request body  is:\n{}",requestId, new String(requestWrapper.getContentAsByteArray()));
            }
        }
        HttpStatus responseStatus = HttpStatus.valueOf(responseWrapper.getStatusCode());
        log.info("request id is: {},response status is:{}",requestId ,responseStatus.value());
        String responseBody = IOUtils.toString(responseWrapper.getContentInputStream(), UTF_8);


        if(httpServletRequest.isAsyncSupported()){
            log.info("request id is: {}, response payLoad is:\n{}",requestId, responseBody);
        }
        else if(!isAsyncStarted(httpServletRequest)&&httpServletRequest.getDispatcherType()!= DispatcherType.ASYNC) {
            log.info("request id is: {},response body is:{}",requestId ,objectMapper.readTree(responseBody));
        }

        else {
            log.info("request id is: {}, cause by request is async:response body is:{}", requestId,"empty");

        }
        responseWrapper.copyBodyToResponse();
    }

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request)  {

        String requestUrl=request.getRequestURL().toString();
        return  isResourceUrl(requestUrl)||isSwaggerResource(requestUrl);
    }

    /**
     * 请求参数列表
     * @param requestWrapper
     * @return
     */
    private JSONObject getRequestParamJSON(ContentCachingRequestWrapper requestWrapper){
        Enumeration<String> parameterEnum=requestWrapper.getParameterNames();
        JSONObject paramJsonObject=new JSONObject();
        if(!ObjectUtils.isEmpty(parameterEnum)) {
            while (parameterEnum.hasMoreElements()) {
                String name= parameterEnum.nextElement();
                String []value=requestWrapper.getParameterValues(name);
                paramJsonObject.put(name,value);

            }
        }
        return  paramJsonObject;
    }

    /**
     *
     * @param requestWrapper
     * @return 请求头参数列表
     */
    private JSONObject getRequestHeader(ContentCachingRequestWrapper requestWrapper){

        Enumeration headerNames = requestWrapper.getHeaderNames();
        JSONObject headerJsonObject=new JSONObject();
        while (headerNames.hasMoreElements()) {
            String headerName = (String) headerNames.nextElement();
            headerJsonObject.put(headerName,requestWrapper.getHeader(headerName));
        }
        return  headerJsonObject;
    }

    private boolean isResourceUrl(String url) {
        return resourceRequestsURI.stream().anyMatch(e->url.contains(e));
    }

    private boolean isSwaggerResource(String url) {
        return swaggerRequestURI.stream().anyMatch(e->url.contains(e));

    }
}

附带继承DispatchServlet实现日志打印

package com.application.config;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.BaseJsonNode;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Logger;

public class CustLoggingDispatcherServlet extends DispatcherServlet {

    private static final org.slf4j.Logger logger = LoggerFactory.getLogger("logging");

    private static final ObjectMapper mapper = new ObjectMapper();

    @Override
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper(request);
        ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(response);
        //创建一个 json 对象，用来存放 http 日志信息
        ObjectNode rootNode = mapper.createObjectNode();
        rootNode.put("uri", requestWrapper.getRequestURI());
        rootNode.put("clientIp", requestWrapper.getRemoteAddr());
        rootNode.set("requestHeaders", mapper.valueToTree(getRequestHeaders(requestWrapper)));
        String method = requestWrapper.getMethod();
        rootNode.put("method", method);
        try {
            super.doDispatch(requestWrapper, responseWrapper);
        } finally {
            if(method.equals("GET")) {
                rootNode.set("request", mapper.valueToTree(requestWrapper.getParameterMap()));
            }
            else {
                JsonNode newNode = mapper.readTree(requestWrapper.getContentAsByteArray());
                rootNode.set("request", newNode);
            }

            if(response.getContentType().equals(MediaType.APPLICATION_JSON.getType())
                    &&response.getContentType().equals( MediaType.APPLICATION_JSON_UTF8.getType())) {
                JsonNode newNode = mapper.readTree(responseWrapper.getContentInputStream());
                rootNode.set("response", newNode);
            }
            else{
                JsonNode newNode = JsonNodeFactory.instance.textNode(new String(responseWrapper.getContentAsByteArray()));
                rootNode.set("response", newNode);

            }

            responseWrapper.copyBodyToResponse();

            rootNode.set("responseHeaders", mapper.valueToTree(getResponsetHeaders(responseWrapper)));
            logger.info(rootNode.toString());
        }
    }

    private Map<String, Object> getRequestHeaders(HttpServletRequest request) {
        Map<String, Object> headers = new HashMap<>();
        Enumeration<String> headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String headerName = headerNames.nextElement();
            headers.put(headerName, request.getHeader(headerName));
        }
        return headers;

    }

    private Map<String, Object> getResponsetHeaders(ContentCachingResponseWrapper response) {
        Map<String, Object> headers = new HashMap<>();
        Collection<String> headerNames = response.getHeaderNames();
        for (String headerName : headerNames) {
            headers.put(headerName, response.getHeader(headerName));
        }
        return headers;
    }
}

@Bean
    public ServletRegistrationBean dispatcherRegistration() {
        return new ServletRegistrationBean(dispatcherServlet());
    }
    @Bean(name = DispatcherServletAutoConfiguration.DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    public DispatcherServlet dispatcherServlet() {
        return new CustLoggingDispatcherServlet();
    }

Spring MVC利用过滤器打印日志
在微服务架构体系中,利用SpringMVC打印单服务日志的实现形式有多种方式，本人了解的如下几种。 1.继承Dis...
Spring MVC表单防重复提交
利用Spring MVC的过滤器及token传递验证来实现表单防重复提交。创建注解 @Target(Elem...
Spring MVC表单防重复提交
利用Spring MVC的过滤器及token传递验证来实现表单防重复提交。创建注解 @Target(Elemen...
Spring MVC禁止对CSS,JS,IMAGE等静态资源过滤
在使用Spring MVC时，我们默认对过滤器是这样子设置： mvc-dispatcher / 这样的后...
使用Traceld实现系统请求跟踪
1、建立一个过滤器，在过滤器中给线程设置TraceId2、将日志的配置文件进行修改，把TraceId打印到日志中 ...
2019-07-18 SpringMVC 数据绑定
1.Spring MVC数据绑定基本概念在为发明Spring MVC之前，我们一般使用的方法是，利用doPost...
Spring Boot - 过滤器
Spring MVC中的拦截器和过滤器都是基于AOP实现的，它们比较相似，但也有不同，最明显的差异就是：过滤器可以...
Spring MVC 拦截器（HandlerIntercepto
Spring MVC的处理器拦截器（HandlerInterceptor）类似于Servlet 规范中的过滤器Fi...
Java 面试系列：Spring MVC 核心组件 + 面试题
Spring MVC 介绍 Spring MVC（Spring Web MVC）是 Spring Framewor...
Spring MVC原理
【spring】Spring MVC原理 1.Spring MVC概述： Spring MVC是Spring提供的...