java过滤关键字，敏感词汇

很多小伙伴在做网站的时候可能会遇到一些敏感词汇不能出现在网站，但是又不能控制用户的输入，所以贴出一个关键字过滤功以解忧愁

1、前端使用ajax提交表单，将要过滤的字段提交到后台过滤

function audit(obj){//保存并过滤关键字
    var a = obj;
    document.getElementById("checked").value = a;
    $.ajax({//将内容提交到后台过滤关键字
       type:"POST",
       dataType:"JSON",
       url:"cmsContentFiltration/filtration.do",//过滤接口我的是这样的
       data:$('#form').serialize(),//将表单序列化提交后台过滤关键字
       success:function(str){//回调函数中进行是否保存操作
       if(str.data==""|| str.data===undefined){//无敏感词汇直接保存
                $("#form").submit()
       }else{
      if(window.confirm('所提交的内容包含：'+str.data+'等以下敏感词汇，是否保存？')){
                $("#form").submit();
                return true;
              }else{
               return false;
             }
        }
      }
   });
}

2、控制层

/**
 * @ClassName filtration
 * @Description
 * @Author shenWB
 * @Date 2019/6/27 10:12
 * @Version 1.0
 **/
    @RequestMapping("filtration")
    @ResponseBody
    public Object filtration(CmsContent entity, CmsContentAttribute attribute, @ModelAttribute CmsContentParamters contentParamters,
            Boolean draft, Boolean checked, HttpServletRequest request, HttpSession session, ModelMap model){
        Map<String, Object> m = new HashMap<String, Object>();
        List<String> str =new ArrayList<String>();//要过滤字段的集合
        str.add(entity.getTitle());//标题
        //if (!attribute.getText().equals(null)) {
        if (attribute != null && attribute.getText() != null && !attribute.getText().isEmpty()) {
            str.add(attribute.getText());//正文
        }
        //if (!entity.getEditor().equals(null)) {
        if (entity != null && entity.getEditor()!=null && !entity.getEditor().isEmpty()) {
            str.add(entity.getEditor());//编辑
        }
        //if (!entity.getDescription().equals(null)) {
        if (entity != null && entity.getDescription() != null && !entity.getDescription().isEmpty()) {
            str.add(entity.getDescription());//描述
        }
        if(contentParamters.getCategoryExtendDataList()!=null){
            for (ExtendData obj : contentParamters.getCategoryExtendDataList()) {//扩展字段
                str.add(obj.getValue());
            }
        }
        SensitivewordFilter filter = new SensitivewordFilter();//过滤词工具类对象
        String sb="";//拼接字符串，用于前台提示用户具体包含哪些关键字，
        for (String string : str) {//要过滤字段的集合，取出逐一过滤
        Set<String> set = filter.getSensitiveWord(string, 1);//要过滤的字段传到工具类中去过滤
            if(!set.toString().equals("[]")){
                sb+=set+",";
            }
        }
        if(!sb.equals("")){
                sb = sb.substring(0,sb.length()-1);//去掉最后多出来的逗号。
        }
        m.put("data", sb);    
        return m;
    }

3、关键字过滤工具类1

package com.publiccms.common.tools;

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

