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