实现对Request数据流和Response返回结果的代理

一、HttpServletRequestWrapper

       在拦截器或springMvc等流的方式读取Request的参数，由于只能使用一次，所以我这里记录了对Request的代理类，以便多次使用。

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.charset.Charset;

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

public class HttpServletRequestWrapper extends HttpServletRequestWrapper
{
    private final byte[] body;

    public HttpServletRequestWrapper(HttpServletRequest request) throws IOException
    {
	super(request);
	ServletInputStream stream = request.getInputStream();
	String requestBody = StreamUtils.copyToString(stream, Charset.forName("UTF-8"));
	body = requestBody.getBytes("UTF-8");
    }

    @Override
    public ServletInputStream getInputStream() throws IOException
    {
	final ByteArrayInputStream bais = new ByteArrayInputStream(body);
	return new ServletInputStream()
	{
	    @Override
	    public int read() throws IOException
	    {
		return bais.read();
	    }
	};
    }
}

        使用该代理类

// 解决Controller中RequestBody流的二次读取
ServletRequest requestWrapper = new HttpServletRequestWrapper(httpRequest);
	// 获取流中的请求参数
Object params = getBodyString(requestWrapper);

         getBodyString读取数据流

 private String getBodyString(ServletRequest request)
    {
	StringBuilder sb = new StringBuilder();
	InputStream inputStream = null;
	BufferedReader reader = null;
	try
	{
	    inputStream = request.getInputStream();
	    reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")));
	    String line = "";
	    while ((line = reader.readLine()) != null)
	    {
		sb.append(line);
	    }
	} catch (IOException e)
	{
	    e.printStackTrace();
	} finally
	{
	    if (inputStream != null)
	    {
		try
		{
		    inputStream.close();
		} catch (IOException e)
		{
		    e.printStackTrace();
		}
	    }
	    if (reader != null)
	    {
		try
		{
		    reader.close();
		} catch (IOException e)
		{
		    e.printStackTrace();
		}
	    }
	}
	return sb.toString();
    }

二、 ResponseWrapper

    实现对Response的代理，能在响应结果中加入自己想其他返回的内容。

import java.io.ByteArrayOutputStream;
import java.io.IOException;

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

public class ResponseWrapper extends HttpServletResponseWrapper
{
    private ByteArrayOutputStream buffer;

    private ServletOutputStream out;

    public ResponseWrapper(HttpServletResponse response)
    {
	super(response);
	buffer = new ByteArrayOutputStream();
	out = new WrapperOutputStream(buffer);
    }

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

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

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

    class WrapperOutputStream extends ServletOutputStream
    {
	private ByteArrayOutputStream bos;

	public WrapperOutputStream(ByteArrayOutputStream bos)
	{
	    this.bos = bos;
	}

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

      使用response代理类

// 转换成代理类
ResponseWrapper wrapperResponse = new ResponseWrapper((HttpServletResponse)servletResponse);
	// 这里只拦截返回，直接让请求过去，如果在请求前有处理，可以在这里处理
	chain.doFilter(requestWrapper, wrapperResponse);

	byte[] content = wrapperResponse.getContent();// 获取返回值
	String result = null;
	// 判断是否有值
	if (null != content)
	{
	    result = new String(content, "UTF-8");
	    // 把返回值输出到客户端
	    ServletOutputStream out = servletResponse.getOutputStream();
	    out.write(result.getBytes());
	    out.flush();
	}