解决spring http输入流和输出流只能读取一次

1.需求：给某些请求接口记录日志，记录请求的数据和响应的数据和请求所花费的时间。这里采用非侵入式编程，也业务代码进行解耦。按照spring AOP 的编程思想。

2.编程设计：在spring 拦截器中植入日志代码。因为其刚好满足非侵入，且能捕获到请求和响应的数据。

3.了解spring 拦截器和过滤器的运行原理

　　先执行过滤器，然后执行拦截器。

4. 分析：当在拦截器中获取请求的输入流和响应的输出流的时候发现，只能读取一次，拦截器在具体的业务代码之前执行，导致请求的输入流被拦截器使用，到controller 的时候将获取不到数据。当响应的数据流被拦截器的postHandler 使用之后，输出到客户端没有响应的数据。

　　流程：先创建过滤器，过滤器是链式执行，配置的web.xml 的中。

　　WrapperFilter  在web.xml 中的配置

  <filter>
    <filter-name>sosWrapperFilter</filter-name>
    <filter-class>com.xiao.handler.filter.WrapperFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>sosWrapperFilter</filter-name>
<!-- 过滤的url地址  -->

    <url-pattern>/myTest/*</url-pattern>
  </filter-mapping>

 增加一个拦截器配置，配置需要过滤器的请求地址,走 spring mvc的拦截器，拦截的是请求地址（不包含上下文 eg:http://localost:8080/xiao）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/test/*"/>
            <bean class="com.xiao.interceptor.SosOrderInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

    
</beans>

　开始编写过滤器，拦截器

过滤器

/**
 *
 * @describ  request 请求过滤器增强
 * @date 2019-03-06
 * @author coder_xiao
 */
public class WrapperFilter implements  Filter  {

    private static Log log = LogFactory.getLog(WrapperFilter.class);


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        CacheContentRequestWrapper requestWrapper=null;
        CacheContentResponseWrapper responseWrapper=null;
        HttpServletRequest request=(HttpServletRequest)servletRequest;
        HttpServletResponse response=(HttpServletResponse) servletResponse;
        try {
                requestWrapper = new CacheContentRequestWrapper(request);
                responseWrapper = new CacheContentResponseWrapper(response);
       }catch (Exception e){
            log.error("获取requestWrapper失败！",e);
       }finally {
            if((requestWrapper!=null)&&(responseWrapper!=null)) {
                filterChain.doFilter(requestWrapper, responseWrapper);
                responseWrapper.reWriteResponse(responseWrapper,(HttpServletResponse) servletResponse);
            }else{
                filterChain.doFilter(servletRequest, servletResponse);
            }
        }

    }

    @Override
    public void destroy() {

    }
}

拦截器

public class SosOrderInterceptor implements HandlerInterceptor {

