JSP脏话过滤器的实现

JSP脏话过滤器的实现

不管是JSP还是Servlet，其Filter过滤器都是一个东西。因为JSP的本质就是Servlet，只不过是被包装了一下，成了标准，让Web服务器都遵循这个标准来解析编译执行而已。

以下演示的就是在JSP中如何过滤脏话（Servlet的处理方式也差不多）。

一、过滤器类

package com.filter;

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

public class WordsFilter implements Filter {

              

               private Map< String, String>map = new HashMap< String, String>();

               // 过滤器的初始化

               public void init(FilterConfig config) throws ServletException {

                               String filePath = config.getInitParameter("filePath");

                               // 从配置文件中取得文件的相对路径

                               ServletContext context = config.getServletContext();

                               String realPath = context.getRealPath(filePath);

                               // 根据相对路径取得绝对路径

                               try {

                                              FileReader freader = new FileReader(realPath);

                                              // 根据绝对路径，通过文件流来读取文件

                                              BufferedReader br = new BufferedReader(freader);

                                              String line = null;

                                              while((line=br.readLine()) != null) {

                                                             String []str = line.split("=");

                                                             map.put(str[0], str[1]);

                                              }

                               } catch (FileNotFoundException e) {

                                              e.printStackTrace();

                               } catch (IOException e) {

                                              e.printStackTrace();

                               }

                              

                              

               }

               public void doFilter(ServletRequest request, ServletResponse response,

                                              FilterChain chain) throws IOException, ServletException {

                               // 乱码处理

                               request.setCharacterEncoding("gb2312");

                               response.setContentType("text/html;charset=gb2312");

                               HttpServletRequest HttpReq = (HttpServletRequest) request;

                               HttpReqWrapper hrw = new HttpReqWrapper(HttpReq);

                               hrw.setMap(map);

                               chain.doFilter(hrw, response);

               }

               public void destroy() {

                               System.out.println("--过滤器的销毁--");

               }

              

}

二、请求包装器

package com.filter;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;

public class HttpReqWrapper extends HttpServletRequestWrapper {

               private Map< String,String> map = null;

               public HttpReqWrapper(HttpServletRequest request) {

                               super(request);

               }

               // 过滤脏话

               public String replace(String str){

                               StringBuffer sb = new StringBuffer(str);

                               Setkeys = this.getMap().keySet();

                               Iteratorit = keys.iterator();

                               String ss = null;

                               while(it.hasNext()) {

                                              String key = it.next();

                                              int index = sb.indexOf(key);

                                              if(index != -1) {

                                                             if(key != null)

                                                                            ss = key;

                                                             sb.replace(index, index+key.length(), this.getMap().get(key));

                                              }

                               }

                               if(ss!=null) {

                                              if (sb.toString().indexOf(ss) == -1) {

                                                             return sb.toString();

                                              } else {

                                                             return replace(sb.toString());

                                              }

                               }

                               return sb.toString();

               }

               // 重写getParameter()方法

               public String getParameter(String str) {

                               if(str.equals("pager.offset")){

                                              return super.getParameter(str);

                               }else{

                                              String content =  super.getParameter(str);

                                              return replace(content);

                               }             

               }

               public Map< String,String> getMap() {

                               return map;

               }

               public void setMap(Map< String,String> map) {

                               this.map = map;

               }

              

              

}

三、脏话列表 Profanity.txt

妈的=**
老子=**
狗日的=***
我日=我*
TMD=***
我靠=我*
贱人=**
滚=*
操=*

四、web.xml中配置过滤器
<filter>
<filter-name>WordsFilter</filter-name>
<filter-class>com.filter.WordsFilter</filter-class>
<init-param>
<param-name>filePath</param-name>
<param-value>/WEB-INF/Profanity.txt</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>WordsFilter</filter-name>
<url-pattern>/getNote.jsp</url-pattern>
</filter-mapping>

五、代码样式格式化后的内容

1.  JSP脏话过滤器的实现

2.  不管是JSP还是Servlet，其Filter过滤器都是一个东西。因为JSP的本质就是Servlet，只不过是被包装了一下，成了标准，让Web服务器都遵循这个标准来解析编译执行而已。

3.  以下演示的就是在JSP中如何过滤脏话（Servlet的处理方式也差不多）：

4.  一、 过滤器类 

5.  package com.filter;

6.  import java.io.BufferedReader;

7.  import java.io.FileNotFoundException;

8.  import java.io.FileReader;

9.  import java.io.IOException;

10. import java.util.HashMap;

11. import java.util.Iterator;

12. import java.util.Map;

13. import java.util.Set;

14. import javax.servlet.Filter;

15. import javax.servlet.FilterChain;

16. import javax.servlet.FilterConfig;

17. import javax.servlet.ServletContext;

18. import javax.servlet.ServletException;

19. import javax.servlet.ServletRequest;

20. import javax.servlet.ServletResponse;

