Java 装饰模式的应用

你的名字 2022-06-13 00:53 80阅读 0赞

Java Web在filter中可以得到代表用户请求和响应的request、response对象，因此在编程中可以使用Decorator(装饰器)模式对request、response对象进行包装，再把包装对象传给目标资源，从而实现一些特殊需求。  
**一、Decorator设计模式  
1.1、Decorator设计模式介绍**  
　　当某个对象的方法不适应业务需求时，通常有2种方式可以对方法进行增强：  
    1、编写子类，覆盖需增强的方法。  
    2、使用Decorator设计模式对方法进行增强。  
　　在《JAVA与模式》一书中开头是这样描述装饰（Decorator）模式的：装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。  
　　那么在实际应用中遇到需增强对象的方法时，到底选用哪种方式比较好呢？这个没有具体的定式，只能是根据具体的需求来采用具体的方式，不过有一种情况下，必须使用Decorator设计模式：即被增强的对象，开发人员只能得到它的对象，无法得到它的class文件。比如request、response对象，开发人员之所以在servlet中能通过sun公司定义的HttpServletRequest\\response接口去操作这些对象，是因为Tomcat服务器厂商编写了request、response接口的实现类。web服务器在调用servlet时，会用这些接口的实现类创建出对象，然后传递给servlet程序。此种情况下，由于开发人员根本不知道服务器厂商编写的request、response接口的实现类是哪个？在程序中只能拿到服务器厂商提供的对象，因此就只能采用Decorator设计模式对这些对象进行增强。  
**1.2、Decorator设计模式的实现**  
　　1.首先看需要被增强对象继承了什么接口或父类，编写一个类也去继承这些接口或父类。  
　　2.在类中定义一个变量，变量类型即需增强对象的类型。  
　　3.在类中定义一个构造函数，接收需增强的对象。  
　　4.覆盖需增强的方法，编写增强的代码。  
**二、使用Decorator设计模式增强request对象**  
　　Servlet API 中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper，HttpServletRequestWrapper 类实现了request 接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 request 对象的对应方法，以避免用户在对request对象进行增强时需要实现request接口中的所有方法。  
**2.1、使用Decorator模式包装request对象解决get和post请求方式下的中文乱码问题**  
编写一个用于处理中文乱码的过滤器CharacterEncodingFilter，代码如下：  
  1 package me.gacl.web.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.HttpServletRequestWrapper;  
13 import javax.servlet.http.HttpServletResponse;  
14  
15 /\*\*  
16 \* @ClassName: CharacterEncodingFilter  
17 \* @Description: 此过滤器用来解决解决get、post请求方式下的中文乱码问题  
18 \* @author: 芭蕉扇  
19 \* @date: 2017-03-20  
20 \*  
21 \*/  
22 public class CharacterEncodingFilter implements Filter \{  
23  
24     private FilterConfig filterConfig = null;  
25     //设置默认的字符编码  
26     private String defaultCharset = "UTF-8";  
27  
28     public void doFilter(ServletRequest req, ServletResponse resp,  
29             FilterChain chain) throws IOException, ServletException \{  
30          
31         HttpServletRequest request = (HttpServletRequest) req;  
32         HttpServletResponse response = (HttpServletResponse) resp;  
33         //得到在web.xml中配置的字符编码  
34         String charset = filterConfig.getInitParameter("charset");  
35         if(charset==null)\{  
36             charset = defaultCharset;  
37         \}  
38         request.setCharacterEncoding(charset);  
39         response.setCharacterEncoding(charset);  
40         response.setContentType("text/html;charset="+charset);  
41          
42         MyCharacterEncodingRequest requestWrapper = new MyCharacterEncodingRequest(request);  
43         chain.doFilter(requestWrapper, response);  
44     \}  
45  
46     public void init(FilterConfig filterConfig) throws ServletException \{  
47         //得到过滤器的初始化配置信息  
48         this.filterConfig = filterConfig;  
49     \}  
50      
51     public void destroy() \{  
52  
53     \}  
54 \}  
55  
56 /\*\*  
57 \* @ClassName: MyCharacterEncodingRequest  
58 \* @Description: Servlet API中提供了一个request对象的Decorator设计模式的默认实现类HttpServletRequestWrapper,  
59 \* (HttpServletRequestWrapper类实现了request接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 request对象的对应方法)  
60 \* 以避免用户在对request对象进行增强时需要实现request接口中的所有方法。  
61 \* 所以当需要增强request对象时，只需要写一个类继承HttpServletRequestWrapper类，然后在重写需要增强的方法即可  
62 \* @author: 芭蕉扇  
63 \* @date: 2014-9-2 下午10:42:57  
64 \*     1.实现与被增强对象相同的接口  
65     2、定义一个变量记住被增强对象  
66     3、定义一个构造函数，接收被增强对象  
67     4、覆盖需要增强的方法  
68     5、对于不想增强的方法，直接调用被增强对象（目标对象）的方法  
69 \*/  
70 class MyCharacterEncodingRequest extends HttpServletRequestWrapper\{  
71     //定义一个变量记住被增强对象(request对象是需要被增强的对象)  
72     private HttpServletRequest request;  
73     //定义一个构造函数，接收被增强对象  
74     public MyCharacterEncodingRequest(HttpServletRequest request) \{  
75         super(request);  
76         this.request = request;  
77     \}  
78     /\* 覆盖需要增强的getParameter方法  
79      \* @see javax.servlet.ServletRequestWrapper\#getParameter(java.lang.String)  
80      \*/  
81     @Override  
82     public String getParameter(String name) \{  
83         try\{  
84             //获取参数的值  
85             String value= this.request.getParameter(name);  
86             if(value==null)\{  
87                 return null;  
88             \}  
89             //如果不是以get方式提交数据的，就直接返回获取到的值  
90             if(!this.request.getMethod().equalsIgnoreCase("get")) \{  
91                 return value;  
92             \}else\{  
93                 //如果是以get方式提交数据的，就对获取到的值进行转码处理  
94                 value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());  
95                 return value;  
96             \}  
97         \}catch (Exception e) \{  
98             throw new RuntimeException(e);  
99         \}  
100     \}  
101 \}  
  
