DFA敏感词过滤

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.json.JSONException;
import org.json.JSONObject;

public class DFA {
    /**
     * 根节点
     */
    private static TreeNode rootNode = new TreeNode();    

    /**
     * 创建关键词树时的临时根节点
     */
    private static TreeNode rootNodeTemp = new TreeNode();

    /**
     * 关键词缓存
     */
    private static ByteBuffer keywordBuffer = ByteBuffer.allocate(1024);       

    /**
     * 关键词编码
     */
    private static String charset = "utf-8";    

    /**
     * 关键词树是否初始化
     */
    private static boolean treeIsInit = false;    

    /**
     * 创建DFA树
     * @param keywordList
     * @throws UnsupportedEncodingException
     */
    public static void createKeywordTree(List<String> keywordList) throws UnsupportedEncodingException{
        for (String keyword : keywordList) {
            if(keyword == null) continue;
            keyword = keyword.trim().toLowerCase();
            byte[] bytes = keyword.getBytes(charset);
            TreeNode tempNode = rootNodeTemp;
            for (int i = 0; i < bytes.length; i++) {
                int index = bytes[i] & 0xff;
                TreeNode node = tempNode.getSubNode(index);
                if(node == null){
                    node = new TreeNode();
                    tempNode.setSubNode(index, node);
                }
                tempNode = node;
                if(i == bytes.length - 1){
                    tempNode.setKeywordEnd(true);
                }
            }
        }
        synchronized (DFA.class)
        {
            rootNode = rootNodeTemp;
            if(!treeIsInit)treeIsInit = true;
        }

    }    

    /**
     * 检索关键词
     * @param text
     * @return
     * @throws UnsupportedEncodingException
     */
    public static JSONObject searchKeyword(String text) throws UnsupportedEncodingException{
        if(StringUtils.isEmpty(text)){
            JSONObject json = new JSONObject();
            try
            {
                json.put("islegal", "1");
                json.put("deststr", "");
            }
            catch (JSONException e)
            {
                e.printStackTrace();
            }
            return json;
        }
        if(!treeIsInit)createKeywordTree();
        System.out.println("searchKeyword:"+text);
        return searchKeyword(text.getBytes(charset),text.toLowerCase().getBytes(charset));
    }    

    /**
     * 检索关键词
     * @param oldBytes
     * @param bytes
     * @return
     */
    public static JSONObject searchKeyword(byte[] oldBytes,byte[] bytes){
        String is_legal = "1";
        JSONObject json = new JSONObject();
        String result = null;
        if(bytes == null || bytes.length == 0){
            result = "";
        }else{
            synchronized (DFA.class)
            {
                TreeNode tempNode = rootNode;
                int rollback = 0;
                int position = 0;
                while (position < bytes.length) {
                    int index = bytes[position] & 0xFF;
                    keywordBuffer.put(bytes[position]);
                    tempNode = tempNode.getSubNode(index);
                    if(tempNode == null){
                        position = position - rollback;
                        rollback = 0;
                        tempNode = rootNode;
                        keywordBuffer.clear();
                    }
                    else if(tempNode.isKeywordEnd()){
                        keywordBuffer.flip();
                        for (int i = 0; i <= rollback; i++) {
                                bytes[position-i] = 42;
                                oldBytes[position-i] = 42;
                        }
                        keywordBuffer.limit(keywordBuffer.capacity());
                        rollback = 1;
                        is_legal = "0";
                    }else{
                        rollback++;
                    }
                    position++;
                }
            }
            try {
                 result  =  new String(oldBytes,charset);    

            } catch (Exception e) {
                e.printStackTrace();
            }  

        }
        try
        {
            json.put("islegal", is_legal);
            json.put("deststr", result);
        }
        catch (JSONException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return json;
    }    

    public void setCharset(String charset) {
        this.charset = charset;
    } 

    public static void main(String[] args){
        try{
            List<String> keys = new ArrayList<String>();
            keys.add("TMD");
            keys.add("변형");
            String text ="你真TMD是个변형啊!";
            DFA.createKeywordTree(keys);
            JSONObject a = DFA.searchKeyword(text);
            System.out.println(a);
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
    }
} 

import java.util.ArrayList;
import java.util.List;

public class TreeNode {
    private static final int NODE_LEN = 256;  

    /**
     * true 关键词的终结 ； false 继续
     */
    private boolean end = false;   

    private List<TreeNode> subNodes = new ArrayList<TreeNode>(NODE_LEN);  

    public TreeNode(){
        for (int i = 0; i < NODE_LEN; i++) {
            subNodes.add(i, null);
        }
    }  

    /**
     * 向指定位置添加节点树
     * @param index
     * @param node
     */
    public void setSubNode(int index, TreeNode node){
        subNodes.set(index, node);
    }  

    public TreeNode getSubNode(int index){
        //System.out.println("index:"+index+" node:"+this+"--subNodes:"+subNodes.get(index));
        return subNodes.get(index);
    }  

    public boolean isKeywordEnd() {
        return end;
    }  

    public void setKeywordEnd(boolean end) {
        this.end = end;
    }
}