前述：
在写这篇笔记之前，对笔记中的设计模式进行介绍：
本篇笔记中将要使用到的设计模式是：装饰（包装）设计模式
（1）装饰（包装）设计模式口诀：
①定义一个类，实现被装饰对象的接口
②定义一个成员变量，记住被装饰对象的引用
③定义构造方法，传入被装饰对象的实例
④改写要修改的方法
⑤不需要改写的方法，调用被装饰对象的原来的方法
（2）什么时候使用装饰设计模式
当我们需要对一个类进行增强的时候，增强后的类不再当前类的范畴
例如：现在有一个 Animal类 Cat和Dog都属于动物类型，因此可以直接继承
现在新来一个“电子狗 ”，不属于动物的范围，但是有需要用其中的方法，这时候我们选择使用装饰（包装）设计模式
一：需求：统一解决请求参数中文乱码
二：需求原因：
在没有该需求之前，解决请求乱码问题：
（1）POST：
1 //第一种
2 //request.setCharacterEncoding(this.getServletContext().getInitParameter("charset"));
3 //备注：这种获取方式是因为在web.xml中进行了如下配置
4 <!-- 设置编码 -->
5 <context-param>
6 <param-name>charset</param-name>
7 <param-value>UTF-8</param-value>
8 </context-param>
9
10 //第二种
11 request.setCharacterEncoding("utf-8");
分析：第一种方式的好处是，在context中配置后，项目后期如果需要修改获取方式，直接修改配置文件即可，不要对.java文件进行修改
（2）GET：
1 String value = request.getParameter("value");
2 if(value == null || value.trim().equals("")){
3 value="";
4 }
5 value = new String(value.getBytes("ISO-8859-1"),"utf-8");
三、优化思路：
使用一个过滤器，在请求到达servlet之前，先对request对象设置编码
要求所有的请求都要进行设置编码，因此所有的request都要拦截，进行增强，那么：
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、过滤器代码
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 }
2、自定义增强类（MyRequest ）
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 }