屏蔽功能

KeyTree类  这个类的功能是 :

    读取硬盘上的key.txt(里面存放的是敏感关键词)，将之读入Set中，再讲Set中的元素传入到Map中(通过Map来生成敏感词的树状结构)，并传出这个Map(敏感词树)

    public Map createKeyWord():创建一个Map类型的词库(敏感词树)

    private void readSetToMap(Set<String> keyWordSet)： (内部方法)读取敏感词库，将敏感词放入HashSet中

    private Set<String> readKeyTxt()：(内部方法)读取敏感词库中的内容，将内容添加到set集合中

package pingbi;

/**
 * keyWordSet：敏感词集合(中间量) 将原始key.txt中的内容先读入到这个变量(keyWordSet)中,
 *             再由此变量生成敏感词树(keyTreeMap)
 * newMap、nowMap：一起用来生成敏感词树(keyTreeMap)的
 * keyTreeMap:敏感词树
 */
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.*;

/** ----------------初始化敏感词库，将敏感词加入到HashMap中，构建DFA算法模型-----------------*/
public class KeyTree {
    // private String ENCODING = "GBK"; //字符编码
    private String ENCODING = "UTF-8"; // 字符编码
    @SuppressWarnings("rawtypes")
    private HashMap keyTreeMap;// 敏感词集合
    
    public HashMap getKeyTreeMap() {
        return keyTreeMap;
    }

    @SuppressWarnings("rawtypes")
    public Map createKeyWord() {
        try {
            // 读取敏感词库
            Set<String> keyWordSet = readKeyTxt();
            // 将敏感词库加入到HashMap中
            readSetToMap(keyWordSet);
            // spring获取application，然后application.setAttribute("sensitiveWordMap",sensitiveWordMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return keyTreeMap;
    }

    /*-------------- 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型--------------*/
    @SuppressWarnings({ "rawtypes", "unchecked" })
    private void readSetToMap(Set<String> keyWordSet) {
        keyTreeMap = new HashMap(keyWordSet.size());// 初始化敏感词容器，减少扩容操作
        String key = null;
        Map nowMap = null;
        Map<String, String> newMap = null;
        // 迭代keyWordSet
        Iterator<String> iterator = keyWordSet.iterator();
        while (iterator.hasNext()) {
            key = iterator.next(); // 关键字
            nowMap = keyTreeMap;
            for (int i = 0; i < key.length(); i++) {
                char keyChar = key.charAt(i); // 转换成char型
                Object wordMap = nowMap.get(keyChar); // 获取

                if (wordMap != null) { // 如果存在该key，直接赋值
                    nowMap = (Map) wordMap;
                } else { // 不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个
                    newMap = new HashMap<String, String>();
                    newMap.put("isEnd", "0"); // 不是最后一个
                    nowMap.put(keyChar, newMap);
                    nowMap = newMap;
                }

                if (i == key.length() - 1) {
                    nowMap.put("isEnd", "1"); // 最后一个
                }
            }
        }
    }

    /*------------------- 读取敏感词库中的内容，将内容添加到set集合中--------------------*/
    @SuppressWarnings("resource")
    private Set<String> readKeyTxt() throws Exception {
        Set<String> set = null;

        String filepath = "E:\pingbi\key.txt";
        File file = new File(filepath); // 读取文件
        // String filename = "key.txt";

        InputStreamReader read = new InputStreamReader(new FileInputStream(filepath), ENCODING);
        try {
            if (file.isFile() && file.exists()) {// 文件流是否存在
                set = new HashSet<String>();
                BufferedReader bufferedReader = new BufferedReader(read);
                String txt;
                while ((txt = bufferedReader.readLine()) != null) {// 读取文件，将文件内容放入到set中
                    set.add(txt);
                }
            } else {// 不存在抛出异常信息
                throw new Exception("敏感词库文件不存在");
            }
        } catch (Exception e) {
            throw e;
        } finally {
            read.close();// 关闭文件流
        }
        return set;
    }
}

shieldUtil类提供 工具方法

