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;  
    }  
}