filter高级应用

Filter高级应用：
 Decorator模式 
 1）包装类需要和被包装对象 实现相同接口，或者继承相同父类
 2）包装类需要持有 被包装对象的引用 
  在包装类中定义成员变量，通过包装类构造方法，传入被包装对象 
 3）在包装类中，可以控制原来那些方法需要加强
 不需要加强 ，调用被包装对象的方法
 需要加强，编写增强代码逻辑 
 ServletRequestWrapper 和 HttpServletRequestWrapper 
 提供对request对象进行包装的方法，但是默认情况下每个方法都是调用原来request对象的方法，
 也就是说包装类并没有对request进行增强 
 如果要增强就可以在这两个包装类基础上，继承HttpServletRequestWrapper 和 HttpServletRequestWrapper 覆盖需要增强的方法即可
 6.完全解决get和post乱码的过滤器 
 在Filter中，对request对象进行包装，增强获得参数的方法 
 getParameter 
 getParameterValues
 getParameterMap
 参考代码：

 public class GenericEncodingFilter implements Filter {
     @Override
     public void destroy() {
     }
     @Override
     public void doFilter(ServletRequest request, ServletResponse response,
             FilterChain chain) throws IOException, ServletException {
         // 转型为与协议相关对象
         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
         // 对request包装增强
         HttpServletRequest myrequest = new MyRequest(httpServletRequest);
         chain.doFilter(myrequest, response);
     }
     @Override
     public void init(FilterConfig filterConfig) throws ServletException {
     }
 }

 // 自定义request对象
 class MyRequest extends HttpServletRequestWrapper {

     private HttpServletRequest request;

     private boolean hasEncode;

     public MyRequest(HttpServletRequest request) {
         super(request);// super必须写
         this.request = request;
     }
     // 对需要增强方法 进行覆盖
     @Override
     public Map getParameterMap() {
         // 先获得请求方式
         String method = request.getMethod();
         if (method.equalsIgnoreCase("post")) {
             // post请求
             try {
                 // 处理post乱码
                 request.setCharacterEncoding("utf-8");
                 return request.getParameterMap();
             } catch (UnsupportedEncodingException e) {
                 e.printStackTrace();
             }
         } else if (method.equalsIgnoreCase("get")) {
             // get请求
             Map<String, String[]> parameterMap = request.getParameterMap();
             if (!hasEncode) { // 确保get手动编码逻辑只运行一次
                 for (String parameterName : parameterMap.keySet()) {
                     String[] values = parameterMap.get(parameterName);
                     if (values != null) {
                         for (int i = 0; i < values.length; i++) {
                             try {
                                 // 处理get乱码
                                 values[i] = new String(values[i]
                                         .getBytes("ISO-8859-1"), "utf-8");
                             } catch (UnsupportedEncodingException e) {
                                 e.printStackTrace();
                             }
                         }
                     }
                 }
                 hasEncode = true;
             }
             return parameterMap;
         }
         return super.getParameterMap();
     }
     @Override
     public String getParameter(String name) {
         Map<String, String[]> parameterMap = getParameterMap();
         String[] values = parameterMap.get(name);
         if (values == null) {
             return null;
         }
         return values[0]; // 取回参数的第一个值
     }
     @Override
     public String[] getParameterValues(String name) {
         Map<String, String[]> parameterMap = getParameterMap();
         String[] values = parameterMap.get(name);
         return values;
     }
 }

增强Response对象，对响应数据进行压缩
 先说一下在Tomcat服务器内，提供对响应压缩 配置实现 
 在conf/server.xml 中 
 <Connector port="80" protocol="HTTP/1.1" 
               connectionTimeout="20000" 
               redirectPort="8443"/> 添加 compressableMimeType="text/html,text/xml,text/plain" compression="on"

 public class GzipFilter implements Filter {
     @Override
     public void destroy() {
     }
     @Override
     public void doFilter(ServletRequest request, ServletResponse response,
             FilterChain chain) throws IOException, ServletException {
         // 自定义缓冲区，重写response的getWriter和getOutputStream
         HttpServletResponse httpServletResponse = (HttpServletResponse) response;
         // 字节缓存区
         // 将数据写入内存数组中
         final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
         HttpServletResponse myresponse = new HttpServletResponseWrapper(
                 httpServletResponse) {
             private PrintWriter out;
             @Override
             // 重写getWriter 流获得是对 getOutputStream 编码获得
             public PrintWriter getWriter() throws IOException {
                 System.out.println("getWriter...");
                 if (out == null) {
                     // 确保PrintWriter只有一个对象，flushbuffer中输出缓冲区内容
                     out = new PrintWriter(new OutputStreamWriter(
                             byteArrayOutputStream, getCharacterEncoding()));
                 }
                 return out;
             }
             @Override
             public ServletOutputStream getOutputStream() throws IOException {
                 System.out.println("getOutputStream...");
                 return new ServletOutputStream() {
                     @Override
                     // 将数据写到哪
                     public void write(int b) throws IOException {
                         // 将响应数据 写入自定义缓存区
                         byteArrayOutputStream.write(b);
                     }
                 };
             }
             @Override
             public void flushBuffer() throws IOException {
                 getOutputStream().flush();
                 getWriter().flush();
             }
         };
         // 目标资源执行，只有目标资源执行后，才有响应数据
         chain.doFilter(request, myresponse);
         myresponse.flushBuffer();
         // 目标资源已经执行过，数据已经在 byteArrayOutputStream 缓存区
         byte[] data = byteArrayOutputStream.toByteArray(); // data是未压缩数据
         System.out.println("未压缩数据长度：" + data.length);
         // 读data数据进行压缩
         byte[] gzipData = gzip(data);// gzipData是压缩后数据
         System.out.println("压缩后数据长度：" + gzipData.length);
         // 原来response 目的地是客户端浏览器
         httpServletResponse.setHeader("Content-Encoding", "gzip");
         httpServletResponse.setContentLength(gzipData.length);
         httpServletResponse.getOutputStream().write(gzipData);
         httpServletResponse.getOutputStream().flush();
     }
     // 对data数据进行gzip压缩
     public byte[] gzip(byte[] data) {
         // 定义字节缓存区，用gzip方式向缓存区写数据
         ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
         try {
             GZIPOutputStream gzipOutputStream = new GZIPOutputStream(
                     arrayOutputStream);
             gzipOutputStream.write(data);// 将原数据 压缩gzip格式写入新的缓存区\
             gzipOutputStream.close();
             arrayOutputStream.flush();
             return arrayOutputStream.toByteArray();// 返回压缩后的内容
         } catch (IOException e) {
             e.printStackTrace();
             throw new RuntimeException("压缩失败！");
         }
     }
     @Override
     public void init(FilterConfig filterConfig) throws ServletException {
     }
 }

天下代码一般仿写:http://blog.csdn.net/javadaddy/article/details/8142559