java用DFA实现脏词过滤以及用FileAlterationListenerAdaptor实现对资源文件修改的动态监听

最近在跟朋友做一个博客网站，里面涉及一些脏词过滤算法，查了很多资料总结来说DFA算法是比较理想的，效率高。脏词本身是一个可以配置的东西，所以不能在程序中将脏词写死，否则要修改或者添加一些新的脏词还需要修改代码重新启动服务器，这显然是不可行的，所以脏词需要做成一个配置文件，并且当配置文件修改后，我不需要重启服务器就可以自动监测到修改后的脏词，这个是用FileAlterationListenerAdaptor实现的。废话不多说，直接上代码，我的代码分成主要分成了两个类，一个是监听器类，一个是脏词检查类。

1. 监听器类，主要实现导入配置文件中的脏词，以及实现对脏词文件的监听，实现脏词文件修改后自动导入

/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zuoxiaolong.blog.common.utils;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.LineIterator;
import org.apache.commons.io.filefilter.FileFilterUtils;
import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
import org.apache.commons.io.monitor.FileAlterationMonitor;
import org.apache.commons.io.monitor.FileAlterationObserver;

import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
* 脏词配置文件监听器
*
* @author linjiedeng
* @date 16/5/28 下午4:26
* @since 1.0.0
*/
public class SensitiveWordMonitor extends FileAlterationListenerAdaptor {

private static SensitiveWordMonitor sensitiveWordMonitor;

public static Map sensitiveWordMap = new HashMap<>();

private static String SENSITIVE_WORD_FILE_NAME = "bad-word.properties";

//服务启动的时候载入脏词文件,并实现对文件的实时监听, 每10分钟监听一次
static {
//获取资源文件的路径
String classPathHole = SensitiveWordMonitor.class.getResource("/").toString();
//去掉开头的file：
String classPath = classPathHole.substring(5);
/监听器类加载的时候首先要导入一次脏词文件
File file = new File(classPath + SENSITIVE_WORD_FILE_NAME);
Set<String> badWordSet = badWordSet = loadBadWord(file);
sensitiveWordMap = addSensitiveWordToHashMap(badWordSet);
SensitiveWordMonitor.getSensitiveWordMonitor().monitor(classPath, 10 * 60 * 1000);
}

private SensitiveWordMonitor() {

}

public static SensitiveWordMonitor getSensitiveWordMonitor() {
if(sensitiveWordMonitor == null) {
synchronized (SensitiveWordMonitor.class) {
if(sensitiveWordMonitor == null) {
sensitiveWordMonitor = new SensitiveWordMonitor();
}
}
}

return sensitiveWordMonitor;
}

private static Set<String> loadBadWord(File file) {
Set<String> badWordSet = new HashSet<>();
try {
LineIterator it = FileUtils.lineIterator(file);
while(it.hasNext()) {
String badWord = it.nextLine();
badWordSet.add(badWord);
}
} catch (Exception e) {
e.printStackTrace();
}

return badWordSet;
}

@Override
public void onFileChange(File file) {
Set<String> badWordSet = badWordSet = loadBadWord(file);
sensitiveWordMap = addSensitiveWordToHashMap(badWordSet);
}

private static Map addSensitiveWordToHashMap(Set<String> badWordSet) {

Map wordMap = new HashMap(badWordSet.size());

for (String word : badWordSet) {
Map currentMap = wordMap;
for (int i = 0; i < word.length(); i++) {

char keyChar = word.charAt(i);
Object tempMap = currentMap.get(keyChar);

if (tempMap != null) {
currentMap = (Map) tempMap;
} else {
Map<String, String> newMap = new HashMap<String, String>();
newMap.put("isEnd", "0");

currentMap.put(keyChar, newMap);
currentMap = newMap;
}

if (i == word.length() - 1) {
currentMap.put("isEnd", "1");
}
}
}

return wordMap;
}

public void monitor(String directory, int interval) {
FileAlterationObserver fileAlterationObserver = new FileAlterationObserver(directory, FileFilterUtils.and(FileFilterUtils.nameFileFilter(SENSITIVE_WORD_FILE_NAME)), null);
fileAlterationObserver.addListener(this);
FileAlterationMonitor fileAlterationMonitor = new FileAlterationMonitor(interval, fileAlterationObserver);

try {
fileAlterationMonitor.start();
} catch (Exception e) {
e.printStackTrace();
}
}
}

2. SensitiveWordCheckUtils脏词检查工具类，实现对脏词的检查判断，当然也可以实现替换，这里没有写，但是弄清楚了原理的话实现起来很简单

/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.zuoxiaolong.blog.common.utils;

import java.util.Map;

/**
* 敏感词检查工具类
*
* @author linjiedeng
* @date 16/5/28 下午7:02
* @since 1.0.0
*/
public class SensitiveWordCheckUtils {

public static int MIN_MATCH_TYPE = 1;   //最小匹配规则, 目前默认的匹配规则

public static int MAX_MATCH_TYPE = 2;   //最大匹配规则

/**
* 判断是否含敏感词
* @param sentence
* @return
*/
public static boolean isContainSensitiveWord(String sentence) {
boolean flag = false;
for (int i = 0; i < sentence.length(); i++) {
if (hasSensitiveWord(sentence, i)) {
return true;
}
}
return false;
}

/**
* 是否包含敏感词
* @param sentence
* @param startCheckIndex
* @return
*/
private static boolean hasSensitiveWord(String sentence, int startCheckIndex) {
int matchCount = 0;
boolean findFlag = false;
Map currentMap = SensitiveWordMonitor.sensitiveWordMap;
for (int i = startCheckIndex; i < sentence.length(); i++) {
char word = sentence.charAt(i);
currentMap = (Map) currentMap.get(word);

// 存在，则判断是否为最后一个
if (currentMap != null) {
matchCount++; // 找到相应key，匹配个数+1

// 如果为最后一个匹配规则,结束循环，返回匹配标识数，目前默认最小匹配规则，所以找到结束就注解退出
if ("1".equals(currentMap.get("isEnd"))) {
findFlag = true;
break;
}
} else {
break;
}
}

if (findFlag && matchCount > 1) {
return true;
} else {
return false;
}
}
}

测试类我就不写了，亲测肯定是没问题的。

当然，这些代码也从如下几篇文章中获取了很多有价值的信息，感谢几位：
http://blog.csdn.net/daixinmei/article/details/42082205
http://www.tuicool.com/articles/QneYFv