　　在web.xml文件中配置CharacterEncodingFilter  
  
1   
2   <filter>  
3       <filter-name>CharacterEncodingFilter</filter-name>  
4       <filter-class>me.gacl.web.filter.CharacterEncodingFilter</filter-class>  
5   </filter>  
6    
7   <filter-mapping>  
8       <filter-name>CharacterEncodingFilter</filter-name>  
9       <url-pattern>/\*</url-pattern>  
10   </filter-mapping>  
  
　　编写jsp测试页面，如下：  
  
1 <%@ page language="java" pageEncoding="UTF-8"%>  
2 <%--引入jstl标签库 --%>  
3 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>  
4 <!DOCTYPE HTML>  
5 <html>  
6   <head>  
7     <title>使用字符过滤器解决解决get、post请求方式下的中文乱码问题</title>  
8   </head>  
9    
10   <body>  
11        <%--使用c:url标签构建url，构建好的url存储在servletDemo1变量中--%>  
12        <c:url value="/servlet/ServletDemo1" scope="page" var="servletDemo1">  
13            <%--构建的url的附带的中文参数 ，参数名是：username，值是：孤傲苍狼--%>  
14            <c:param name="username" value="孤傲苍狼"></c:param>  
15        </c:url>  
16       <%--使用get的方式访问 --%>  
17        <a href="$\{servletDemo1\}">超链接(get方式请求)</a>  
18        <hr/>  
19        <%--使用post方式提交表单 --%>  
20        <form action="$\{pageContext.request.contextPath\}/servlet/ServletDemo1" method="post">  
21            用户名：<input type="text" name="username" value="孤傲苍狼" />  
22            <input type="submit" value="post方式提交">  
23        </form>  
24         
25   </body>  
26 </html>  
  
　　编写处理用户请求的ServletDemo1  
  
1 package me.gacl.web.controller;  
2  
3 import java.io.IOException;  
4 import java.io.PrintWriter;  
5  
6 import javax.servlet.ServletException;  
7 import javax.servlet.http.HttpServlet;  
8 import javax.servlet.http.HttpServletRequest;  
9 import javax.servlet.http.HttpServletResponse;  
10  
11 public class ServletDemo1 extends HttpServlet \{  
12  
13     public void doGet(HttpServletRequest request, HttpServletResponse response)  
14             throws ServletException, IOException \{  
15         //接收参数  
16         String username = request.getParameter("username");  
17         //获取请求方式  
18         String method = request.getMethod();  
19         //获取输出流  
20         PrintWriter out = response.getWriter();  
21         out.write("请求的方式："+method);  
22         out.write("<br/>");  
23         out.write("接收到的参数："+username);  
24     \}  
25  
26     public void doPost(HttpServletRequest request, HttpServletResponse response)  
27             throws ServletException, IOException \{  
28         doGet(request, response);  
29     \}  
30  
31 \}  
  
　　测试结果如下：  
　　  
　　从运行结果中可以看到，无论是get请求方式还是post请求方式，中文乱码问题都可以完美解决了。  
**2.2、使用Decorator模式包装request对象实现html标签转义功能**  
  
　　编写一个html转义过滤器，代码如下：  
  
  1 package me.gacl.web.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.HttpServletRequestWrapper;  
