如何使用servlet过滤器记录请求和响应，保留请求正文和响应正文？

Question

我试图记录应用程序中的每个传入请求和传出响应。我正在使用jee 6，所以我没有ContainerRequestFilter和ContainerResponseFilter类。所以我决定用滤镜。

我用@WebFilter（“/*”）注释了一个类，并实现了Filter接口。我成功地读取了请求头和请求正文。我也很难阅读响应标题和响应正文。下面是代码片段

MyHttpServletResponseWrapper wrapper = new MyHttpServletResponseWrapper((HttpServletResponse) response);
chain.doFilter(request, wrapper);

MyHttpServletResponse seWrapper类

public class MyHttpServletResponseWrapper extends HttpServletResponseWrapper {
    private StringWriter sw = new StringWriter();
    public MyHttpServletResponseWrapper(HttpServletResponse response) { super(response); }

    public PrintWriter getWriter() { return new PrintWriter(sw); }

    public ServletOutputStream getOutputStream() {
        return new ServletOutputStream (){
            public void write(int B) { sw.append((char) B); }
        };
    }

    public String getCopy() { sw.toString(); }
}

记录响应后，我将响应写回输出流，以便客户端可以接收响应。下面是代码

logResponse(wrapper);
response.getOutputStream().write(wrapper.getCopy().getBytes());

我不明白的是，阅读后如何将请求正文放回输入流中。

在像Jersey这样的标准API中，有一种使用setEntityInputStream(inputStream)将它放回去的简便方法

如何使用标准的 Java 服务器输出流 API 来做到这一点。

我不是在试图重新发明轮子。我试图避免使用Jersey，以便我的代码可以轻松迁移到新的jee版本。我也想了解像Jersey这样的API是如何做到这一点的。

要阅读正文的响应，我阅读了下面的链接，但它对我不起作用。容器抛出了一个异常，说作者已经获得了。

捕获并记录响应正文

附笔。

我想我想出了如何将输入流设置回去。下面是一些代码

MyRequestWrapper requestwrapper = new MyRequestWrapper((HttpServletRequest) request);

chain.doFilter；

我的请求包装器类

public class MyRequestWrapper extends HttpServletRequestWrapper {
    String body; 
    int counter;
    public MyRequestWrapper(HttpServletRequest request) { super(request); }

    public void setBody(String body) { this.body = body;}

    public ServletInputStream getInputStream() {
        return new ServletInputStream() {
            public interest read() throws IOException {
                if(counter >=body.length()) return -1;
                return body.charAt(counter++);
            }
        };
    }
}

我知道被重写的getInputStream和getOutputStream中的代码质量都不怎么样。现在我不担心这个。我想知道这是不是一个正确的想法？如果是这样的话，我想专注于代码质量。

Answer 1

/** I know its too late but it can be helpfull for others as well. **//
import java.io.IOException;
import java.io.UnsupportedEncodingException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;

public class ApiIOLoggerFilter implements Filter {
@Override 
public void init(FilterConfig filterConfig) {}
@Override 
public void destroy() {}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {
        ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper((HttpServletRequest) request);
        ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper((HttpServletResponse) response);
        try {
            chain.doFilter(requestWrapper, responseWrapper);
        } finally {
            performRequestAudit(requestWrapper);
            performResponseAudit(responseWrapper);
        }
    } else {
        chain.doFilter(request, response);
    }
}

private void performRequestAudit(ContentCachingRequestWrapper requestWrapper) {
    if (requestWrapper != null && requestWrapper.getContentAsByteArray() != null && requestWrapper.getContentAsByteArray().length > 0) {
        logger.info("\n Headers:: {} \n Request Body:: {}", new ServletServerHttpRequest((HttpServletRequest)requestWrapper.getRequest()).getHeaders(),
                getPayLoadFromByteArray(requestWrapper.getContentAsByteArray(), requestWrapper.getCharacterEncoding()));
    }
}

private void performResponseAudit(ContentCachingResponseWrapper responseWrapper)
        throws IOException {
    if (responseWrapper != null && responseWrapper.getContentAsByteArray() != null
            && responseWrapper.getContentAsByteArray().length > 0) {
        logger.info("Response Body:: {}", getPayLoadFromByteArray(responseWrapper.getContentAsByteArray(),
                responseWrapper.getCharacterEncoding()));
    } else {
        performErrorResponseAudit(responseWrapper);
    }
    responseWrapper.copyBodyToResponse();
}

private void performErrorResponseAudit(ContentCachingResponseWrapper responseWrapper) {
    logger.warn("HTTP Error Status Code::" + responseWrapper.getStatus());
}

private String getPayLoadFromByteArray(byte[] requestBuffer, String charEncoding) {
    String payLoad = "";
    try {
        payLoad = new String(requestBuffer, charEncoding);
    } catch (UnsupportedEncodingException unex) {
        payLoad = "Unsupported-Encoding";
    }
    return payLoad;
}

}