java web过滤器实际应用（解决中文乱码 html标签转义功能 敏感字符过滤功能）
转载地址：http://www.cnblogs.com/xdp-gacl/p/3952405.html
在filter中可以得到代表用户请求和响应的request、response对象，因此在编程中可以使用Decorator(装饰器)模式对request、response对象进行包装，再把包装对象传给目标资源，从而实现一些特殊需求。
一、Decorator设计模式
1.1、Decorator设计模式介绍
当某个对象的方法不适应业务需求时，通常有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: 2014-8-31 下午11:09:37
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 <!--配置字符过滤器，解决get、post请求方式下的中文乱码问题-->
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: 2014-9-2 下午11:28:41
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: 2014-9-2 下午11:29:09
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 <!--配置Html过滤器，转义内容中的html标签-->
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: 2014-9-6 上午10:43:11
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: 2014-9-6 上午11:56:35
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: 2014-9-6 下午6:17:37
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: 2014-9-7 上午10:52:42
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 <!--jsp文件的输出的内容都经过压缩过滤器压缩后才输出 -->
8 <filter-mapping>
9 <filter-name>GzipFilter</filter-name>
10 <url-pattern>*.jsp</url-pattern>
11 <!-- 配置过滤器的拦截方式-->
12 <!-- 对于在Servlet中通过
13 request.getRequestDispatcher("jsp页面路径").forward(request, response)
14 方式访问的Jsp页面的要进行拦截 -->
15 <dispatcher>FORWARD</dispatcher>
16 <!--对于直接以URL方式访问的jsp页面进行拦截，过滤器的拦截方式默认就是 REQUEST-->
17 <dispatcher>REQUEST</dispatcher>
18 </filter-mapping>
19 <!--js文件的输出的内容都经过压缩过滤器压缩后才输出 -->
20 <filter-mapping>
21 <filter-name>GzipFilter</filter-name>
22 <url-pattern>*.js</url-pattern>
23 </filter-mapping>
24 <!--css文件的输出的内容都经过压缩过滤器压缩后才输出 -->
25 <filter-mapping>
26 <filter-name>GzipFilter</filter-name>
27 <url-pattern>*.css</url-pattern>
28 </filter-mapping>
29 <!--html文件的输出的内容都经过压缩过滤器压缩后才输出 -->
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: 2014-9-8 上午12:20:16
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 <!-- 映射需要缓存输出的JSP页面，这几个页面都只是单纯作为输入UI，不会有太多的变化，因此可以缓存输出 -->
10 <url-pattern>/login.jsp</url-pattern>
11 <url-pattern>/test.jsp</url-pattern>
12 <url-pattern>/test2.jsp</url-pattern>
13 </filter-mapping>
java web过滤器实际应用（解决中文乱码 html标签转义功能 敏感字符过滤功能）的更多相关文章
- java 读取文件到String(解决中文乱码)
在改写V&View(维视)时用到了文件管理,需要从html文档读取字符串,可是一直出现中文乱码,一直解决不了.而且很是意外,我在本地运行代码时就能正常读取中文,当放到tomcat上时全是乱码, ...
- JAVA本地读取文件，解决中文乱码问题
JAVA本地读取文件出现中文乱码,查阅一个大神的博客做一下记录 import java.io.BufferedInputStream;import java.io.BufferedReader;imp ...
- Web开发的编码解决中文乱码
中文乱码有两个环节会出现 第一,从请求体中获得的数据 从请求体中获得的数据要为其进行编码,默认为ISO-8859-1,所以在使用getParameter()时先调用setCharacterEncodi ...
- 过滤器复用代码【中文乱码、HTML转义】
中文乱码 public class CharacterEncodingFilter implements Filter { public void doFilter(ServletRequest re ...
- java转pdf（html转为pdf）,解决中文乱码，标签不规范等问题
第一步,下载jar包以及建对应的文件夹.注意pd4ml的jar要选择pro版本.然后建一个pd4fonts.properties 里面对应的字体. SimSun = simsun.ttf 前面为变量名 ...
- 关于web.xml中配置Spring字符编码过滤器以解决中文乱码的问题
当出现中文乱码问题,Spring中可以利用CharacterEncodingFilter过滤器解决,如下代码所示: <!-- Spring字符编码过滤器:解决中文乱码问题 --> < ...
- SSH项目web.xml文件的常用配置【struts2的过滤器、spring监听器、解决Hibernate延迟加载问题的过滤器、解决中文乱码的过滤器】
配置web.xml(struts2的过滤器.spring监听器.解决Hibernate延迟加载问题的过滤器.解决中文乱码的过滤器) <!-- 解决中文乱码问题 --> <filter ...
- java web 中有效解决中文乱码问题-pageEncoding与charset区别, response和request的setCharacterEncoding 区别
这里先写几个大家容易搞混的编码设置代码: 在jsp代码中的头部往往有这两行代码 pageEncoding是jsp文件本身的编码contentType的charset是指服务器发送给客户端时的内容编码J ...
- 04_过滤器Filter_02_Filter解决中文乱码问题
[过滤器解决中文乱码问题实例] [工程截图] [web.xml] <?xml version="1.0" encoding="UTF-8"?> &l ...
随机推荐
- 凡信（超仿微信Android版）开源了，内有源码下载 -
韩梦飞沙 韩亚飞 313134555@qq.com yue31313 han_meng_fei_sha 凡信(超仿微信Android版)开源了,内有源码下载 - IM Geek开发者社区-移动 ...
- Codeforces.809E.Surprise me!(莫比乌斯反演 虚树)
题目链接 \(Description\) 给定一棵树,求\[\frac{1}{n(n-1)/2}\times\sum_{i\in[1,n],j\in[1,n],i\neq j}\varphi(a_i\ ...
- VMWare虚拟机下CentOS 配置网络实现远程连接,提供Web访问
最近使用VMWARE虚拟机当中redhat操作系统,感觉直接使用很不方便,于是就决定配置下redhat网络,通过本机远程工具SecureCRT来连接redhat使用. 环境说明:本机操 ...
- 移动web开发经验总结(1)
1.<meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, minimum-sca ...
- c# 四舍五入、上取整、下取整
在处理一些数据时,我们希望能用“四舍五入”法实现,但是C#采用的是“四舍六入五成双”的方法,如下面的例子,就是用“四舍六入五成双”得到的结果: double d1 = Math.Round(1.25, ...
- java基础学习总结——开篇
java是我学习的第一门编程语言,当初学习java基础的时候下了不少功夫,趁着这段时间找工作之际,好好整理一下以前学习java基础时记录的笔记,当作是对java基础学习的一个总结吧,将每一个java的 ...
- win8.1快速启动选项突然消失了怎么办？
win8开始提供的快速启动功能是一种混合式的休眠模式,Windows系统 在关机时将系统的信息保存到硬盘上的一个文件中来实现下一次的快速启动.当再次启动电脑时, Windows 使用该系统信息文件来恢 ...
- 报错：无法从int?转换为int
□ 背景分析 在控制器方法中的一个参数允许为null值:public ActionResult GetByCategory(int? categoryId = null) 当把这里的categoryI ...
- 23LINQ运算符返回其它类型实例汇总
IEnumerable<T>返回其它集合类型 ToArray() ToList() ToDictionary() ToLookUp() 返回集合中的元素 □ ElementAt ...
- jsondataobjects
jsondataobjects GITHUB: https://github.com/ahausladen/jsondataobjects.git 跨平台JSON库 Json Data Objects ...