13 import javax.servlet.http.HttpServletResponse;  
14  
15 /\*\*  
16 \* @ClassName: HtmlFilter  
17 \* @Description: html转义过滤器  
18 \* @author: 芭蕉扇  
19 \* @date: 2017-03-20  
20 \*  
21 \*/  
22 public class HtmlFilter implements Filter \{  
23  
24     public void doFilter(ServletRequest req, ServletResponse resp,  
25             FilterChain chain) throws IOException, ServletException \{  
26          
27         HttpServletRequest request = (HttpServletRequest) req;  
28         HttpServletResponse response = (HttpServletResponse) resp;  
29  
30         MyHtmlRequest myrequest = new MyHtmlRequest(request);  
31         chain.doFilter(myrequest, response);  
32          
33     \}  
34  
35      
36     public void destroy() \{  
37          
38     \}  
39  
40      
41     public void init(FilterConfig filterConfig) throws ServletException \{  
42          
43     \}  
44 \}  
45  
46 /\*\*  
47 \* @ClassName: MyHtmlRequest  
48 \* @Description: 使用Decorator模式包装request对象，实现html标签转义功能  
49 \* @author: 芭蕉扇  
50 \* @date: 2017-03-20  
51 \*  
52 \*/  
53 class MyHtmlRequest extends HttpServletRequestWrapper \{  
54  
55     private HttpServletRequest request;  
56  
57     public MyHtmlRequest(HttpServletRequest request) \{  
58         super(request);  
59         this.request = request;  
60     \}  
61  
62     /\* 覆盖需要增强的getParameter方法  
63      \* @see javax.servlet.ServletRequestWrapper\#getParameter(java.lang.String)  
64      \*/  
65     @Override  
66     public String getParameter(String name) \{  
67         String value = this.request.getParameter(name);  
68         if (value == null) \{  
69             return null;  
70         \}  
71         //调用filter转义value中的html标签  
72         return filter(value);  
73     \}  
74  
75     /\*\*  
76     \* @Method: filter  
77     \* @Description: 过滤内容中的html标签  
78     \* @Anthor:芭蕉扇  
79     \* @param message  
80     \* @return  
81     \*/  
82     public String filter(String message) \{  
83         if (message == null)\{  
84             return null;  
85         \}  
86         char content\[\] = new char\[message.length()\];  
87         message.getChars(0, message.length(), content, 0);  
88         StringBuffer result = new StringBuffer(content.length + 50);  
89         for (int i = 0; i < content.length; i++) \{  
90             switch (content\[i\]) \{  
91             case '<':  
92                 result.append("<");  
93                 break;  
94             case '>':  
95                 result.append(">");  
96                 break;  
97             case '&':  
98                 result.append("&");  
99                 break;  
100             case '"':  
101                 result.append(""");  
102                 break;  
103             default:  
104                 result.append(content\[i\]);  
105             \}  
106         \}  
107         return result.toString();  
108     \}  
109 \}  
  
　　在web.xml文件中配置HtmlFilter  
  
1   
2   <filter>  
3       <filter-name>HtmlFilter</filter-name>  
4       <filter-class>me.gacl.web.filter.HtmlFilter</filter-class>  
5   </filter>  
6    
7   <filter-mapping>  
8       <filter-name>HtmlFilter</filter-name>  
9       <url-pattern>/\*</url-pattern>  
10   </filter-mapping>  
  
　　编写jsp测试页面，如下：  
  
1 <%@ page language="java" import="java.util.\*" pageEncoding="UTF-8"%>  
2 <!DOCTYPE HTML>  
3 <html>  
4   <head>  
5     <title>html过滤器测试</title>  
6   </head>  
7    
8   <body>  
9        <form action="$\{pageContext.request.contextPath\}/servlet/ServletDemo2" method="post">  
10            留言:  
11            <textarea rows="8" cols="70" name="message">  
12            <script type="text/javascript">  
13            while(true)\{  
14                alert("死循环了，我会不停地弹出了");  
15            \}  
16            </script>  
17         <a href="http://www.cnblogs.com">访问博客园</a>  
18            </textarea>  
19            <input type="submit" value="发表">  
20        </form>  
21   </body>  
22 </html>  
  
　　编写处理用户请求的ServletDemo2  
  
1 package me.gacl.web.controller;  
2  
3 import java.io.IOException;  
4  
5 import javax.servlet.ServletException;  
6 import javax.servlet.http.HttpServlet;  
7 import javax.servlet.http.HttpServletRequest;  
8 import javax.servlet.http.HttpServletResponse;  
9  
10 public class ServletDemo2 extends HttpServlet \{  
11  
12     public void doGet(HttpServletRequest request, HttpServletResponse response)  
13             throws ServletException, IOException \{  
14         //获取用户输入的内容  
15         String message = request.getParameter("message");  
16         response.getWriter().write("您上次的留言是：<br/>" + message);  
17     \}  
18  
19     public void doPost(HttpServletRequest request, HttpServletResponse response)  
20             throws ServletException, IOException \{  
21         doGet(request, response);  
22     \}  
23 \}  
  
测试结果如下：  
  
　　从运行结果中可以看到，所有的html标签都被转义输出了。  
**2.3、使用Decorator模式包装request对象实现敏感字符过滤功能**  
  
　　编写一个敏感字符过滤器，代码如下：  
  
  1 package me.gacl.web.filter;  
  2  
  3 import java.io.BufferedReader;  
  4 import java.io.IOException;  
  5 import java.io.InputStream;  
  6 import java.io.InputStreamReader;  
  7 import java.io.UnsupportedEncodingException;  
  8 import java.util.ArrayList;  
  9 import java.util.List;  
10 import javax.servlet.Filter;  
11 import javax.servlet.FilterChain;  
12 import javax.servlet.FilterConfig;  
13 import javax.servlet.ServletException;  
14 import javax.servlet.ServletRequest;  
15 import javax.servlet.ServletResponse;  
16 import javax.servlet.http.HttpServletRequest;  
17 import javax.servlet.http.HttpServletRequestWrapper;  
18 import javax.servlet.http.HttpServletResponse;  
19  
20 /\*\*  
21 \* @ClassName: DirtyFilter  
22 \* @Description: 敏感词过滤器  
23 \* @author: 芭蕉扇  
24 \* @date: 2017-03-20  
25 \*  
26 \*/  
27 public class DirtyFilter implements Filter \{  
28  
29     private FilterConfig config = null;  
30      
31     @Override  
32     public void init(FilterConfig filterConfig) throws ServletException \{  
33         this.config = filterConfig;  
34     \}  
35  
36     @Override  
37     public void doFilter(ServletRequest req, ServletResponse resp,  
38             FilterChain chain) throws IOException, ServletException \{  
39          
40         HttpServletRequest request = (HttpServletRequest) req;  
41         HttpServletResponse response = (HttpServletResponse) resp;  
42         DirtyRequest dirtyrequest = new DirtyRequest(request);  
43          
44         chain.doFilter(dirtyrequest, response);  
45     \}  
46  
47     @Override  
48     public void destroy() \{  
49  
50     \}  
51      
52     /\*\*  
53     \* @Method: getDirtyWords  
54     \* @Description: 获取敏感字符  
55     \* @Anthor:芭蕉扇  
56     \*  
57     \* @return  
58     \*/  
59     private List<String> getDirtyWords()\{  
60         List<String> dirtyWords = new ArrayList<String>();  
61         String dirtyWordPath = config.getInitParameter("dirtyWord");  
62         InputStream inputStream = config.getServletContext().getResourceAsStream(dirtyWordPath);  
63         InputStreamReader is = null;  
64         try \{  
65             is = new InputStreamReader(inputStream,"UTF-8");  
66         \} catch (UnsupportedEncodingException e2) \{  
67             e2.printStackTrace();  
68         \}  
69         BufferedReader reader = new BufferedReader(is);  
70         String line;  
71         try \{  
72             while ((line = reader.readLine())!= null) \{//如果 line为空说明读完了  
73                 dirtyWords.add(line);  
74             \}  
75         \} catch (IOException e) \{  
76             e.printStackTrace();  
77         \}  
78         return dirtyWords;  
79     \}  
80      
81     /\*\*  
82     \* @ClassName: DirtyRequest  
83     \* @Description: 使用Decorator模式包装request对象，实现敏感字符过滤功能  
84     \* @author: 芭蕉扇  
85     \* @date: 2017-03-20  
86     \*  
87     \*/  
88     class DirtyRequest extends HttpServletRequestWrapper\{  
89  
90         private List<String> dirtyWords = getDirtyWords();  
91         private HttpServletRequest request;  
92         public DirtyRequest(HttpServletRequest request) \{  
93             super(request);  
94             this.request = request;  
95         \}  
96         /\* 重写getParameter方法，实现对敏感字符的过滤  
97          \* @see javax.servlet.ServletRequestWrapper\#getParameter(java.lang.String)  
98          \*/  
99         @Override  
100         public String getParameter(String name) \{  
101              
102             String value = this.request.getParameter(name);  
103             if(value==null)\{  
104                 return null;  
105             \}  
106              
107             for(String dirtyWord : dirtyWords)\{  
108                 if(value.contains(dirtyWord))\{  
109                     System.out.println("内容中包含敏感词："+dirtyWord+"，将会被替换成\*\*\*\*");  
110                     //替换敏感字符  
111                     value = value.replace(dirtyWord, "\*\*\*\*");  
112                 \}  
113             \}  
114             return value;  
115         \}  
116     \}  
117 \}  
  
　　在web.xml文件中配置DirtyFilter  
  
1    
2   <filter>  
3       <filter-name>DirtyFilter</filter-name>  
4       <filter-class>me.gacl.web.filter.DirtyFilter</filter-class>  
5         
6       <init-param>  
7          <param-name>dirtyWord</param-name>     
8          <param-value>/WEB-INF/DirtyWord.txt</param-value>  
9     </init-param>  
10   </filter>  
11    
12   <filter-mapping>  
13       <filter-name>DirtyFilter</filter-name>  
14       <url-pattern>/\*</url-pattern>  
15   </filter-mapping>  
  
　　当用户填写的内容包含一些敏感字符时，在DirtyFilter过滤器中就会将这些敏感字符替换掉。  
  
　　我们如果将上述的CharacterEncodingFilter、HtmlFilter、DirtyFilter这三个过滤器联合起来使用，那么就相当于是把request对象包装了3次，request对象的getParameter方法经过3次重写，使得getParameter方法的功能大大增强，可以同时解决中文乱码，html标签转义，敏感字符过滤这些需求。  
  
　　在实际开发中完全可以将上述的三个过滤器合并成一个，让合并后的过滤器具有解决中文乱码，html标签转义，敏感字符过滤这些功能，例如：  
  
  1 package me.gacl.web.filter;  
  2  
  3 import java.io.BufferedReader;  
  4 import java.io.IOException;  
  5 import java.io.InputStream;  
  6 import java.io.InputStreamReader;  
  7 import java.io.UnsupportedEncodingException;  
  8 import java.util.ArrayList;  
  9 import java.util.List;  
10  
11 import javax.servlet.Filter;  
12 import javax.servlet.FilterChain;  
13 import javax.servlet.FilterConfig;  
14 import javax.servlet.ServletException;  
15 import javax.servlet.ServletRequest;  
16 import javax.servlet.ServletResponse;  
17 import javax.servlet.http.HttpServletRequest;  
18 import javax.servlet.http.HttpServletRequestWrapper;  
19 import javax.servlet.http.HttpServletResponse;  
20  
21 /\*\*  
22 \* @ClassName: AdvancedFilter  
23 \* @Description: 这个过滤器是用来解决中文乱码，转义内容中的html标签，过滤内容中的敏感字符的  
24 \* @author: 芭蕉扇  
25 \* @date: 2017-03-20  
26 \*  
27 \*/  
28 public class AdvancedFilter implements Filter \{  
29  
30     private FilterConfig filterConfig = null;  
31     //设置默认的字符编码  
32     private String defaultCharset = "UTF-8";  
33      
34     @Override  
35     public void init(FilterConfig filterConfig) throws ServletException \{  
36         //得到过滤器的初始化配置信息  
37         this.filterConfig = filterConfig;  
38     \}  
39  
40     @Override  
41     public void doFilter(ServletRequest req, ServletResponse resp,  
42             FilterChain chain) throws IOException, ServletException \{  
43         HttpServletRequest request = (HttpServletRequest) req;  
44         HttpServletResponse response = (HttpServletResponse) resp;  
45         //得到在web.xml中配置的字符编码  
46         String charset = filterConfig.getInitParameter("charset");  
47         if(charset==null)\{  
48             charset = defaultCharset;  
49         \}  
50         request.setCharacterEncoding(charset);  
51         response.setCharacterEncoding(charset);  
52         response.setContentType("text/html;charset="+charset);  
53          
54         AdvancedRequest requestWrapper = new AdvancedRequest(request);  
55         chain.doFilter(requestWrapper, response);  
56     \}  
57  
58     @Override  
59     public void destroy() \{  
60  
61     \}  
62  
63     class AdvancedRequest extends HttpServletRequestWrapper\{  
64          
65         private List<String> dirtyWords = getDirtyWords();  
66          
67         //定义一个变量记住被增强对象(request对象是需要被增强的对象)  
68         private HttpServletRequest request;  
69         //定义一个构造函数，接收被增强对象  
70         public AdvancedRequest(HttpServletRequest request) \{  
71             super(request);  
72             this.request = request;  
73         \}  
74         /\* 覆盖需要增强的getParameter方法  
75          \* @see javax.servlet.ServletRequestWrapper\#getParameter(java.lang.String)  
76          \*/  
77         @Override  
78         public String getParameter(String name) \{  
79             try\{  
80                 //获取参数的值  
81                 String value= this.request.getParameter(name);  
82                 if(value==null)\{  
83                     return null;  
84                 \}  
85                 //如果不是以get方式提交数据的，就直接返回获取到的值  
86                 if(!this.request.getMethod().equalsIgnoreCase("get")) \{  
87                     //调用filter转义value中的html标签  
88                     value= filter(value);  
89                 \}else\{  
90                     //如果是以get方式提交数据的，就对获取到的值进行转码处理  
91                     value = new String(value.getBytes("ISO8859-1"),this.request.getCharacterEncoding());  
92                     //调用filter转义value中的html标签  
93                     value= filter(value);  
94                 \}  
95                  
96                 for(String dirtyWord : dirtyWords)\{  
97                     if(value.contains(dirtyWord))\{  
98                         System.out.println("内容中包含敏感词："+dirtyWord+"，将会被替换成\*\*\*\*");  
99                         //替换敏感字符  
100                         value = value.replace(dirtyWord, "\*\*\*\*");  
101                     \}  
102                 \}  
103                 return value;  
104             \}catch (Exception e) \{  
105                 throw new RuntimeException(e);  
106             \}  
107         \}  
108     \}  
109  
110     /\*\*  
111     \* @Method: filter  
112     \* @Description: 过滤内容中的html标签  
113     \* @Anthor:芭蕉扇  
114     \* @param value  
115     \* @return  
116     \*/  
117     public String filter(String value) \{  
118         if (value == null)\{  
119             return null;  
120         \}  
121         char content\[\] = new char\[value.length()\];  
122         value.getChars(0, value.length(), content, 0);  
123         StringBuffer result = new StringBuffer(content.length + 50);  
124         for (int i = 0; i < content.length; i++) \{  
125             switch (content\[i\]) \{  
126             case '<':  
127                 result.append("<");  
128                 break;  
129             case '>':  
130                 result.append(">");  
131                 break;  
132             case '&':  
133                 result.append("&");  
134                 break;  
135             case '"':  
136                 result.append(""");  
137                 break;  
138             default:  
139                 result.append(content\[i\]);  
140             \}  
141         \}  
142         return (result.toString());  
143     \}  
144      
145     /\*\*  
146     \* @Method: getDirtyWords  
147     \* @Description: 获取敏感字符  
148     \* @Anthor:芭蕉扇  
149     \*  
150     \* @return  
151     \*/  
152     private List<String> getDirtyWords()\{  
153         List<String> dirtyWords = new ArrayList<String>();  
154         String dirtyWordPath = filterConfig.getInitParameter("dirtyWord");  
155         InputStream inputStream = filterConfig.getServletContext().getResourceAsStream(dirtyWordPath);  
156         InputStreamReader is = null;  
157         try \{  
158             is = new InputStreamReader(inputStream,defaultCharset);  
159         \} catch (UnsupportedEncodingException e2) \{  
160             e2.printStackTrace();  
161         \}  
162         BufferedReader reader = new BufferedReader(is);  
163         String line;  
164         try \{  
165             while ((line = reader.readLine())!= null) \{//如果 line为空说明读完了  
166                 dirtyWords.add(line);  
167             \}  
168         \} catch (IOException e) \{  
169             e.printStackTrace();  
170         \}  
171         return dirtyWords;  
172     \}  
173 \}  
  
