java过滤敏感词，读配置文件/动态数据

读取：properties 配置文件

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.Properties;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class KeyWordFilter {
    private static Pattern pattern = null;

    static {
        StringBuffer patternBuf = new StringBuffer();
        try {
            InputStream in = KeyWordFilter.class.getClassLoader().getResourceAsStream("words.properties");
            Properties properties = new Properties();
            properties.load(in);
            
            Enumeration<?> enu = properties.propertyNames();
            while (enu.hasMoreElements()) {
                patternBuf.append((String) enu.nextElement() + "|");    //读取所有properties里的词，以 | 分隔
            }
            
            patternBuf.deleteCharAt(patternBuf.length() - 1);
            
            //默认下，properties文件读取编码： ISO8859-1
            pattern = Pattern.compile(new String(patternBuf.toString().getBytes("ISO8859-1"), "UTF-8"));
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static String doFilter(String str) {
        System.out.println("str:" + str);
        try {
            Matcher m = pattern.matcher(str);
            str = m.replaceAll("**");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return str;
    }
}

读取数据库

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.shangde.edu.dis.domain.DisWord;
import com.shangde.edu.dis.service.IDisWord;

/**
 * 过滤敏感词
 * @author changfu.dai
 *
 */
public class KeyWordFilter {
	
	private IDisWord disWordService;
	private static KeyWordFilter instance = null ;
	private StringBuffer patternBuf = null;
	private Pattern pattern = null;
	
	public static KeyWordFilter getInstance(IDisWord disWordService) {   
		      if (instance == null) {  
		            instance = new KeyWordFilter(disWordService); 
		      }   
		      return instance;   
	}
	
	/**
	 *	更新数据时重新new敏感词过滤对象
	 */
	public void init(){
		creatKeyWords();
	}
	/**
	 * 从数据库初始化正则表达式字符串
	 * @param disWordService 敏感词实现对象
	 */
	public KeyWordFilter(IDisWord disWordService){
		this.disWordService = disWordService;
		init();
	}
	
	/**
	 * 创建和更新关键词正则表达式
	 */
	private void creatKeyWords(){
		patternBuf = new StringBuffer("");
		List<DisWord> dwList = disWordService.getAllDisWord();
		if(dwList.size()>0){
			patternBuf.append("(");
			for (DisWord word : dwList) {
				patternBuf.append(word.getWord()+"|");
			}
			patternBuf.deleteCharAt(patternBuf.length() - 1);
			patternBuf.append(")");
			pattern = Pattern.compile(new String(patternBuf.toString().getBytes()));
		}else{
			pattern = null;
		} 
	}
	
	/**
	 * 过滤敏感词
	 * @param str	要过滤的字符串
	 * @return 	过滤后的字符串
	 */
	public String doFilter(String str) {
		if(pattern!=null&&str!=null){
			Matcher m = pattern.matcher(str);
			str = m.replaceAll("**");
		}
		return str;
	}

}

/*读取数据库的使用方法，使用了 spring 注入*/
//敏感词service action注入
private IDisWord disWordService;
public void setDisWordService(IDisWord disWordService) {
	this.disWordService = disWordService;
}

//方法中调用
//参数：敏感词service对象
KeyWordFilter kw = KeyWordFilter.getInstance(disWordService);

//str过滤后的内容；content要过滤的内容
String str = kw.doFilter(content);

//对敏感词增加或删除时调用  创建最新的单例对象
KeyWordFilter.getInstance(disWordService).init();