1      <filter>
2             <filter-name>EncodingFilter</filter-name>
3             <filter-class>com.cqy.filter.EncodingFilter</filter-class>
4       </filter>
5
6       <filter-mapping>
7             <filter-name>EncodingFilter</filter-name>
8             <url-pattern>/*</url-pattern>
9       </filter-mapping>

 1 package com.cqy.filter;
 2
 3 import java.io.IOException;
 4
 5 import javax.servlet.Filter;
 6 import javax.servlet.FilterChain;
 7 import javax.servlet.FilterConfig;
 8 import javax.servlet.ServletException;
 9 import javax.servlet.ServletRequest;
10 import javax.servlet.ServletResponse;
11 import javax.servlet.http.HttpServletRequest;
12 import javax.servlet.http.HttpServletResponse;
13
14 import com.cqy.domain.MyRequest;
15
16 public class EncodingFilter implements Filter {
17
18       @Override
19       public void destroy() {
20
21       }
22
23       @Override
24       public void doFilter(ServletRequest req, ServletResponse res,
25                   FilterChain chain) throws IOException, ServletException {
26             // 将请求和响应强制转换成Http形式
27             HttpServletRequest request = (HttpServletRequest) req;
28             HttpServletResponse response = (HttpServletResponse) res;
29
30             // 处理响应乱码
31             response.setContentType("text/html;charset=utf-8");
32
33             // 自定义一个request对象：MyRequest，对服务器原来的requset进行增强，使用装饰设计模式
34             // 要增强原来的request对象，必须先获取到原来的request对象
35             MyRequest myRequest = new MyRequest(request);
36
37             // 注意：放行的时候应该传入增强后的request对象
38             chain.doFilter(myRequest, response);
39       }
40
41       @Override
42       public void init(FilterConfig arg0) throws ServletException {
43
44       }
45
46 }

  1 package com.domain;
  2
  3 import java.io.UnsupportedEncodingException;
  4 import java.util.Map;
  5 import java.util.Set;
  6
  7 import javax.servlet.http.HttpServletRequest;
  8 import javax.servlet.http.HttpServletRequestWrapper;
  9
 10 /**
 11  * @author  继承HttpServletRequestWrapper相当于实现了HttpServletRequest
 12  *         HttpServletRequestWrapper类，它本身实现了所有HttpServletRequest的方法
 13  *         继承它之后，需要修改的方法MyRequest可以自己定义，不需要修改的方法，直接使用父类的方法
 14  *
 15  *         第一步：总结：继承HttpServletRequestWrapper，为了偷懒，
 16  *         不用自己去实现所有HttpServletRequest的方法 第二步：使用构造函数将原来的request对象保存到当前自定义对象中
 17  *         第三步：针对要修改的方法，进行增强 第四步：定义一个flag标记，防止编码重复执行
 18  */
 19 public class MyRequest extends HttpServletRequestWrapper {
 20
 21     // 定义了一个成员变量，用来保存构造函数传入的requset对象
 22     private HttpServletRequest request = null;
 23
 24     // 定义一个标记，用来标注：当前requset中，请求参数，是否已经编码过了
 25     private boolean flag = false;
 26
 27     public MyRequest(HttpServletRequest request) {
 28         super(request);
 29         this.request = request;
 30
 31     }
 32
 33     // 总需求：对request对象的获取数据的方法，进行增强（统一编码）
 34
 35     @Override
 36     public Map<String, String[]> getParameterMap() {
 37         // 获得请求方式request.getMethod()方法
 38         String method = this.request.getMethod();
 39         // post请求
 40         if ("post".equalsIgnoreCase(method)) {
 41             // 设置编码格式
 42             try {
 43                 request.setCharacterEncoding("utf-8");
 44             } catch (UnsupportedEncodingException e) {
 45                 e.printStackTrace();
 46             }
 47             Map<String, String[]> map = this.request.getParameterMap();
 48             return map;
 49
 50         } else if ("get".equalsIgnoreCase(method)) {
 51             // get请求
 52             // 分析：get请求需要对每一个参数都进行转换，因此需要对map中的每个元素进行遍历
 53             // 首先获得map集合
 54             Map<String, String[]> map = this.request.getParameterMap();
 55
 56             //第一次获取请求参数，flag==false，执行后面的额乱码处理动作
 57             //第二次获取请求参数的时候，flag==true，不执行后面的处理，直接返回已经编码过的map集合
 58             if (flag) {
 59                 return map;
 60             }
 61             if (map == null) {
 62                 return super.getParameterMap();
 63             } else {
 64                 // 然后获得map集合的key
 65                 Set<String> key = map.keySet();
 66                 // 通过key将map中的元素取出来
 67                 for (String string : key) {
 68                     String[] value = map.get(string);
 69                     // 接下来需要将String中的每一个都进行遍历，转换参数
 70                     for (int i = 0; i < value.length; i++) {
 71                         try {
 72                             String string2 = new String(
 73                                     value[i].getBytes("iso-8859-1"), "utf-8");
 74                             value[i] = string2;
 75                         } catch (UnsupportedEncodingException e) {
 76                             e.printStackTrace();
 77                         }
 78                     }
 79                 }
 80                 flag = true;
 81                 return map;
 82             }
 83         } else {
 84             //位置请求方式，自定义对象处理不了，使用父类的方法处理
 85             return super.getParameterMap();
 86         }
 87     }
 88
 89     @Override
 90     public String[] getParameterValues(String name) {
 91         // 通过map集合获取参数
 92         Map<String, String[]> map = this.getParameterMap();
 93         if (map == null) {
 94             return super.getParameterValues(name);
 95         } else {
 96             String[] strings = map.get(name);
 97             return strings;
 98         }
 99     }
100
101     @Override
102     public String getParameter(String name) {
103         // 通过values获取参数
104         String[] values = this.getParameterValues(name);
105         if (values == null) {
106             return super.getParameter(name);
107         } else {
108             return values[0];
109         }
110     }
111
112 }