　　在web.xml文件中配置AdvancedFilter  
  
1   <filter>  
2       <filter-name>AdvancedFilter</filter-name>  
3       <filter-class>me.gacl.web.filter.AdvancedFilter</filter-class>  
4       <init-param>  
5          <param-name>charset</param-name>     
6          <param-value>UTF-8</param-value>  
7     </init-param>  
8       <init-param>  
9          <param-name>dirtyWord</param-name>     
10          <param-value>/WEB-INF/DirtyWord.txt</param-value>  
11     </init-param>  
12   </filter>  
13    
14   <filter-mapping>  
15       <filter-name>AdvancedFilter</filter-name>  
16       <url-pattern>/\*</url-pattern>  
17   </filter-mapping>  
  
　　AdvancedFilter过滤器同时具有解决中文乱码，转义内容中的html标签，过滤内容中的敏感字符这些功能。  
**三、使用Decorator设计模式增强response对象**  
  
　　Servlet  API 中提供了response对象的Decorator设计模式的默认实现类HttpServletResponseWrapper ，HttpServletResponseWrapper类实现了response接口中的所有方法，但这些方法的内部实现都是仅仅调用了一下所包装的的 response对象的对应方法，以避免用户在对response对象进行增强时需要实现response接口中的所有方法。  
**3.1、response增强案例——压缩响应正文内容**  
  
