使用过滤器（Filter）解决请求参数中文乱码问题（复杂方式）

前述：

     在写这篇笔记之前，对笔记中的设计模式进行介绍：

     本篇笔记中将要使用到的设计模式是：装饰（包装）设计模式

          （1）装饰（包装）设计模式口诀：

               ①定义一个类，实现被装饰对象的接口

               ②定义一个成员变量，记住被装饰对象的引用

               ③定义构造方法，传入被装饰对象的实例

               ④改写要修改的方法

               ⑤不需要改写的方法，调用被装饰对象的原来的方法

 

          （2）什么时候使用装饰设计模式

               当我们需要对一个类进行增强的时候，增强后的类不再当前类的范畴

                    例如：现在有一个     Animal类     Cat和Dog都属于动物类型，因此可以直接继承

                                                                      现在新来一个“电子狗 ”，不属于动物的范围，但是有需要用其中的方法，这时候我们选择使用装饰（包装）设计模式

 

一：需求：统一解决请求参数中文乱码

  

二：需求原因：

     在没有该需求之前，解决请求乱码问题：

          （1）POST：

 

//第一种
//request.setCharacterEncoding(this.getServletContext().getInitParameter("charset"));
//备注：这种获取方式是因为在web.xml中进行了如下配置
     <!-- 设置编码 -->
      <context-param>
            <param-name>charset</param-name>
            <param-value>UTF-8</param-value>
      </context-param>
 
//第二种
request.setCharacterEncoding("utf-8");

     分析：第一种方式的好处是，在context中配置后，项目后期如果需要修改获取方式，直接修改配置文件即可，不要对.java文件进行修改

 

         （2）GET：

 

     String value = request.getParameter("value");
     if(value == null || value.trim().equals("")){
         value="";
     }
     value = new String(value.getBytes("ISO-8859-1"),"utf-8");

     

三、优化思路：

     使用一个过滤器，在请求到达servlet之前，先对request对象设置编码

     要求所有的请求都要进行设置编码，因此所有的request都要拦截，进行增强，那么：

 

     <filter>
            <filter-name>EncodingFilter</filter-name>
            <filter-class>com.cqy.filter.EncodingFilter</filter-class>
      </filter>
 
      <filter-mapping>
            <filter-name>EncodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
      </filter-mapping>

 

四：代码实现：

     1、过滤器代码

 

package com.cqy.filter;
 
import java.io.IOException;
 
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import com.cqy.domain.MyRequest;
 
public class EncodingFilter implements Filter {
 
      @Override
      public void destroy() {
 
      }
 
      @Override
      public void doFilter(ServletRequest req, ServletResponse res,
                  FilterChain chain) throws IOException, ServletException {
            // 将请求和响应强制转换成Http形式
            HttpServletRequest request = (HttpServletRequest) req;
            HttpServletResponse response = (HttpServletResponse) res;
 
            // 处理响应乱码
            response.setContentType("text/html;charset=utf-8");
 
            // 自定义一个request对象：MyRequest，对服务器原来的requset进行增强，使用装饰设计模式
            // 要增强原来的request对象，必须先获取到原来的request对象
            MyRequest myRequest = new MyRequest(request);
 
            // 注意：放行的时候应该传入增强后的request对象
            chain.doFilter(myRequest, response);
      }
 
      @Override
      public void init(FilterConfig arg0) throws ServletException {
 
      }
 
}

 

     2、自定义增强类（MyRequest ）

 

package com.domain;
 
import java.io.UnsupportedEncodingException;
import java.util.Map;
import java.util.Set;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
 
/**
 * @author  继承HttpServletRequestWrapper相当于实现了HttpServletRequest
 *         HttpServletRequestWrapper类，它本身实现了所有HttpServletRequest的方法
 *         继承它之后，需要修改的方法MyRequest可以自己定义，不需要修改的方法，直接使用父类的方法
 *
 *         第一步：总结：继承HttpServletRequestWrapper，为了偷懒，
 *         不用自己去实现所有HttpServletRequest的方法 第二步：使用构造函数将原来的request对象保存到当前自定义对象中
 *         第三步：针对要修改的方法，进行增强 第四步：定义一个flag标记，防止编码重复执行
 */
public class MyRequest extends HttpServletRequestWrapper {
 
    // 定义了一个成员变量，用来保存构造函数传入的requset对象
    private HttpServletRequest request = null;
 
    // 定义一个标记，用来标注：当前requset中，请求参数，是否已经编码过了
    private boolean flag = false;
 
    public MyRequest(HttpServletRequest request) {
        super(request);
        this.request = request;
 
    }
 
    // 总需求：对request对象的获取数据的方法，进行增强（统一编码）
 
    @Override
    public Map<String, String[]> getParameterMap() {
        // 获得请求方式request.getMethod()方法
        String method = this.request.getMethod();
        // post请求
        if ("post".equalsIgnoreCase(method)) {
            // 设置编码格式
            try {
                request.setCharacterEncoding("utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            Map<String, String[]> map = this.request.getParameterMap();
            return map;
 
        } else if ("get".equalsIgnoreCase(method)) {
            // get请求
            // 分析：get请求需要对每一个参数都进行转换，因此需要对map中的每个元素进行遍历
            // 首先获得map集合
            Map<String, String[]> map = this.request.getParameterMap();
 
            //第一次获取请求参数，flag==false，执行后面的额乱码处理动作
            //第二次获取请求参数的时候，flag==true，不执行后面的处理，直接返回已经编码过的map集合
            if (flag) {
                return map;
            }
            if (map == null) {
                return super.getParameterMap();
            } else {
                // 然后获得map集合的key
                Set<String> key = map.keySet();
                // 通过key将map中的元素取出来
                for (String string : key) {
                    String[] value = map.get(string);
                    // 接下来需要将String中的每一个都进行遍历，转换参数
                    for (int i = 0; i < value.length; i++) {
                        try {
                            String string2 = new String(
                                    value[i].getBytes("iso-8859-1"), "utf-8");
                            value[i] = string2;
                        } catch (UnsupportedEncodingException e) {
                            e.printStackTrace();
                        }
                    }
                }
                flag = true;
                return map;
            }
        } else {
            //位置请求方式，自定义对象处理不了，使用父类的方法处理
            return super.getParameterMap();
        }
    }
 
    @Override
    public String[] getParameterValues(String name) {
        // 通过map集合获取参数
        Map<String, String[]> map = this.getParameterMap();
        if (map == null) {
            return super.getParameterValues(name);
        } else {
            String[] strings = map.get(name);
            return strings;
        }
    }
 
    @Override
    public String getParameter(String name) {
        // 通过values获取参数
        String[] values = this.getParameterValues(name);
        if (values == null) {
            return super.getParameter(name);
        } else {
            return values[0];
        }
    }
 
}