    public shieldUtil(): 构造方法，初始化敏感词库

    public Set<String> getSensitiveWord(String txt): 获取文字中所有的的敏感词，并放入一个Set中

    public String replaceSensitiveWord(String txt, String replaceChar): 替换敏感字字符,替换字符，默认

    public int CheckSensitiveWord(String txt, int beginIndex) :检查文字中是否包含敏感字符，检查规则如下： 如果存在，则返回敏感词字符的长度，不存在返回0

    public boolean isSensitive(String txt): 判断是否含有敏感词

    private String getReplaceChars(String replaceChar, int length): (内部方法)获取替换字符串

package pingbi;

import java.io.*;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/** 敏感词过滤 */
public class shieldUtil {
    @SuppressWarnings("rawtypes")
    private Map keyWord= null;// 树

    /* -------------------构造函数，初始化敏感词库-------------------------- */
    public shieldUtil() {
        keyWord= new KeyTree().createKeyWord();
    }

    /*--------------- 获取文字中所有的的敏感词，并放入一个Set中--------------------*/
    public Set<String> getSensitiveWord(String txt) {
        Set<String> sensitiveWordSet = new HashSet<String>();

        for (int i = 0; i < txt.length(); i++) {
            int length = CheckSensitiveWord(txt, i);// 判断是否包含敏感字符
            if (length > 0) {// 存在,加入list中
                sensitiveWordSet.add(txt.substring(i, i + length));
                i = i + length - 1;// 减1的原因，是因为for会自增
            }
        }
        return sensitiveWordSet;
    }

    /*------------------替换敏感字字符,替换字符，默认------------------*/
    public String replaceSensitiveWord(String txt, String replaceChar) {
        String resultTxt = txt;
        Set<String> set = getSensitiveWord(txt); // 获取所有的敏感词
        Iterator<String> iterator = set.iterator();
        String word = null;
        String replaceString = null;
        while (iterator.hasNext()) {
            word = iterator.next();
            replaceString = getReplaceChars(replaceChar, word.length());
            resultTxt = resultTxt.replaceAll(word, replaceString);
        }
        return resultTxt;
    }

    /*-----------------获取替换字符串 -----------------*/
    /* 例如，已知匹配到的敏感词长度是3，想要替换成“*”号，则得到的替换字符串为“***” */
    private String getReplaceChars(String replaceChar, int length) {
        String resultReplace = replaceChar;
        for (int i = 1; i < length; i++) {
            resultReplace += replaceChar;
        }
        return resultReplace;
    }

    /*--------检查文字中是否包含敏感字符，检查规则如下： 如果存在，则返回敏感词字符的长度，不存在返回0---------*/
    // 只匹配一次，成功即返回
    @SuppressWarnings({ "rawtypes" })
    public int CheckSensitiveWord(String txt, int beginIndex) {
        boolean flag = false;// 敏感词结束标识位：用于敏感词只有1位的情况
        int matchLength = 0;// 匹配标识数默认为0
        char word = 0;
        Map nowMap = keyWord;
        for (int i = beginIndex; i < txt.length(); i++) {
            word = txt.charAt(i);
            nowMap = (Map) nowMap.get(word);// 获取指定key
            if (nowMap != null) {// 存在，则判断是否为最后一个
                matchLength++;// 找到相应key，匹配标识+1
                if ("1".equals(nowMap.get("isEnd"))) {// 如果为最后一个匹配规则,结束循环，返回匹配标识数
                    flag = true;// 结束标志位为true
                }
            } else {// 不存在，直接返回
                break;
            }
        }
        if (matchLength < 2 || !flag) {// 长度必须大于等于1，为词
            matchLength = 0;
        }
        return matchLength;
    }

    /*----------------------判断是否含有敏感词------------------*/
    public boolean isSensitive(String txt) {
        int matchLength = CheckSensitiveWord(txt, 0);
        return matchLength > 0;
    }
}