　　应用HttpServletResponseWrapper对象，压缩响应正文内容。  
  
　　具体思路:通过filter向目标页面传递一个自定义的response对象。在自定义的response对象中，重写getOutputStream方法和getWriter方法，使目标资源调用此方法输出页面内容时，获得的是我们自定义的ServletOutputStream对象。在我们自定义的ServletOuputStream对象中，重写write方法，使写出的数据写出到一个buffer中。当页面完成输出后，在filter中就可得到页面写出的数据，从而我们可以调用GzipOuputStream对数据进行压缩后再写出给浏览器，以此完成响应正文件压缩功能。  
  
　　编写压缩过滤器，代码如下：  
  
  1 package me.gacl.web.filter;  
  2  
  3 import java.io.ByteArrayOutputStream;  
  4 import java.io.IOException;  
  5 import java.io.OutputStreamWriter;  
  6 import java.io.PrintWriter;  
  7 import java.util.zip.GZIPOutputStream;  
  8  
  9 import javax.servlet.Filter;  
10 import javax.servlet.FilterChain;  
11 import javax.servlet.FilterConfig;  
12 import javax.servlet.ServletException;  
13 import javax.servlet.ServletOutputStream;  
14 import javax.servlet.ServletRequest;  
15 import javax.servlet.ServletResponse;  
16 import javax.servlet.http.HttpServletRequest;  
17 import javax.servlet.http.HttpServletResponse;  
18 import javax.servlet.http.HttpServletResponseWrapper;  
19  
20 /\*\*  
21 \* @ClassName: GzipFilter  
22 \* @Description: 压缩过滤器，将web应用中的文本都经过压缩后再输出到浏览器  
23 \* @author: 芭蕉扇  
24 \* @date: 2017-03-20  
25 \*  
26 \*/  
27 public class GzipFilter implements Filter \{  
28  
29     public void doFilter(ServletRequest req, ServletResponse resp,  
30             FilterChain chain) throws IOException, ServletException \{  
31          
32         HttpServletRequest request = (HttpServletRequest) req;  
33         HttpServletResponse response = (HttpServletResponse) resp;  
34          
35         BufferResponse myresponse = new BufferResponse(response);  
36         chain.doFilter(request, myresponse);  
37         //拿出缓存中的数据，压缩后再打给浏览器  
38         byte out\[\] = myresponse.getBuffer();  
39         System.out.println("原始大小:" + out.length);  
40          
41         ByteArrayOutputStream bout = new ByteArrayOutputStream();  
42         //压缩输出流中的数据  
43         GZIPOutputStream gout = new GZIPOutputStream(bout);  
44         gout.write(out);  
45         gout.close();  
46          
47         byte gzip\[\] = bout.toByteArray();  
48         System.out.println("压缩后的大小:" + gzip.length);  
49          
50         response.setHeader("content-encoding", "gzip");  
51         response.setContentLength(gzip.length);  
52         response.getOutputStream().write(gzip);  
53     \}  
54      
55     public void destroy() \{  
56          
57     \}  
58  
59     public void init(FilterConfig filterConfig) throws ServletException \{  
60          
61     \}  
62 \}  
63  
64 class BufferResponse extends HttpServletResponseWrapper\{  
65  
66     private ByteArrayOutputStream bout = new ByteArrayOutputStream();  
67     private PrintWriter pw;  
68     private HttpServletResponse response;  
69     public BufferResponse(HttpServletResponse response) \{  
70         super(response);  
71         this.response = response;  
72     \}  
73     @Override  
74     public ServletOutputStream getOutputStream() throws IOException \{  
75         return new MyServletOutputStream(bout);  
76     \}  
77     @Override  
78     public PrintWriter getWriter() throws IOException \{  
79         pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));  
80         return pw;  
81     \}  
82      
83     public byte\[\] getBuffer()\{  
84         try\{  
85             if(pw!=null)\{  
86                 pw.close();  
87             \}  
88             if(bout!=null)\{  
89                 bout.flush();  
90                 return bout.toByteArray();  
91             \}  
92              
93              
94             return null;  
95         \}catch (Exception e) \{  
96             throw new RuntimeException(e);  
97         \}  
98     \}  
99 \}  
100  
101 class MyServletOutputStream extends ServletOutputStream\{  
102  
103     private ByteArrayOutputStream bout;  
104     public MyServletOutputStream(ByteArrayOutputStream bout)\{  
105         this.bout = bout;  
106     \}  
107      
108     @Override  
109     public void write(int b) throws IOException \{  
110         this.bout.write(b);  
111     \}  
112 \}  
  