21. import javax.servlet.http.HttpServletRequest;

22. public class WordsFilter implements Filter {

23.     

24.     private Map< String, String>map = new HashMap< String, String>();

25.     // 过滤器的初始化

26.     public void init(FilterConfig config) throws ServletException {

27.         String filePath = config.getInitParameter("filePath");

28.         // 从配置文件中取得文件的相对路径

29.         ServletContext context = config.getServletContext();

30.         String realPath = context.getRealPath(filePath);

31.         // 根据相对路径取得绝对路径

32.         try {

33.             FileReader freader = new FileReader(realPath);

34.             // 根据绝对路径，通过文件流来读取文件

35.             BufferedReader br = new BufferedReader(freader);

36.             String line = null;

37.             while((line=br.readLine()) != null) {

38.                 String []str = line.split("=");

39.                 map.put(str[0], str[1]);

40.             }

41.         } catch (FileNotFoundException e) {

42.             e.printStackTrace();

43.         } catch (IOException e) {

44.             e.printStackTrace();

45.         }

46.         

47.         

48.     }

49.     public void doFilter(ServletRequest request, ServletResponse response,

50.             FilterChain chain) throws IOException, ServletException {

51.         // 乱码处理

52.         request.setCharacterEncoding("gb2312");

53.         response.setContentType("text/html;charset=gb2312");

54.         HttpServletRequest HttpReq = (HttpServletRequest) request;

55.         HttpReqWrapper hrw = new HttpReqWrapper(HttpReq);

56.         hrw.setMap(map);

57.         chain.doFilter(hrw, response);

58.     }

59.     public void destroy() {

60.         System.out.println("--过滤器的销毁--");

61.     }

62.     

63. }

64. 二、请求包装器

65. package com.filter;

66. import java.util.Iterator;

67. import java.util.Map;

68. import java.util.Set;

69. import javax.servlet.http.HttpServletRequest;

70. import javax.servlet.http.HttpServletRequestWrapper;

71. public class HttpReqWrapper extends HttpServletRequestWrapper {

72.     private Map< String,String> map = null;

73.     public HttpReqWrapper(HttpServletRequest request) {

74.         super(request);

75.     }

76.     // 过滤脏话

77.     public String replace(String str){

78.         StringBuffer sb = new StringBuffer(str);

79.         Setkeys = this.getMap().keySet();

80.         Iteratorit = keys.iterator();

81.         String ss = null;

82.         while(it.hasNext()) {

83.             String key = it.next();

84.             int index = sb.indexOf(key);

85.             if(index != -1) {

86.                 if(key != null)

87.                     ss = key;

88.                 sb.replace(index, index+key.length(), this.getMap().get(key));

89.             }

90.         }

91.         if(ss!=null) {

92.             if (sb.toString().indexOf(ss) == -1) {

93.                 return sb.toString();

94.             } else {

95.                 return replace(sb.toString());

96.             }

97.         }

98.         return sb.toString();

99.     }

100.     // 重写getParameter()方法

101.     public String getParameter(String str) {

102.         if(str.equals("pager.offset")){

103.             return super.getParameter(str);

104.         }else{

105.             String content =  super.getParameter(str);

106.             return replace(content);

107.         }    

108.     }

109.     public Map< String,String> getMap() {

110.         return map;

111.     }

112.     public void setMap(Map< String,String> map) {

113.         this.map = map;

114.     }

115.     

116.     

117. }

118. 三、脏话列表 Profanity.txt

119. 妈的=**

120. 老子=**

121. 狗日的=***

122. 我日=我*

123. TMD=***

124. 我靠=我*

125. 贱人=**

126. 滚=*

127. 操=*

128. 四、web.xml中配置过滤器

129. <filter>

130. <filter-name>WordsFilter</filter-name>

131. <filter-class>com.filter.WordsFilter</filter-class>

132. <init-param>

133. <param-name>filePath</param-name>

134. <param-value>/WEB-INF/Profanity.txt</param-value>

135. </init-param>

136. </filter>

137. <filter-mapping>

138. <filter-name>WordsFilter</filter-name>

139. <url-pattern>/getNote.jsp</url-pattern>

140. </filter-mapping>

六、补充说明

1、<param-name>是参数名称，即代码中：String filePath = config.getInitParameter("filePath"); 用于获取对应参数名称的值，值就存放在<param-value>中。<param-name>和<param-value>相当于一个键-值对，类似于java.util.Map接口。

2、<url-pattern>是要过滤的JSP页面，即可能出现脏话的页面。如果你要把所有页面都过滤，那就把<url-pattern>这一项写成：<url-pattern>/*</url-pattern>，如果在某个相对路径下面，就用：<url-pattern>/servlet/*</url-pattern>，如果要具体过滤某一个JSP页面，就用：<url-pattern>/work/index.jsp</url-pattern>。

 

By CodingMouse

2010年4月9日