通过Filter实现修改http请求、响应

╰半橙微兮° 2022-10-05 09:51 363阅读 0赞

请求头和请求参数是不能直接修改，在servlet或者Controller中获取参数本质上是通过 getParameter(String name) 或者 public String[] getParameterValues(String name) 方法，但无论是ServletRequest还是HttpServletRequest都没提供修改请求头、请求参数方法（没有setHeader、setParameter方法，只提供了setAttribute方法）；

注：getParameterMap()返回的时一个不可修改的map，所以也无法通过该方法来修改请求参数。

那到底该如何做才能实现呢？答案：通过装饰模式

一、修改请求

1、ServletRequestWrapper介绍：

简单介绍下ServletRequest、HttpServletRequest、ServletRequestWrapper以及HttpServletRequestWrapper他们之间的层次关系：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70

简单画一下UML图：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 1

上面这个关系毫无疑问是一个很标准的装饰模式：

  • ServletRequest：抽象组件
  • HttpServletRequest：抽象组件的一个子类，它的实例被称做“被装饰者”ide
  • ServletRequestWrapper：一个基本的装饰类，这里是非抽象的工具
  • HttpServletRequestWrapper：一个具体的装饰者，固然这里也继承了HttpServletRequest这个接口，是为了获取一些在ServletRequest中没有的方法
  • ModifyParametersWrapper：一样是 一个具体的装饰者（自定义的一个类）

注：一个标准的装饰模式的UML类图是这样的：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXhpYW83MjM4NDY_size_16_color_FFFFFF_t_70 2

2、Filter中修改请求参数、请求头原理：

在servlet、Controller中处理request的对象是HttpServletRequest接口实现类，HttpServletRequestWrapper类实现类该接口；我们可以利用装饰模式，创建一个装饰类继承HttpServletRequestWrapper，然后重写其中关于请求参数、请求头的方法，最后在Filter中将装饰类再传递下去，这样servlet中就可以通过getParameter方法获取被修改过的请求参数来。

  • 请求参数相关的方法：String getQueryString()、Map getParameterMap()、String[] getParameterValues(String name)、String getParameter(String name)、Enumeration getParameterNames()
  • 请求头相关的方法：String getHeader(String name)、Enumeration getHeaderNames()、Enumeration getHeaders(String name)

同理修改请求的cookie也是一样的道理。

3、示例（修改请求头、请求体）：

1）定义MyRequestWrapper

  1. public class MyRequestWrapper extends HttpServletRequestWrapper  {
  2.     private Map<String,String[]> paramsMap;
  3.     private Map<String, String> headerMap;
  4.     public MyRequestWrapper(HttpServletRequest request) {
  5.         super(request);
  7.         this.paramsMap = new HashMap<>();
  8.         this.paramsMap.putAll(request.getParameterMap());
  10.         this.headerMap = new HashMap<>();
  11.     }
  13.     public void addParameter(String name,String value) {
  14.         String[] parameterValues = getParameterValues(name);
  15.         if (parameterValues == null) {
  16.             this.paramsMap.put(name, new String[] {value});
  17.         } else {
  18.             parameterValues = Arrays.copyOf(parameterValues, parameterValues.length + 1);
  19.             parameterValues[parameterValues.length-1] = value;
  20.             this.paramsMap.put(name, parameterValues);
  21.         }
  22.     }
  24.     @Override
  25.     public Enumeration<String> getParameterNames() {
  26.         Vector<String> vector = new Vector<String>(paramsMap.keySet());
  27.         return vector.elements();
  28.     }
  29.     @Override
  30.     public String getParameter(String name) {
  31.          if(paramsMap.containsKey(name)) {
  32.              return paramsMap.get(name).length > 0 ? paramsMap.get(name)[0] : null;
  33.          }
  34.          return null;
  35.     }
  36.     @Override
  37.     public String[] getParameterValues(String name) {
  38.          return paramsMap.get(name);
  39.     }
  40.     @Override
  41.     public Map<String, String[]> getParameterMap() {
  42.           return Collections.unmodifiableMap(paramsMap);
  43.     }
  44.     @Override
  45.     public String getQueryString() {
  46.         StringBuilder sb = new StringBuilder();
  47.         if(paramsMap != null) {
  48.             for(Map.Entry<String, String[]> en : paramsMap.entrySet()) {
  49.                 sb.append(en.getKey()).append("=").append(en.getValue()[0]).append("&");
  50.             }
  51.         }
  52.         int len = sb.length();
  53.         if(len > 0) {
  54.             sb.deleteCharAt(len-1);
  55.         }
  56.         return sb.toString();
  57.     }
  60.     public void addHeader(String name, String value){
  61.         this.headerMap.put(name, value);
  62.     }
  63.     @Override
  64.     public String getHeader(String name) {
  65.         String headerValue = headerMap.get(name);
  66.         if (headerValue != null){
  67.             return headerValue;
  68.         }
  69.         return super.getHeader(name);
  70.     }
  72.     @Override
  73.     public Enumeration<String> getHeaderNames() {
  74.         List<String> names = Collections.list(super.getHeaderNames());
  75.         for (String name : headerMap.keySet()) {
  76.             names.add(name);
  77.         }
  78.         return Collections.enumeration(names);
  79.     }
  81.     @Override
  82.     public Enumeration<String> getHeaders(String name) {
  83.         List<String> values = Collections.list(super.getHeaders(name));
  84.         if (headerMap.containsKey(name)) {
  85.             values.add(headerMap.get(name));
  86.         }
  87.         return Collections.enumeration(values);
  88.     }
  89. }

