實現對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();
	}