敏感词的过滤

对敏感词生成前缀树

1. 根节点不包含字符
2. 叶子节点包含敏感词结束字符，从前缀树的第一个节点到前缀树的叶子节点结束为一个敏感词；
  对包含敏感词文件内的数据进行逐行读取，每一行都是一个敏感词，对每一行数据中的每一个字符进行遍历查找，当不包含某个字符时，生成新的节点挂在上层节点的下面。

过滤的文本

  从前往后遍历，需要两个指针，一个begin指向begin位置处的字符，另一个position先指向begin位置，然后向后遍历；

敏感词过滤过程

• 指针begin指向过滤文本中的某个位置；从过滤文本的开头向结尾遍历，遍历到结尾时，整个敏感词过滤过程结束；
• 指针position一开始指向begin，并且从begin位置处向后遍历，用于判断以begin开始的连续字符是否是敏感词；
• 指针tempNode是敏感词构成的前缀树中的字符位置；与position同步，当与position处的字符相同时且不是敏感词结尾字符时，position向后遍历，tempNode也向下查找；

package com.example.wenda_new1.service;
import org.apache.commons.lang.CharUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;

@Service
public class SensitiveService implements InitializingBean {
    private static final Logger logger = LoggerFactory.getLogger(SensitiveService.class);
    private static final String DEFAULT_REPLACEMENT = "敏感词"; // 默认敏感词替换符

    //根节点构造函数
    private class TrieNode {
        private boolean end = false; //true 关键词的终结 ； false 继续
        private Map<Character, TrieNode> subNodes = new HashMap<>();// key下一个字符，value是对应的节点
        void addSubNode(Character key, TrieNode node) {// 向指定位置添加节点
            subNodes.put(key, node);
        }
        TrieNode getSubNode(Character key) { // 获取下个节点
            return subNodes.get(key);
        }
        boolean isKeywordEnd() {
            return end;
        }
        void setKeywordEnd(boolean end) {
            this.end = end;
        }
        public int getSubNodeCount() {
            return subNodes.size();
        }
    }

    private TrieNode rootNode = new TrieNode(); // 根节点

    //判断是否是一个符号
    private boolean isSymbol(char c) {
        int ic = (int) c;
        // 0x2E80-0x9FFF 东亚文字范围
        return !CharUtils.isAsciiAlphanumeric(c) && (ic < 0x2E80 || ic > 0x9FFF);
    }


    //过滤敏感词
    public String filter(String text) {
        if (StringUtils.isBlank(text)) {
            return text;
        }
        String replacement = DEFAULT_REPLACEMENT;
        StringBuilder result = new StringBuilder();

        TrieNode tempNode = rootNode;
        int begin = 0; // 回滚数
        int position = 0; // 当前比较的位置
        while (position < text.length()) {
            char c = text.charAt(position);
            // 空格直接跳过
            if (isSymbol(c)) {
                if (tempNode == rootNode) {
                    result.append(c);
                    ++begin;
                }
                ++position;
                continue;
            }
            tempNode = tempNode.getSubNode(c);
            // 当前位置的匹配结束
            if (tempNode == null) {
                // 以begin开始的字符串不存在敏感词
                result.append(text.charAt(begin));
                // 跳到下一个字符开始测试
                position = begin + 1;
                begin = position;
                // 回到树初始节点
                tempNode = rootNode;
            } else if (tempNode.isKeywordEnd()) {
                // 发现敏感词， 从begin到position的位置用replacement替换掉
                result.append(replacement);
                position = position + 1;
                begin = position;
                tempNode = rootNode;
            } else {
                ++position;
            }
        }
        result.append(text.substring(begin));
        return result.toString();
    }

    //将敏感词加到前缀树中
    private void addWord(String lineTxt) {
        TrieNode tempNode = rootNode;
        // 循环每个字节
        for (int i = 0; i < lineTxt.length(); ++i) {
            Character c = lineTxt.charAt(i);
            // 过滤空格
            if (isSymbol(c)) {
                continue;
            }
            TrieNode node = tempNode.getSubNode(c);
            if (node == null) { // 没初始化
                node = new TrieNode();
                tempNode.addSubNode(c, node);
            }
            tempNode = node;
            if (i == lineTxt.length() - 1) {
                // 关键词结束， 设置结束标志
                tempNode.setKeywordEnd(true);
            }
        }
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        rootNode = new TrieNode();
        try {
            InputStream is = Thread.currentThread().getContextClassLoader()
                    .getResourceAsStream("SensitiveWords.txt");
            InputStreamReader read = new InputStreamReader(is);
            BufferedReader bufferedReader = new BufferedReader(read);
            String lineTxt;
            while ((lineTxt = bufferedReader.readLine()) != null) {//将文件中的每个敏感词都加到前缀树中
                lineTxt = lineTxt.trim();
                addWord(lineTxt);
            }
            read.close();
        } catch (Exception e) {
            logger.error("读取敏感词文件失败" + e.getMessage());
        }
    }

    //测试代码
    public static void main(String[] argv) {
        SensitiveService s = new SensitiveService();
        s.addWord("赌博");
        s.addWord("好赌");
        System.out.print(s.filter("你好X赌**博XX"));
    }
}

注意：SensitiveWords.txt是包含敏感词的文件，每个敏感词在占一行，其中中包含敏感词“赌博”