　　在web.xml中配置压缩过滤器  
  
1  <filter>  
2       <description>配置压缩过滤器</description>  
3       <filter-name>GzipFilter</filter-name>  
4       <filter-class>me.gacl.web.filter.GzipFilter</filter-class>  
5   </filter>  
6    
7     
8   <filter-mapping>  
9       <filter-name>GzipFilter</filter-name>  
10       <url-pattern>\*.jsp</url-pattern>  
11         
12         
15       <dispatcher>FORWARD</dispatcher>  
16         
17       <dispatcher>REQUEST</dispatcher>  
18   </filter-mapping>  
19     
20   <filter-mapping>  
21       <filter-name>GzipFilter</filter-name>  
22       <url-pattern>\*.js</url-pattern>  
23   </filter-mapping>  
24     
25   <filter-mapping>  
26       <filter-name>GzipFilter</filter-name>  
27       <url-pattern>\*.css</url-pattern>  
28   </filter-mapping>  
29     
30   <filter-mapping>  
31       <filter-name>GzipFilter</filter-name>  
32       <url-pattern>\*.html</url-pattern>  
33   </filter-mapping>  
  
**3.2、response增强案例——缓存数据到内存**  
  
　　对于页面中很少更新的数据，例如商品分类，为避免每次都要从数据库查询分类数据，因此可把分类数据缓存在内存或文件中，以此来减轻数据库压力，提高系统响应速度。  
  
