功能描述
将请求响应中所有的禁用关键字替换掉之后再输出。
使用方法
在 java web 项目的 web.xml 文件中添加如下代码。
<!--替换关键字的过滤器配置 开始 -->
<
filter
>
<
filter-name
>StopWordsFilter</
filter-name
>
<
filter-class
>com.hmw.filter.StopWordsFilter</
filter-class
>
<
init-param
>
<
description
>需要禁用的关键字,一个关键字占一行</
description
>
<
param-name
>keys</
param-name
>
<
param-value
>
QQ
百度
七一五
</
param-value
>
</
init-param
>
</
filter
>
<
filter-mapping
>
<
filter-name
>StopWordsFilter</
filter-name
>
<
servlet-name
>*.jsp</
servlet-name
>
</
filter-mapping
>
<!--替换关键字的过滤器 结束 -->
|
过滤器源码
ReplaceKeyWordFilter.java
package
com.hmw.filter;
import
java.io.IOException;
import
java.io.PrintWriter;
import
java.util.HashSet;
import
java.util.Iterator;
import
java.util.Set;
import
java.util.StringTokenizer;
import
javax.servlet.Filter;
import
javax.servlet.FilterChain;
import
javax.servlet.FilterConfig;
import
javax.servlet.ServletException;
import
javax.servlet.ServletRequest;
import
javax.servlet.ServletResponse;
import
javax.servlet.http.HttpServletResponse;
/**
* 替换关键字的滤器 <br>
*
* @author <a href="mailto:hemingwang0902@126.com">何明旺</a>
*/
public
class
StopWordsFilter
implements
Filter {
private
Set keyWords =
new
HashSet();
/**
* 将需要进行替换的关键字添加到一个定义好的 Set 中
*/
@Override
public
void
init(FilterConfig config)
throws
ServletException {
String keys = config.getInitParameter(
"keys"
);
StringTokenizer tokenizer =
new
StringTokenizer(keys);
String token =
null
;
while
(tokenizer.hasMoreTokens()) {
token = tokenizer.nextToken();
if
(token !=
null
&& token.length() >
0
){
keyWords.add(tokenizer.nextToken());
}
}
}
@Override
public
void
doFilter(ServletRequest request, ServletResponse response,
FilterChain chain)
throws
ServletException, IOException {
CharArrayWrapper responseWrapper =
new
CharArrayWrapper(
(HttpServletResponse) response);
// 调用请求资源(使用自己包装的 responseWrapper)
chain.doFilter(request, responseWrapper);
// 取得响应字符串
String responseString = responseWrapper.toString();
// 将需要替换的关键字用“**”替换掉
Iterator iter = keyWords.iterator();
while
(iter.hasNext()) {
responseString = replace(responseString, iter.next(),
"**"
);
}
// 修改响应头信息中的 Content-Length
response.setContentLength(responseString.length());
PrintWriter out = response.getWriter();
out.write(responseString);
}
@Override
public
void
destroy() {
}
/**
* 将字符串中的所有的指定子字符串替换掉
* @param mainString 需要进行替换的字符串
* @param orig 需要被替换的子串
* @param replacement 替换后的新串
* @return 返回替换后的字符串
*/
public
static
String replace(String mainString, String orig, String replacement) {
String result =
""
;
int
oldIndex =
0
;
int
index =
0
;
int
origLength = orig.length();
while
((index = mainString.indexOf(orig, oldIndex)) != -
1
) {
result = result + mainString.substring(oldIndex, index) + replacement;
oldIndex = index + origLength;
}
result = result + mainString.substring(oldIndex);
return
result;
}
}
|
CharArrayWrapper.java
package
com.hmw.filter;
import
java.io.CharArrayWriter;
import
java.io.PrintWriter;
import
javax.servlet.http.HttpServletResponse;
import
javax.servlet.http.HttpServletResponseWrapper;
/**
* A response wrapper that takes everything the client would normally output and
* saves it in one big character array.
*/
public
class
CharArrayWrapper
extends
HttpServletResponseWrapper {
private
CharArrayWriter charWriter;
/**
* Initializes wrapper.
* <P>
* First, this constructor calls the parent constructor. That call is
* crucial so that the response is stored and thus setHeader, *setStatus,
* addCookie, and so forth work normally.
* <P>
* Second, this constructor creates a CharArrayWriter that will be used to
* accumulate the response.
*/
public
CharArrayWrapper(HttpServletResponse response) {
super
(response);
charWriter =
new
CharArrayWriter();
}
/**
* When servlets or JSP pages ask for the Writer, don't give them the real
* one. Instead, give them a version that writes into the character array.
* The filter needs to send the contents of the array to the client (perhaps
* after modifying it).
*/
@Override
public
PrintWriter getWriter() {
return
new
PrintWriter(charWriter);
}
/**
* Get a String representation of the entire buffer.
* <P>
* Be sure <B>not</B> to call this method multiple times on the same
* wrapper. The API for CharArrayWriter does not guarantee that it
* "remembers" the previous value, so the call is likely to make a new
* String every time.
*/
@Override
public
String toString() {
return
charWriter.toString();
}
/** Get the underlying character array. */
public
char
[] toCharArray() {
return
charWriter.toCharArray();
}
}
|