使用HttpServletRequestWrapper HttpServletResponseWrapper修改请求响应数据

1.请求Wrapper

使用请求Wrapper将请求数据重新包装

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class MyHttpServletRequestWrapper extends HttpServletRequestWrapper {
    private final byte[] body;
    public MyHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        byte[] inputStream= request.getInputStream();
        //修改请求流逻辑
        body = inputStream;
    }
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);

        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;

            }

            @Override
            public void setReadListener(ReadListener readListener) {
            }

            @Override
            public int read() throws IOException {
                return bais.read();
            }
        };
    }
}

2.响应Wrapper

用于将响应数据重新包装

import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import java.io.*;

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

    public ResponseReplaceWrapper(HttpServletResponse resp) throws IOException{
        super(resp);
        //真正存储数据的流
        buffer=new ByteArrayOutputStream();
        out=new WapperedOutputStream(buffer);
        writer=new PrintWriter(new OutputStreamWriter(buffer,this.getCharacterEncoding()));
    }

    /**
     * 重载父类获取outputstream的方法
     * @return
     * @throws IOException
     */
    @Override
    public ServletOutputStream getOutputStream()throws IOException{
        return out;
    }

    /**
     * 重载父类获取writer的方法
     * @return
     * @throws UnsupportedEncodingException
     */
    @Override
    public PrintWriter getWriter() throws UnsupportedEncodingException{
        return writer;
    }

    /**
     * 重载父类获取flushBuffer的方法
     * @throws IOException
     */
    @Override
    public void flushBuffer()throws IOException{
        if(out!=null){
            out.flush();
        }
        if(writer!=null){
            writer.flush();
        }
    }
    @Override
    public void reset(){
        buffer.reset();
    }
    public byte[] getResponseData()throws IOException{
        //将out、writer中的数据强制输出到WapperedResponse的buffer里面，否则取不到数据
        flushBuffer();
        return buffer.toByteArray();
    }

    /**
     * 内部类，对ServletOutputStream进行包装
     */
    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 boolean isReady() {
            return false;
        }

        @Override
        public void setWriteListener(WriteListener writeListener) {

        }
    }
}

3.过滤器

使用过滤器拦截并重新组装报文

import org.apache.catalina.connector.RequestFacade;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * 过滤器
 */
@WebFilter(filterName="pathFilter",urlPatterns="/*")
public class PathFilter implements Filter {
    /**
     * Filter过滤器销毁
     */
    @Override
    public void destroy() {
    }

    /**
     * Filter指定过滤器操作
     * @param request
     * @param response
     * @param chain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
                MyHttpServletRequestWrapper requestWrapper = new MyHttpServletRequestWrapper((HttpServletRequest) request);
                ResponseReplaceWrapper responseReplaceWrapper = new ResponseReplaceWrapper((HttpServletResponse) response);
                chain.doFilter(requestWrapper, responseReplaceWrapper);          
                this.writeResponse(response,responseReplaceWrapper.getResponseData());
    }

    /**
     * Filter初始化
     * @param arg0
     * @throws ServletException
     */
    @Override
    public void init(FilterConfig arg0) throws ServletException {
    }

    /**
     * 将相应数据转码并写入响应
     * @param response
     * @param outByte
     * @throws IOException
     */
    private void writeResponse(ServletResponse response,byte[] outByte) throws IOException {
        //响应数据并转码
        byte[] outEbcdic= EbcdicUtils.gbk2Ebcdic(outByte);
        //把返回值输出到客户端
        ServletOutputStream out = response.getOutputStream();
        out.write(outEbcdic);
        out.flush();
        out.close();
    }
}