/**

* @Author shenWB

* @Date 2019/6/27 15:12

* @Version 1.0

**/
public class SensitivewordFilter {
    @SuppressWarnings("rawtypes")
    private Map sensitiveWordMap = null;
    public static int minMatchTYpe = 1;      //最小匹配规则
    public static int maxMatchType = 2;      //最大匹配规则    
    /**
     * 构造函数，初始化敏感词库
     */
    public SensitivewordFilter(){
        sensitiveWordMap = new SensitiveWordInit().initKeyWord();
    }   
    /**
     * 判断文字是否包含敏感字符
     * @param txt  文字
     * @param matchType  匹配规则 1：最小匹配规则，2：最大匹配规则
     * @return 若包含返回true，否则返回false
     */
    public boolean isContaintSensitiveWord(String txt,int matchType){
        boolean flag = false;
        for(int i = 0 ; i < txt.length() ; i++){
            int matchFlag = this.CheckSensitiveWord(txt, i, matchType); //判断是否包含敏感字符
            if(matchFlag > 0){    //大于0存在，返回true
                flag = true;
            }
        }
        return flag;
    }    
    /**
     * 获取文字中的敏感词
     * @param txt 文字
     * @param matchType 匹配规则&nbsp;1：最小匹配规则，2：最大匹配规则
     * @return
     */
    public Set<String> getSensitiveWord(String txt , int matchType){
        Set<String> sensitiveWordList = new HashSet<String>();        
        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
     * @param matchType
     * @param replaceChar 替换字符，默认*
     */
    public String replaceSensitiveWord(String txt,int matchType,String replaceChar){
        String resultTxt = txt;
        Set<String> set = getSensitiveWord(txt, matchType);     //获取所有的敏感词
        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;
    }    
    /**
     * 获取替换字符串
     * @param replaceChar
     * @param length
     * @return
     */
    private String getReplaceChars(String replaceChar,int length){
        String resultReplace = replaceChar;
        for(int i = 1 ; i < length ; i++){
            resultReplace += replaceChar;
        } 
        return resultReplace;
    }   
    /**
     * 检查文字中是否包含敏感字符，检查规则如下
     * @param txt
     * @param beginIndex
     * @param matchType
     * @return，如果存在，则返回敏感词字符的长度，不存在返回0
     */
    @SuppressWarnings({ "rawtypes"})
    public int CheckSensitiveWord(String txt,int beginIndex,int matchType){
        boolean  flag = false;    //敏感词结束标识位：用于敏感词只有1位的情况
        int matchFlag = 0;     //匹配标识数默认为0
        char word = 0;
        Map nowMap = sensitiveWordMap;
        for(int i = beginIndex; i < txt.length() ; i++){
            word = txt.charAt(i);
            nowMap = (Map) nowMap.get(word);     //获取指定key
            if(nowMap != null){     //存在，则判断是否为最后一个
                matchFlag++;     //找到相应key，匹配标识+1 
                if("1".equals(nowMap.get("isEnd"))){       //如果为最后一个匹配规则,结束循环，返回匹配标识数
                    flag = true;       //结束标志位为true   
                    if(SensitivewordFilter.minMatchTYpe == matchType){    //最小规则，直接返回,最大规则还需继续查找
                        break;
                    }
                }
            }
            else{     //不存在，直接返回
                break;
            }
        }
        if(matchFlag < 2 || !flag){        //长度必须大于等于1，为词 
            matchFlag = 0;
        }
        return matchFlag;
    }

//此处可写main测试

//        public static void main(String[] args) {
//        SensitivewordFilter filter = new SensitivewordFilter();
//        System.out.println("敏感词的数量：" + filter.sensitiveWordMap.size());

//        String string = "滴滴达 滴滴达 滴滴滴达,你是一个傻逼呀";
//        System.out.println("待检测语句字数：" + string.length());
//        long beginTime = System.currentTimeMillis();
//        Set<String> set = filter.getSensitiveWord(string, 1);
//        long endTime = System.currentTimeMillis();
//        System.out.println("语句中包含敏感词的个数为：" + set.size() + "。包含：" + set);
//        System.out.println("总共消耗时间为：" + (endTime - beginTime));
//        System.out.println(string);

}

4、关键字过滤工具2， 初始化敏感词库

package com.publiccms.common.tools;

import com.publiccms.logic.component.site.SiteComponent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.*;

/**

* @Author shenWB

* @Date 2019/6/27 16:36

* @Version 1.0

* 初始化敏感词库，将敏感词加入到HashMap中

**/
@Component
public class SensitiveWordInit {
    @Autowired
    private SiteComponent siteComponent;
    private static SensitiveWordInit sensitiveWordInit;
    @PostConstruct
    public void init(){
        sensitiveWordInit = this;
        sensitiveWordInit.siteComponent = this.siteComponent;
    }
    private String ENCODING = "UTF-8";    //指定字符编码    
    @SuppressWarnings("rawtypes")
    public HashMap sensitiveWordMap;    
    public SensitiveWordInit(){
        super();
    }
    @SuppressWarnings("rawtypes")
    public Map initKeyWord(){
        try {
            //读取敏感词库
            Set<String> keyWordSet = readSensitiveWordFile();
            //将敏感词库加入到HashMap中
            addSensitiveWordToHashMap(keyWordSet);
            //spring获取application，然后application.setAttribute("sensitiveWordMap",sensitiveWordMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sensitiveWordMap;
    }

    /**
     * 读取敏感词库，将敏感词放入HashSet中，构建一个DFA算法模型
     * @param keyWordSet  敏感词库
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    private void addSensitiveWordToHashMap(Set<String> keyWordSet) {
        sensitiveWordMap = new HashMap(keyWordSet.size());     //初始化敏感词容器，减少扩容操作
        String key = null;  
        Map nowMap = null;
        Map<String, String> newWorMap = null;
        //迭代keyWordSet
        Iterator<String> iterator = keyWordSet.iterator();
        while(iterator.hasNext()){
            key = iterator.next();    //关键字
            nowMap = sensitiveWordMap;
            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，因为他不是最后一个
                    newWorMap = new HashMap<String,String>();
                    newWorMap.put("isEnd", "0");     //不是最后一个
                    nowMap.put(keyChar, newWorMap);
                    nowMap = newWorMap;
                }                
                if(i == key.length() - 1){
                    nowMap.put("isEnd", "1");    //最后一个
                }
            }
        }
    }

    /**
     * 读取敏感词库中的内容，将内容添加到set集合中
     * @return
     * @throws Exception 
     */
    @SuppressWarnings("resource")
    private Set<String> readSensitiveWordFile() throws Exception{
        String str = sensitiveWordInit.siteComponent.getWebTemplateFilePath();
        String[] arr =str.split("/");
        String filepath = arr[0]+ File.separator +"sensitive"+ File.separator+"vocabulary.txt";
        System.out.println(filepath);
        Set<String> set = null;
        File file = new File(filepath);
//        File file = new File("D:\\SensitiveWord.txt");    //读取文件
        if(!file.exists()) {
            if(!file.getParentFile().exists())file.getParentFile().mkdirs();
            file.createNewFile();
        }
        InputStreamReader read = new InputStreamReader(new FileInputStream(file),ENCODING);
        try {
            if(file.isFile() && file.exists()){      //文件流是否存在
                set = new HashSet<String>();
                BufferedReader bufferedReader = new BufferedReader(read);
                String txt = null;
                while((txt = bufferedReader.readLine()) != null){    //读取文件，将文件内容放入到set中
                    set.add(txt);
                }
            }
            else{         //不存在抛出异常信息
                throw new Exception("敏感词库文件不存在");
            }
        } catch (Exception e) {
            throw e;
        }finally{
            read.close();     //关闭文件流
        }
        return set;
    }
}

到此就已经oj8k了