　　编写缓存数据的过滤器，代码如下：  
  1 package me.gacl.web.filter;  
  2  
  3 import java.io.ByteArrayOutputStream;  
  4 import java.io.IOException;  
  5 import java.io.OutputStreamWriter;  
  6 import java.io.PrintWriter;  
  7 import java.util.HashMap;  
  8 import java.util.Map;  
  9  
10 import javax.servlet.Filter;  
11 import javax.servlet.FilterChain;  
12 import javax.servlet.FilterConfig;  
13 import javax.servlet.ServletException;  
14 import javax.servlet.ServletOutputStream;  
15 import javax.servlet.ServletRequest;  
16 import javax.servlet.ServletResponse;  
17 import javax.servlet.http.HttpServletRequest;  
18 import javax.servlet.http.HttpServletResponse;  
19 import javax.servlet.http.HttpServletResponseWrapper;  
20  
21 /\*\*  
22 \* @ClassName: WebResourceCachedFilter  
23 \* @Description: Web资源缓存过滤器  
24 \* @author: 芭蕉扇  
25 \* @date: 2017-03-20  
26 \*  
27 \*/  
28 public class WebResourceCachedFilter implements Filter \{  
29     /\*\*  
30     \* @Field: map  
31     \*          缓存Web资源的Map容器  
32     \*/  
33     private Map<String,byte\[\]> map = new HashMap<String,byte\[\]>();  
34      
35     @Override  
36     public void init(FilterConfig filterConfig) throws ServletException \{  
37  
38     \}  
39  
40     @Override  
41     public void doFilter(ServletRequest req, ServletResponse resp,  
42             FilterChain chain) throws IOException, ServletException \{  
43         HttpServletRequest request = (HttpServletRequest) req;  
44         HttpServletResponse response = (HttpServletResponse) resp;  
45         //1.得到用户请求的uri  
46         String uri = request.getRequestURI();  
47         //2.看缓存中有没有uri对应的数据  
48         byte b\[\] = map.get(uri);  
49         //3.如果缓存中有，直接拿缓存的数据打给浏览器，程序返回  
50         if(b!=null)\{  
51             //根据字节数组和指定的字符编码构建字符串  
52             String webResourceHtmlStr = new String(b,response.getCharacterEncoding());  
53             System.out.println(webResourceHtmlStr);  
54             response.getOutputStream().write(b);  
55             return;  
56         \}  
57         //4.如果缓存没有，让目标资源执行，并捕获目标资源的输出  
58         BufferResponse myresponse = new BufferResponse(response);  
59         chain.doFilter(request, myresponse);  
60         //获取缓冲流中的内容的字节数组  
61         byte out\[\] = myresponse.getBuffer();  
62         //5.把资源的数据以用户请求的uri为关键字保存到缓存中  
63         map.put(uri, out);  
64         //6.把数据打给浏览器  
65         response.getOutputStream().write(out);  
66     \}  
67  
68     @Override  
69     public void destroy() \{  
70  
71     \}  
72  
73     class BufferResponse extends HttpServletResponseWrapper\{  
74         private ByteArrayOutputStream bout = new ByteArrayOutputStream();  //捕获输出的缓存  
75         private PrintWriter pw;  
76         private HttpServletResponse response;  
77         public BufferResponse(HttpServletResponse response) \{  
78             super(response);  
79             this.response = response;  
80         \}  
81         @Override  
82         public ServletOutputStream getOutputStream() throws IOException \{  
83             return new MyServletOutputStream(bout);  
84         \}  
85         @Override  
86         public PrintWriter getWriter() throws IOException \{  
87             pw = new PrintWriter(new OutputStreamWriter(bout,this.response.getCharacterEncoding()));  
88             return pw;  
89         \}  
90          
91         public byte\[\] getBuffer()\{  
92             try\{  
93                 if(pw!=null)\{  
94                     pw.close();  
95                 \}  
96                 return bout.toByteArray();  
97             \}catch (Exception e) \{  
98                 throw new RuntimeException(e);  
99             \}  
100         \}  
101     \}  
102  
103     class MyServletOutputStream extends ServletOutputStream\{  
104         private ByteArrayOutputStream bout;  
105         public MyServletOutputStream(ByteArrayOutputStream bout)\{  //接收数据写到哪里  
106             this.bout = bout;  
107         \}  
108         @Override  
109         public void write(int b) throws IOException \{  
110             bout.write(b);  
111         \}  
112     \}  
113 \}  
  
　　在web.xml中配置Web资源缓存过滤器  
  
1   <filter>  
2        <description>Web资源缓存过滤器</description>  
3       <filter-name>WebResourceCachedFilter</filter-name>  
4       <filter-class>me.gacl.web.filter.WebResourceCachedFilter</filter-class>  
5   </filter>  
6    
7   <filter-mapping>  
8       <filter-name>WebResourceCachedFilter</filter-name>  
9         
10       <url-pattern>/login.jsp</url-pattern>  
11       <url-pattern>/test.jsp</url-pattern>  
12       <url-pattern>/test2.jsp</url-pattern>  
13   </filter-mapping>