Android 敏感词过滤实现
Android 敏感词过滤实现
今天公司提出来一个在手机端输入文字的时候直接过滤敏感词并替换成“”的需求。想想很简单嘛，不就是把EditText的内容拿到，然后转换成char[],再和敏感词库的一一对比。网上应该有很多才对。所以就直接百度了一下，敏感词过滤，网上果然很多，而且大部分都是提出使用DFA算法，我**，牵扯到算法啊，好高大上的感觉有没有，于是认真的看看简介.
（图是我从别人那抄来的）
看到这张图是不是很熟悉，树形结构。于是开始copy（能抄的时候从来不动脑子去写）别人的代码过来修改修改就能用。
public class SensitiveWordsUtils {
/**
* 敏感词匹配规则
*/
public static final int MinMatchTYpe = 1; //最小匹配规则，如：敏感词库["中国","中国人"]，语句："我是中国人"，匹配结果：我是[中国]人
public static final int MaxMatchType = 2; //最大匹配规则，如：敏感词库["中国","中国人"]，语句："我是中国人"，匹配结果：我是[中国人]
/**
* 敏感词集合
*/
public static HashMap sensitiveWordMap;
/**
* 初始化敏感词库，构建DFA算法模型
*
* @param
*/
public static synchronized void init(Context context) {
try {
initSensitiveWordMap(context);
} catch (Exception e) {
e.printStackTrace();
}
}
//这里直接从asstes读敏感词文件，然后加入到set集合
public static Set<String> readSensitiveWordFile(Context context) throws Exception{
Set<String> set = null;
InputStreamReader read = new InputStreamReader(context.getResources().getAssets().open(“文件名称”),"UTF-8");
try {
set = new HashSet<String>();
BufferedReader bufferedReader = new BufferedReader(read);
String txt = null;
while((txt = bufferedReader.readLine()) != null){
//读取文件，将文件内容放入到set中
set.add(txt);
}
} catch (Exception e) {
throw e;
}finally{
read.close(); //关闭文件流
}
Log.e("ryan","set=="+set.toString());
return set;
}
/**
* 初始化敏感词库，构建DFA算法模型
*
*/
private static void initSensitiveWordMap(Context context) throws Exception {
Set<String> sensitiveWordSet = readSensitiveWordFile(context);
//初始化敏感词容器，减少扩容操作
if (null != sensitiveWordSet && sensitiveWordSet.size() > 0){
sensitiveWordMap = new HashMap(sensitiveWordSet.size());
String key;
Map nowMap;
Map<String, String> newWorMap;
//迭代sensitiveWordSet
Iterator<String> iterator = sensitiveWordSet.iterator();
while (iterator.hasNext()) {
//关键字
key = iterator.next();
nowMap = sensitiveWordMap;
for (int i = 0; i < key.length(); i++) {
//转换成char型
char keyChar = key.charAt(i);
//库中获取关键字
Object wordMap = nowMap.get(keyChar);
//如果存在该key，直接赋值，用于下一个循环获取
if (wordMap != null) {
nowMap = (Map) wordMap;
} else {
//不存在则，则构建一个map，同时将isEnd设置为0，因为他不是最后一个
newWorMap = new HashMap<>();
//不是最后一个
newWorMap.put("isEnd", "0");
nowMap.put(keyChar, newWorMap);
nowMap = newWorMap;
}
if (i == key.length() - 1) {
//最后一个
nowMap.put("isEnd", "1");
}
}
}
}
}
/**
* 判断文字是否包含敏感字符
*
* @param txt 文字
* @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则
* @return 若包含返回true，否则返回false
*/
public static boolean contains(String txt, int matchType) {
boolean flag = false;
for (int i = 0; i < txt.length(); i++) {
int matchFlag = checkSensitiveWord(txt, i, matchType); //判断是否包含敏感字符
if (matchFlag > 0) {
//大于0存在，返回true
flag = true;
}
}
return flag;
}
/**
* 判断文字是否包含敏感字符
*
* @param txt 文字
* @return 若包含返回true，否则返回false
*/
public static boolean contains(String txt) {
return contains(txt, MaxMatchType);
}
/**
* 获取文字中的敏感词
*
* @param txt 文字
* @param matchType 匹配规则 1：最小匹配规则，2：最大匹配规则
* @return
*/
public static Set<String> getSensitiveWord(String txt, int matchType) {
Set<String> sensitiveWordList = new HashSet<>();
for (int i = 0; i < txt.length(); i++) {
//判断是否包含敏感字符
int length = checkSensitiveWord(txt, i, matchType);
if (length > 0) {
//存在,加入list中
sensitiveWordList.add(txt.substring(i, i + length));
i = i + length - 1;//减1的原因，是因为for会自增
}
}
return sensitiveWordList;
}
/**
* 获取文字中的敏感词
*
* @param txt 文字
* @return
*/
public static Set<String> getSensitiveWord(String txt) {
return getSensitiveWord(txt, MaxMatchType);
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceChar 替换的字符，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符：*， 替换结果：我爱***
* @param matchType 敏感词匹配规则
* @return
*/
public static String replaceSensitiveWord(String txt, char replaceChar, int matchType) {
String resultTxt = txt;
//获取所有的敏感词
Set<String> set = getSensitiveWord(txt, matchType);
Iterator<String> iterator = set.iterator();
String word;
String replaceString;
while (iterator.hasNext()) {
word = iterator.next();
replaceString = getReplaceChars(replaceChar, word.length());
resultTxt = resultTxt.replaceAll(word, replaceString);
}
return resultTxt;
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceChar 替换的字符，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符：*， 替换结果：我爱***
* @return
*/
public static String replaceSensitiveWord(String txt, char replaceChar) {
return replaceSensitiveWord(txt, replaceChar, MaxMatchType);
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceStr 替换的字符串，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符串：[屏蔽]，替换结果：我爱[屏蔽]
* @param matchType 敏感词匹配规则
* @return
*/
public static String replaceSensitiveWord(String txt, String replaceStr, int matchType) {
String resultTxt = txt;
//获取所有的敏感词
Set<String> set = getSensitiveWord(txt, matchType);
Iterator<String> iterator = set.iterator();
String word;
while (iterator.hasNext()) {
word = iterator.next();
resultTxt = resultTxt.replaceAll(word, replaceStr);
}
return resultTxt;
}
/**
* 替换敏感字字符
*
* @param txt 文本
* @param replaceStr 替换的字符串，匹配的敏感词以字符逐个替换，如 语句：我爱中国人 敏感词：中国人，替换字符串：[屏蔽]，替换结果：我爱[屏蔽]
* @return
*/
public static String replaceSensitiveWord(String txt, String replaceStr) {
return replaceSensitiveWord(txt, replaceStr, MaxMatchType);
}
/**
* 获取替换字符串
*
* @param replaceChar
* @param length
* @return
*/
private static String getReplaceChars(char replaceChar, int length) {
String resultReplace = String.valueOf(replaceChar);
for (int i = 1; i < length; i++) {
resultReplace += replaceChar;
}
return resultReplace;
}
/**
* 检查文字中是否包含敏感字符，检查规则如下：
*
* @param txt
* @param beginIndex
* @param matchType
* @return 如果存在，则返回敏感词字符的长度，不存在返回0
*/
private static int checkSensitiveWord(String txt, int beginIndex, int matchType) {
//敏感词结束标识位：用于敏感词只有1位的情况
boolean flag = false;
//匹配标识数默认为0
int matchFlag = 0;
char word;
if ( null == sensitiveWordMap){
return 0;
}
Map nowMap = sensitiveWordMap;
for (int i = beginIndex; i < txt.length(); i++) {
word = txt.charAt(i);
//获取指定key
nowMap = (Map) nowMap.get(word);
if (nowMap != null) {
//存在，则判断是否为最后一个
//找到相应key，匹配标识+1
Log.e("ryan","nowMap=="+nowMap.toString());
matchFlag++;
//如果为最后一个匹配规则,结束循环，返回匹配标识数
if ("1".equals(nowMap.get("isEnd"))) {
//结束标志位为true
flag = true;
//最小规则，直接返回,最大规则还需继续查找
if (MinMatchTYpe == matchType) {
break;
}
}
} else {
//不存在，直接返回
break;
}
}
if (matchFlag < 2 || !flag) {
//长度必须大于等于1，为词
matchFlag = 0;
}
return matchFlag;
}
}
到这里已经完成使用搜到的方法就已经完成了。
#但是问题来了，单个字没法过滤，我了个去，只能过滤词啊。仔细看属性结构的图，打印日志会发现，如果单个字和别的字有组合情况出现。比如：性、性生活，这是两个敏感词，但是当查询的时候会出现，查到“性”之后，因为后面还有“生活”两个字可以匹配，所以会继续查下去，而不会结束，但是继续查下去的时候又不匹配，所以返回的结果就是0，这样情况的敏感字就无法过滤了。
private static void addWords(String... sensitiveWords) {
for (String word : sensitiveWords) {
if (word != null && !word.trim().equals("")) {
word = word.trim();
int len = word.length();
if (len > 1024) {
throw new RuntimeException("敏感词太长[最长1024]!");
}
// 添加该词，如果未重复，则添加到tree
if (WORDS.add(word)) {
TreeGenerator.addWord2Tree(TREE, word);
}
}
}
Log.e("ryan","WORDS=="+WORDS.toString());
}
/**
* 将指定的词分成字构建到一棵树中。
*
* @param tree
* 字树
* @param sensitiveWord
* 敏感词词
* @return
*/
public static void addWord2Tree(Map<String, Map> tree, String sensitiveWord) {
addWord2Tree(tree, sensitiveWord, 0);
}
private static Map<String, Map> addWord2Tree(Map<String, Map> tree,
String word, int index) {
if (index == word.length()) {
tree.put(Finder.TREE_END_KEY, generateWordMap(word));
return tree;
}
String next = word.substring(index, index + 1);
Map<String, Map> subTree = tree.get(next);
if (subTree == null) {
subTree = new HashMap<String, Map>();
}
tree.put(next, addWord2Tree(subTree, word, index + 1));
return tree;
}
private static Map<String, Object> generateWordMap(String word) {
Map<String, Object> wordMap = new HashMap<String, Object>();
wordMap.put(Finder.WORD_VALUE, word);
wordMap.put(Finder.WORD_LENGTH, word.length());
return wordMap;
}
/**
* 替换文本中的敏感词
*
* @param text
* 含敏感词的文本
* @return
*/
public static String replace(String text) {
return Finder.replace(text);
}
/**
* 替换文本中的敏感词
*
* @param text
* 含敏感词的文本
* @return
*/
public static String replace(String text) {
return new TextAnalysis().replace(TREE, text, DEFAULT_REPLACEMENT);
}
/**
* 替换文本中的敏感词
*
* @param tree
* 敏感字树
* @param text
* 待分析的文本
* @param replacement
* 替换字符
* @return
*/
public String replace(Map<String, Map> tree, String text,
Character replacement) {
if (replacement == null) {
replacement = Finder.DEFAULT_REPLACEMENT;
}
if (text != null && text.trim().length() > 0) {
StringBuffer sb = new StringBuffer("");
replace(tree, text, 0, replacement, sb);
return sb.toString();
}
return text;
}