关键字过滤DFA

package com.zqgame.mbm.util;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.RowMapper;

import com.zqgame.mbm.config.Config;
import com.zqgame.mbm.db.MySqlConn;
import com.zqgame.mbm.model.BadWord;
/**
*
* @author zxx
*
*/
public class DFAFilter {
static Logger log=LoggerFactory.getLogger(DFAFilter.class);
private static List<String> arr=new ArrayList<String>();
private static Node rootNode = new Node('R');

//初始化禁词表，以HashMap结合HashSet存储，以禁词第一个字作为HashMap的key，后续字符作为HashSet的value
private static RowMapper<BadWord> badWordRowMap=new RowMapper<BadWord>() {
public BadWord mapRow(ResultSet rs, int arg1)
{
BadWord badWord = new BadWord();
try{
badWord.setId(rs.getInt("id"));
badWord.setBadWord(rs.getString("badWord"));
badWord.setCreateTime(rs.getDate("createTime"));
}catch(Exception ex)
{
ex.printStackTrace();
}
return badWord;
}
};

public static void init(){
initBadWordTable();
createTree();
}

public static List<BadWord> getBadWords(){
String sql="select * from qn_badword_info";
return MySqlConn.getInstance().getJdbc().query(sql, badWordRowMap);
}

public static void initBadWordTable(){
List<BadWord> badWords=getBadWords();
if(null!=badWords&&!badWords.isEmpty()){
for(BadWord badWord:badWords){
arr.add(badWord.getBadWord());
}
}
log.debug("arr"+arr.size());

}
public static String searchWord(String content) {
List<String> word = new ArrayList<String>();
int a = 0;
char[] chars = content.toCharArray();
Node node = rootNode;
while(a<chars.length) {
node = findNode(node,chars[a]);
if(node == null) {
node = rootNode;
a = a - word.size();
word.clear();
} else if(node.flag == 1) {
word.add(String.valueOf(chars[a]));
StringBuffer sb = new StringBuffer();
for(String str : word) {
sb.append(str);
}
content= content.replace(sb.toString(), "*");
a = a - word.size() + 1;
word.clear();
node = rootNode;
} else {
word.add(String.valueOf(chars[a]));
}
a++;
}
return content;
}

private static void createTree() {
for(String str : arr) {
char[] chars = str.toCharArray();
if(chars.length > 0)
insertNode(rootNode, chars, 0);
}
}

private static void insertNode(Node node, char[] cs, int index) {
Node n = findNode(node, cs[index]);
if(n == null) {
n = new Node(cs[index]);
node.nodes.add(n);
}

if(index == (cs.length-1))
n.flag = 1;

index++;
if(index<cs.length)
insertNode(n, cs, index);
}

private static Node findNode(Node node, char c) {
List<Node> nodes = node.nodes;
Node rn = null;
for(Node n : nodes) {
if(n.c==c) {
rn = n;
break;
}
}
return rn;
}

public static void main(String[] args) throws Exception {
Config.loadProper();
DFAFilter.init();

long time=System.currentTimeMillis();
System.out.println(DFAFilter.searchWord("23232323232"));
System.out.println(System.currentTimeMillis()-time);
}


private static class Node {
public char c;
public int flag; //1：表示终结，0：延续
public List<Node> nodes = new ArrayList<Node>();

public Node(char c) {
this.c = c;
this.flag = 0;
}

public Node(char c, int flag) {
this.c = c;
this.flag = flag;
}
}
}