    private final static Log logger = LogFactory.getLog(SosOrderInterceptor.class);



    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
        BufferedReader  bufferedInput=null;
        String  data=null;
        try{
            String urlPath=request.getRequestURI();
            String contentType=request.getContentType();
            Boolean typeIndex=contentType==null?false:contentType.indexOf("application/json")>-1;
            Boolean createIndex=urlPath.indexOf("createOrder")>-1;
            Boolean buildIndex=urlPath.indexOf("buildDraftOrder")>-1;
            Boolean urlIndex=(urlPath.indexOf("createSosOrder")+urlPath.indexOf("buildDraftSosOrder"))>-2;
            //POST 请求 contentType=application/json
            if(typeIndex&&urlIndex) {
                //支持mark and reset 为使流复用
                CacheContentRequestWrapper  contentRequestWrapper= new CacheContentRequestWrapper(request);
                data = contentRequestWrapper.getBodyString();
                String requestId=UUIDUtil.uuid();
                request.setAttribute("requestId",requestId);
                BuildAudit audit=BeanTool.getBean(BuildAudit.class);
                //创建订单
                if (createIndex) {
                    logger.info("开始调用创建订单");
                    audit.buildData(data,"1","1","创建订单",requestId);
                }
                //创建草稿
                if (buildIndex) {
                    logger.info("创建草稿单！");
                    audit.buildData(data,"2","1","创建草稿单",requestId);
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.error(e);
        }finally {
            if(bufferedInput!=null) {
                bufferedInput.close();
            }
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object o, ModelAndView modelAndView) throws Exception {
        logger.info("postHandle");
        try{
            String urlPath=request.getRequestURI();
            String contentType=request.getContentType();
            Boolean typeIndex=contentType==null?false:contentType.indexOf("application/json")>-1;
            Boolean createIndex=urlPath.indexOf("createOrder")>-1;
            Boolean buildIndex=urlPath.indexOf("buildDraftOrder")>-1;
            Boolean urlIndex=(urlPath.indexOf("createSosOrder")+urlPath.indexOf("buildDraftOrder"))>-2;
            String requestId=  request.getAttribute("requestId")==null?null:request.getAttribute("requestId").toString();
            if(typeIndex&&urlIndex) {
                CacheContentResponseWrapper cacheResponse =(CacheContentResponseWrapper)((WebStatFilter.StatHttpServletResponseWrapper) response).getResponse();
                String data=new String(cacheResponse.getResponseData(),"UTF-8");
                BuildAudit audit=BeanTool.getBean(BuildAudit.class);
                //创建订单
                if (createIndex) {
                    audit.buildData(data,"1","2",null,requestId);
                }
                //创建草稿
                if (buildIndex) {
                    audit.buildData(data,"2","2",null,requestId);
                }
                //草稿单转正
                if (urlPath.indexOf("buildDraftSosOrder") > -1) {

                }
            }
        }catch (Exception e){
            logger.error(e);
        }
    }



    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        logger.info("afterCompletion");
        try{

        }catch (Exception ex){
            logger.error(ex);
        }
    }

两个缓存器

package com.lacesar.handler.wrapper;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * @description 包装spring 的 HttpServletRequestWrapper
 */
public class CacheContentRequestWrapper extends HttpServletRequestWrapper {

    private static Log log = LogFactory.getLog(CacheContentRequestWrapper.class);

    /**
     * 存储body数据的容器
     */
    private final byte[] body;

    private String requestId;

    public CacheContentRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        // 将body数据存储起来
        String bodyStr = getBodyString(request);
        body = bodyStr.getBytes("UTF-8");
    }

    /**
     * 获取请求Body
     *
     * @param request request
     * @return String
     */
    public String getBodyString(final ServletRequest request) {
        try {
            return inputStream2String(request.getInputStream());
        } catch (IOException e) {
            log.error("", e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取请求Body
     *
     * @return String
     */
    public String getBodyString() {
        if (body != null) {
            final InputStream inputStream = new ByteArrayInputStream(body);
            return inputStream2String(inputStream);
        } else {
            return null;
        }
    }

    /**
     * 将inputStream里的数据读取出来并转换成字符串
     *
     * @param inputStream inputStream
     * @return String
     */
    private String inputStream2String(InputStream inputStream) {
        StringBuilder sb = new StringBuilder();
        BufferedReader reader = null;

        try {
            reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            log.error("", e);
            throw new RuntimeException(e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    log.error("", e);
                }
            }
        }

        return sb.toString();
    }

    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    public ServletInputStream getInputStream() throws IOException {

        final ByteArrayInputStream inputStream = new ByteArrayInputStream(body);

        return new ServletInputStream() {
            public int read() throws IOException {
                return inputStream.read();
            }

            public boolean isFinished() {
                return false;
            }

            public boolean isReady() {
                return false;
            }

            public void setReadListener(ReadListener readListener) {
            }
        };
    }

    public String getRequestId() {
        return requestId;
    }

    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }
}

package com.lacesar.handler.wrapper;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

public class CacheContentResponseWrapper extends HttpServletResponseWrapper {
    private ByteArrayOutputStream buffer = null;
    private ServletOutputStream out = null;
    private PrintWriter writer = null;

    public CacheContentResponseWrapper(HttpServletResponse resp) throws IOException {
        super(resp);
        buffer = new ByteArrayOutputStream();
        out = new WapperedOutputStream(buffer);
        writer = new PrintWriter(new OutputStreamWriter(buffer, "UTF-8"));
    }

    /**
     * 重新写入response 数据
     *
     * @param wrapperResponse
     * @param response
     */
    public void reWriteResponse(CacheContentResponseWrapper wrapperResponse, HttpServletResponse response) {
        String result = null;
        try {
            result = new String(wrapperResponse.getResponseData(), "UTF-8");
            //解决可能在运行的过程中页面只输出一部分
            response.setContentLength(-1);
            response.setCharacterEncoding("UTF-8");
            PrintWriter out = null;
            out = response.getWriter();
            if (out != null) {
                out.write(result);
                out.flush();
                out.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public ServletOutputStream getOutputStream() throws IOException {
        return out;
    }

    public PrintWriter getWriter() throws UnsupportedEncodingException {
        return writer;
    }

    public void flushBuffer() throws IOException {
        if (out != null) {
            out.flush();
        }
        if (writer != null) {
            writer.flush();
        }
    }

    public void reset() {
        buffer.reset();
    }

    public byte[] getResponseData() throws IOException {
        flushBuffer();
        return buffer.toByteArray();
    }

    private class WapperedOutputStream extends ServletOutputStream {
        private ByteArrayOutputStream bos = null;

        public WapperedOutputStream(ByteArrayOutputStream stream) throws IOException {
            bos = stream;
        }

        @Override
        public void write(int b) throws IOException {
            bos.write(b);
        }

        @Override
        public void write(byte[] b) throws IOException {
            bos.write(b, 0, b.length);
        }

        public boolean isReady() {
            return false;
        }

        public void setWriteListener(WriteListener writeListener) {

        }
    }
}