2）Filter：

  1. public class MyFilter implements Filter {
  2.     private FilterConfig filterConfig;
  4.     @Override
  5.     public void init(FilterConfig filterConfig) throws ServletException {
  6.         this.filterConfig = filterConfig;
  7.         System.out.println("filter init...");
  8.     }
  10.     @Override
  11.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  12.             throws IOException, ServletException {
  13.         MyRequestWrapper requestWrapper = new MyRequestWrapper((HttpServletRequest)request);
  15.         modifyParameter(requestWrapper,request);
  16.         modifyHeader(requestWrapper,request);
  18.         chain.doFilter(requestWrapper, response);
  19.     }
  21.     //修改请求参数
  22.     private void modifyParameter(MyRequestWrapper requestWrapper,ServletRequest request) {
  23.         requestWrapper.addParameter("myParam", "test");
  24.     }
  25.     //修改请求头
  26.     private void modifyHeader(MyRequestWrapper requestWrapper,ServletRequest request) {
  27.         requestWrapper.addHeader("myHead", "test");
  28.     }
  30.     @Override
  31.     public void destroy() {
  32.         System.out.println("filter destory...");
  33.     }
  34. }

3）配置Filter：

  1. <filter>
  2.     <filter-name>myFilter</filter-name>
  3.     <filter-class>cn.edu.nuc.springmvc_test.filter.MyFilter</filter-class>
  4.   </filter>
  5.   <filter-mapping>
  6.     <filter-name>myFilter</filter-name>
  7.     <url-pattern>/*</url-pattern>
  8.   </filter-mapping>

4）测试：

在servlet或者Controller中可以通过如下方式获取修改的参数、请求头

  1. String header = request.getHeader("myHead");
  2. String param = request.getParameter("myParam");

4、HttpServletRequest的输入流只能读取一次的问题：

对于Post的请求，我们可以通过调用request.getInputStream()获取请求体，将其转换成String，进而获取Post请求数据。对于上传文件，也是一个道理。

但是需要注意一点：在一次请求中，无论是在Filter、Servlet还是Controller中，调用request.getInputStream()方法获取请求体数据流，之后再次调用就无法获取请求体数据流类。

1）原因：

InputStream的read()方法内部有一个postion，标志当前流被读取到的位置，每读取一次，该标志就会移动一次，如果读到最后，read()会返回-1，表示已经读取完了。如果想要重新读取则需要调用reset()方法，position就会移动到上次调用mark的位置，mark默认是0，所以就能从头再读了。调用reset()方法的前提是已经重写了reset()方法，当然能否reset也是有条件的，它取决于markSupported()方法是否返回true。

request.getInputStream()方法返回的类型是ServletInputStream，它继承于InputStream。InputStream默认不实现reset()，并且markSupported()默认也是返回false；ServletInputStream该类也没有重写mark()，reset()以及markSupported()方法。

所以，request.getInputStream()无法重复读取流，这就是我们从request对象中获取的输入流就只能读取一次的原因。

2）解决：

最简单的方法：在请求最开始，将请求流数据保存到一个byte数组中，在同一个request中的后续操作直接从byte数组中获取数据即可。

实现：使用装饰模式，借助Filter可以简单来实现。

A、定义MyRequestWrapper2：

  1. import java.io.BufferedReader;
  2. import java.io.ByteArrayInputStream;
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import javax.servlet.ReadListener;
  8. import javax.servlet.ServletInputStream;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletRequestWrapper;
  12. public class MyRequestWrapper2 extends HttpServletRequestWrapper  {
  13.     private  byte[] body;
  15.     public MyRequestWrapper2(HttpServletRequest request) {
  16.         super(request);
  17.         try {
  18.             body = read((InputStream)request.getInputStream());
  19.         } catch (Exception e) {
  20.         }
  21.     }
  23.     @Override
  24.     public BufferedReader getReader() throws IOException {
  25.         return new BufferedReader(new InputStreamReader(getInputStream()));
  26.     }
  27.     @Override
  28.     public ServletInputStream getInputStream() throws IOException {
  29.         final ByteArrayInputStream inputStream = new ByteArrayInputStream(body);
  30.         return new ServletInputStream() {
  31.             @Override
  32.             public int read() throws IOException {
  33.                 return inputStream.read();
  34.             }
  35.             @Override
  36.             public boolean isFinished() {
  37.                 return false;
  38.             }
  39.             @Override
  40.             public boolean isReady() {
  41.                 return false;
  42.             }
  43.             @Override
  44.             public void setReadListener(ReadListener listener) {
  46.             }
  47.         };
  48.     }
  50.     private byte[] read(InputStream inStream)throws Exception{
  51.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  52.         byte[] buffer = new byte[1024];
  53.         int len = 0;
  54.         while((len=inStream.read(buffer))!=-1){
  55.             outputStream.write(buffer, 0, len);
  56.         }
  57.         inStream.close();
  58.         return outputStream.toByteArray();
  59.     }
  60. }

说明：重写getReader和getInputStream方法。此外，这里使用了动态字节数组ByteArrayOutputStream和ByteArrayInputStream。

B、Filter：

  1. @Override
  2.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  3.             throws IOException, ServletException {
  4.         MyRequestWrapper2 requestWrapper = new MyRequestWrapper2((HttpServletRequest)request);
  6.         chain.doFilter(requestWrapper, response);
  7.     }

C、测试：

  1. private String inputStream2String(InputStream inputStream) {
  2.         StringBuilder sb = new StringBuilder();
  3.         BufferedReader reader = null;
  4.         try {
  5.             reader = new BufferedReader(new InputStreamReader(inputStream, Charset.defaultCharset()));
  6.             String line;
  7.             while ((line = reader.readLine()) != null) {
  8.                 sb.append(line);
  9.             }
  10.         } catch (IOException e) {
  11.             throw new RuntimeException(e);
  12.         } finally {
  13.             if (reader != null) {
  14.                 try {reader.close();} catch (IOException e) {}
  15.             }
  16.         }
  17.         return sb.toString();
  18.     }
  20. @RequestMapping(value="/test4")
  21. @ResponseBody
  22. public Map<String,String> test4(HttpServletRequest request,HttpServletResponse httpResponse) {
  23.         Map<String ,String> res = new HashMap<>();
  25.         //stream
  26.         try {
  27.             ServletInputStream inputStream = request.getInputStream();
  28.             String inputStream2String = inputStream2String(inputStream);
  29.             System.out.println(inputStream2String);
  31.             ServletInputStream inputStream2 = request.getInputStream();
  32.             String inputStream2String2 = inputStream2String(inputStream2);
  33.             System.out.println(inputStream2String2);
  34.         } catch (IOException e) {
  35.             e.printStackTrace();
  36.         }
  37. }

二、修改响应

有时我们希望在请求输出之前对response对象进行一些额外的操作，最后再发往客户端。同HttpServletRequest，HttpServletResponse对象没有Buffer功能，且只能读取一次，要实现修改响应，只能通过装饰模式，继承HttpServletResponseWrapper类来达到。

继承HttpServletResponseWrapper都需要重写那些方法呢？

  1. 以流的方式获取输出——重写getOutputStream() //返回一般为打印流，其底层是对ServletOutputStream引用。
  2. 以字符方式获取输出——重写getWriter() //直接对ServletOutputStream的引用
  3. 刷新流——重写flushBuffer()
  4. 重置流——重写reset()

示例：

1）定义response包装器WapperedResponse继承HttpServletResponseWrapper

  1. package cn.edu.nuc.springmvc_test.filter;
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  5. import java.io.OutputStreamWriter;
  6. import java.io.PrintWriter;
  7. import java.io.UnsupportedEncodingException;
  8. import javax.servlet.ServletOutputStream;
  9. import javax.servlet.WriteListener;
  10. import javax.servlet.http.HttpServletResponse;
  11. import javax.servlet.http.HttpServletResponseWrapper;
  13. public class MyResponseWrapper extends HttpServletResponseWrapper {
  14.     private ByteArrayOutputStream buffer = null;
  15.     private ServletOutputStream out = null;
  16.     private PrintWriter writer = null;
  18.     public MyResponseWrapper(HttpServletResponse resp) throws IOException { 
  19.         super(resp); 
  20.         buffer = new ByteArrayOutputStream();// 真正存储数据的流 
  21.         out = new WapperedOutputStream(buffer); 
  22.         writer = new PrintWriter(new OutputStreamWriter(buffer, this.getCharacterEncoding())); 
  23.     }
  25.     @Override
  26.     public ServletOutputStream getOutputStream() throws IOException {
  27.         return out;
  28.     }
  29.     @Override
  30.     public PrintWriter getWriter() throws UnsupportedEncodingException {
  31.         return writer;
  32.     }
  33.     @Override
  34.     public void flushBuffer() throws IOException {
  35.         if (out != null) {
  36.             out.flush();
  37.         }
  38.         if (writer != null) {
  39.             writer.flush();
  40.         }
  41.     }
  42.     @Override
  43.     public void reset() {
  44.         buffer.reset();
  45.     }
  47.     public byte[] getResponseData() throws IOException {
  48.         flushBuffer();
  49.         return buffer.toByteArray();
  50.     }
  52.     private class WapperedOutputStream extends ServletOutputStream {
  53.         private ByteArrayOutputStream bos = null;
  54.         public WapperedOutputStream(ByteArrayOutputStream stream) throws IOException {
  55.             bos = stream;
  56.         }
  58.         @Override
  59.         public void write(int b) throws IOException {
  60.             bos.write(b);
  61.         }
  62.         @Override
  63.         public void write(byte[] b) throws IOException {
  64.             bos.write(b, 0, b.length);
  65.         }
  66.         @Override
  67.         public boolean isReady() {
  68.             return false;
  69.         }
  70.         @Override
  71.         public void setWriteListener(WriteListener listener) {
  72.         }
  73.     }
  74. }

2）过滤器：

  1. public class MyFilter2 implements Filter {
  3.     @Override
  4.     public void init(FilterConfig filterConfig) throws ServletException {
  5.         System.out.println("filter init...");
  6.     }
  8.     @Override
  9.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  10.             throws IOException, ServletException {
  11.         MyResponseWrapper wrapResponse = new MyResponseWrapper((HttpServletResponse)response); 
  13.         chain.doFilter(request, wrapResponse); 
  15.         byte[] data = wrapResponse.getResponseData(); 
  16.         System.out.println("原始数据： " + new String(data)); 
  17.         String tempData = new String("jack"); 
  18.         ServletOutputStream out = response.getOutputStream(); 
  19.         out.write(tempData.getBytes()); 
  20.         out.flush(); 
  22.     }
  24.     @Override
  25.     public void destroy() {
  26.         System.out.println("filter destory...");
  27.     }
  28. }

发表评论

表情：
评论列表 （有 0 条评论，363人围观）

还没有评论，来说两句吧...

相关阅读