替換禁用語（指定關鍵字）的過濾器（StopWordsFilter）

功能描述

        將請求響應中全部的禁用關鍵字替換掉以後再輸出。

使用方法

        在 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();
    }
}