Java怎么实现一个敏感词过滤？有哪些方法？怎么优化？

已于 2025-06-30 13:21:53 修改
阅读量2.1k 收藏 32
点赞数 15
CC 4.0 BY-SA版权
文章标签： java c# 开发语言
于 2025-05-02 15:03:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gwndjsh/article/details/147652868

敏感词过滤是非常常见的一种手段，避免出现一些违规词汇。

Java实现敏感词过滤的完整方案与优化策略

敏感词过滤是内容安全的重要组成部分，以下是Java中实现敏感词过滤的多种方法及其优化方案。

一、基础实现方法

1. 简单字符串匹配（适合小规模场景）

public class SimpleFilter {
    private static final Set<String> sensitiveWords = new HashSet<>(Arrays.asList("敏感词1", "敏感词2"));
    
    public static String filter(String text) {
        for (String word : sensitiveWords) {
            if (text.contains(word)) {
                text = text.replace(word, "***");
            }
        }
        return text;
    }
}

缺点：时间复杂度O(n*m)，性能差，无法处理变形词，拼音等扩展功能。

2. 正则表达式匹配

public class RegexFilter {
    private static final String pattern = "敏感词1|敏感词2|敏感词3";
    
    public static String filter(String text) {
        return text.replaceAll(pattern, "***");
    }
}

缺点：正则构建时间长，敏感词多时性能下降明显。敏感词有些场景还是可以考虑的，可以做一个分片处理。

二、高效实现方案

1. Trie树（前缀树）实现

class TrieNode {
    private Map<Character, TrieNode> children = new HashMap<>();
    private boolean isEnd;
    
    // 添加子节点方法
    // 查找子节点方法
    // getter/setter
}

public class TrieFilter {
    private TrieNode root = new TrieNode();
    
    // 构建Trie树
    public void addWord(String word) {
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            node = node.getChildren().computeIfAbsent(c, k -> new TrieNode());
        }
        node.setEnd(true);
    }
    
    // 过滤方法
    public String filter(String text) {
        StringBuilder result = new StringBuilder();
        TrieNode temp;
        for (int i = 0; i < text.length(); i++) {
            temp = root;
            int j = i;
            while (j < text.length() && temp.getChildren().containsKey(text.charAt(j))) {
                temp = temp.getChildren().get(text.charAt(j));
                j++;
                if (temp.isEnd()) {
                    // 发现敏感词，替换为*
                    result.append("*".repeat(j - i));
                    i = j - 1;
                    break;
                }
            }
            if (i >= text.length()) break;
            if (!temp.isEnd()) {
                result.append(text.charAt(i));
            }
        }
        return result.toString();
    }
}

其实也就是一种树形有向图（无环）结构。是DFA的一种特例（树形结构，无失败转移）。

优点：时间复杂度O(n)，适合大规模敏感词库

前缀树的优点是，插入和查询效率高，特别是在敏感词有共同前缀的情况下（如ab、abc、abcd）。而且他的空间效率较高，因为是共享公共前缀的。

但是他也有缺点，一方面是构建树的初期成本较高。另外对于没有共同前缀的敏感词，效率提升不明显。

所以，前缀树适合做高效的字典查找、根据前缀自动补全、利用前缀匹配进行快速路由等场景。

2. DFA（确定性有限自动机）算法

DFA是Deterministic Finite Automaton的缩写，翻译过来叫确定有限自动机，DFA算法是一种高效的文本匹配算法，特别适合于敏感词过滤。

DFA由一组状态组成，以及在这些状态之间的转换，这些转换由输入字符串驱动。每个状态都知道下一个字符的到来应该转移到哪个状态。如果输入字符串结束时，DFA处于接受状态，则输入字符串被认为是匹配的。

其实就是一种一般有向图（可能含环，如自环）结构，满足一条路径则算匹配成功，就算一个敏感词了。

有三个参数组成

  1. 节点（States）：表示自动机的状态，包括：

    • 初始状态（起点）

    • 中间状态

    • 终止状态（敏感词匹配成功的状态）

  2. 边（Transitions）：表示状态之间的转移条件，每个边对应一个输入字符（如字母、汉字）。

  3. 终止状态：某些节点被标记为终止状态，代表从初始状态到该状态的路径对应一个完整的敏感词。

具体过程就像下面这样

  • 输入字符 c，检查当前状态是否有 c 对应的边。

  • 如果有，转移到下一个状态；如果没有，匹配失败。

  • 如果最终停在终止状态，则输入文本包含敏感词。

  • 否则，不包含。

public class DFAFilter {
    private Map<String, Object> sensitiveWordMap = new HashMap<>();
    
    // 构建敏感词库
    public void init(Set<String> words) {
        for (String word : words) {
            Map<String, Object> nowMap = sensitiveWordMap;
            for (int i = 0; i < word.length(); i++) {
                String key = String.valueOf(word.charAt(i));
                Object tempMap = nowMap.get(key);
                if (tempMap == null) {
                    Map<String, Object> newMap = new HashMap<>();
                    newMap.put("isEnd", "0");
                    nowMap.put(key, newMap);
                    nowMap = newMap;
                } else {
                    nowMap = (Map<String, Object>) tempMap;
                }
                if (i == word.length() - 1) {
                    nowMap.put("isEnd", "1");
                }
            }
        }
    }
    
    // 过滤方法
    public String filter(String text) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < text.length(); i++) {
            int length = checkWord(text, i);
            if (length > 0) {
                result.append("*".repeat(length));
                i += length - 1;
            } else {
                result.append(text.charAt(i));
            }
        }
        return result.toString();
    }
    
    private int checkWord(String text, int beginIndex) {
        boolean flag = false;
        int matchLength = 0;
        Map<String, Object> tempMap = sensitiveWordMap;
        for (int i = beginIndex; i < text.length(); i++) {
            String word = String.valueOf(text.charAt(i));
            tempMap = (Map<String, Object>) tempMap.get(word);
            if (tempMap == null) break;
            matchLength++;
            if ("1".equals(tempMap.get("isEnd"))) {
                flag = true;
                break;
            }
        }
        return flag ? matchLength : 0;
    }
}

  1. 内存优化：

    • 双数组Trie：压缩状态存储，减少内存占用。

    • 共享前缀：DFA合并相同前缀的状态（如 "敏感词" 和 "敏感内容" 共享 "敏感" 路径）。

  2. 匹配加速：

    • AC自动机：在DFA基础上添加失败指针，支持多模式匹配（类似KMP算法）。

    • 批处理：对长文本分块并行检测。

  3. 工程实践：

    • 热更新：动态加载敏感词库，无需重启服务。

    • 多级过滤：先布隆过滤器快速排除无敏感词文本，再走DFA精确匹配。

给大家推荐一个基于 DFA 算法实现的高性能 java 敏感词过滤工具框架——sensitive-word

三、高级优化方案

1. 多模式匹配算法优化

AC自动机（Aho-Corasick算法）
public class ACFilter {
    private ACTrie trie;
    
    public void init(Set<String> words) {
        trie = new ACTrie();
        for (String word : words) {
            trie.insert(word);
        }
        trie.buildFailureLinks();
    }
    
    public String filter(String text) {
        Set<ACTrie.Match> matches = trie.parseText(text);
        char[] chars = text.toCharArray();
        for (ACTrie.Match match : matches) {
            Arrays.fill(chars, match.getStart(), match.getEnd() + 1, '*');
        }
        return new String(chars);
    }
}

优点：一次扫描匹配所有模式串，时间复杂度O(n)

2. 基于布隆过滤器的预处理

public class BloomFilterPreprocessor {
    private BloomFilter<String> bloomFilter;
    private Set<String> exactMatchSet;
    
    public void init(Set<String> words) {
        bloomFilter = BloomFilter.create(Funnels.stringFunnel(), words.size(), 0.01);
        exactMatchSet = new HashSet<>(words);
        words.forEach(bloomFilter::put);
    }
    
    public boolean mightContain(String text) {
        return bloomFilter.mightContain(text);
    }
    
    public boolean exactMatch(String text) {
        return exactMatchSet.contains(text);
    }
}

用途：先快速判断是否可能包含敏感词，再进行精确匹配

四、工程化实践方案

1. 敏感词库动态加载

public class DynamicWordFilter {
    private volatile Map<String, Object> wordMap;
    private ScheduledExecutorService executor;
    
    public void init() {
        loadWords();
        executor = Executors.newSingleThreadScheduledExecutor();
        executor.scheduleAtFixedRate(this::loadWords, 1, 1, TimeUnit.HOURS);
    }
    
    private void loadWords() {
        Map<String, Object> newMap = new HashMap<>();
        // 从数据库或文件加载敏感词
        Set<String> words = loadFromDB();
        // 构建DFA结构
        this.wordMap = buildDFA(words);
    }
}

2. 分布式敏感词过滤

public class DistributedFilter {
    private RedisTemplate<String, String> redisTemplate;
    
    public boolean isSensitive(String text) {
        // 使用Redis的Set结构存储敏感词
        return redisTemplate.opsForSet().isMember("sensitive:words", text);
    }
    
    public String filter(String text) {
        // 调用分布式过滤服务
        return restTemplate.postForObject("http://filter-service/filter", text, String.class);
    }
}

3：也可以考虑使用ElasticSearch做搜索引擎

为什么可以使用ES可以看看

【2025最新】为什么用ElasticSearch？和传统数据库MySQL与什么区别？-优快云博客

总的来说就是ES有强大的文本分析和查询能力来实现。以下是详细实现过程和方案：

具体实现方案
方案1：索引时敏感词标记（推荐）

步骤：

  1. 自定义分析器：

    PUT /sensitive_content_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "sensitive_filter_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "sensitive_word_filter"
          ]
        }
      },
      "filter": {
        "sensitive_word_filter": {
          "type": "stop",
          "stopwords": ["敏感词1", "敏感词2", "违法词"]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "content": {
        "type": "text",
        "analyzer": "sensitive_filter_analyzer",
        "fields": {
          "original": { 
            "type": "keyword" // 保留原始内容
          }
        }
      }
    }
  }
}

  2. 检测敏感词：

    GET /sensitive_content_index/_analyze
{
  "analyzer": "sensitive_filter_analyzer",
  "text": "这是一段包含敏感词1的文本"
}

  3. 输出：敏感词会被过滤掉，只返回普通词项

  4. 写入时自动标记：

    POST /sensitive_content_index/_doc
{
  "content": "这是需要检测的文本",
  "has_sensitive": false // 由pipeline更新
}

  5. 使用Ingest Pipeline自动检测：

    PUT _ingest/pipeline/sensitive_check_pipeline
{
  "processors": [
    {
      "script": {
        "source": """
          def sensitiveWords = ['敏感词1', '违禁词'];
          for (word in sensitiveWords) {
            if (ctx.content.contains(word)) {
              ctx.has_sensitive = true;
              ctx.sensitive_word = word;
              break;
            }
          }
        """
      }
    }
  ]
}

方案2：查询时敏感词过滤

使用Term查询检测：

GET /content_index/_search
{
  "query": {
    "bool": {
      "must_not": [
        { "terms": { "content": ["敏感词1", "违禁词"] }}
      ]
    }
  }
}

高亮显示敏感词：

GET /content_index/_search
{
  "query": {
    "match": { "content": "正常文本" }
  },
  "highlight": {
    "fields": {
      "content": {
        "highlight_query": {
          "terms": { "content": ["敏感词1", "违禁词"] }
        }
      }
    }
  }
}

方案3：结合机器学习（ES 7.15+）

  1. 训练敏感词分类模型：

    PUT _ml/trained_models/sensitive_words_classifier
{
  "input": {"field_names": ["text"]},
  "inference_config": {
    "text_classification": {
      "vocabulary": ["敏感词1", "变体词", "拼音词"]
    }
  }
}

  2. 部署推理处理器：

    PUT _ingest/pipeline/ml_sensitive_detection
{
  "processors": [
    {
      "inference": {
        "model_id": "sensitive_words_classifier",
        "field_map": { "content": "text" }
      }
    }
  ]
}

性能优化技巧

  1. 敏感词库存储优化：

    • 使用ES的Synonyms Token Filter管理同义词/变体词

    • 将敏感词库存储在单独索引中，定期更新

  2. 缓存加速：

    PUT /sensitive_words_cache
{
  "mappings": {
    "properties": {
      "word": { "type": "keyword" }
    }
  }
}

  3. 分布式检测：

    • 对大型文档分片处理

    • 使用_search_shardsAPI并行检测

五、性能优化技巧

  1. 内存优化：

    • 使用基本类型替代包装类

    • 压缩Trie树结构（Ternary Search Tree）

    • 对象复用减少GC压力

  2. 算法优化：

    • 对短文本使用快速失败策略

    • 实现多级过滤（先粗筛后精筛），

    • 并行化处理（Fork/Join框架）

  3. 预处理优化：

    • 文本归一化（全角转半角，繁体转简体）

    • 拼音转换处理（如"taobao"->"淘宝"）

    • 近音词/形近词处理

  4. 缓存优化：

    • 缓存常见文本的过滤结果

    • 使用Caffeine实现本地缓存

    • 布隆过滤器预判

六、完整生产级实现示例

public class ProductionWordFilter implements InitializingBean {
    private final TrieNode root = new TrieNode();
    private final List<String> wordSources;
    private final ScheduledExecutorService executor;
    
    public ProductionWordFilter(List<String> wordSources) {
        this.wordSources = wordSources;
        this.executor = Executors.newSingleThreadScheduledExecutor();
    }
    
    @Override
    public void afterPropertiesSet() {
        reload();
        executor.scheduleWithFixedDelay(this::reload, 1, 1, TimeUnit.HOURS);
    }
    
    public synchronized void reload() {
        TrieNode newRoot = new TrieNode();
        wordSources.stream()
                  .flatMap(source -> loadWords(source).stream())
                  .forEach(word -> addWord(newRoot, word));
        this.root = newRoot;
    }
    
    public FilterResult filter(String text) {
        StringBuilder result = new StringBuilder();
        Set<String> foundWords = new HashSet<>();
        int replacedCount = 0;
        
        for (int i = 0; i < text.length(); ) {
            MatchResult match = findNextMatch(text, i);
            if (match != null) {
                foundWords.add(match.getWord());
                result.append("*".repeat(match.getLength()));
                replacedCount++;
                i = match.getEndIndex();
            } else {
                result.append(text.charAt(i));
                i++;
            }
        }
        
        return new FilterResult(result.toString(), foundWords, replacedCount);
    }
    
    // 其他辅助方法...
}

七、评估指标

  1. 性能指标：

    • 吞吐量（QPS）

    • 平均延迟（ms）

    • 99线延迟（ms）

  2. 效果指标：

    • 召回率（漏判率）

    • 准确率（误判率）

    • 覆盖度（变形词识别率）

  3. 资源消耗：

    • 内存占用

    • CPU使用率

    • 网络IO（分布式场景）

八、扩展思考

  1. 中文分词集成：结合IK Analyzer等分词工具处理更复杂的语义

  2. 机器学习模型：使用NLP模型识别变体、谐音、拆字等高级变种

  3. 图片/语音过滤：扩展多媒体内容过滤能力

  4. 多语言支持：处理Unicode混淆和国际化敏感词

对于大多数Java应用，Trie树或DFA算法配合定期更新的词库已经能够满足需求。

java敏感词过滤
mchine_swift的博客
09-16 428
java敏感词过滤 敏感词：“美元”,“中国”,“北京大学”,“北大”,“南京大学” DFAUtils import java.util.HashMap; import java.util.LinkedList; import java.util.Map; public class DFAUtils { /** * 添加敏感词到算法树 */ public static void addSensitiveWord(String sensitiveWord) {
【Java】如何设计一个敏感词过滤系统？
alen101的博客
07-11 2946
AC自动机算法（Aho–Corasick算法）是一种字符串搜索算法，可以同时将目标串与所有模式串进行匹配，算法均摊情况下具有近似于线性的时间复杂度。AC自动机的匹配原理有两个核心概念：Trie字典树、Fail指针。下面以模式串集合{“she”, “he”, “shers”, “his”, “era”}为例，来介绍这两个概念。AC自动机算法启动时，需要将所有的模式串加载到内存中，构建成一个Trie字典树。
vivo 敏感词匹配系统的设计与实践
vivo互联网技术
12-06 824
本文从vivo内容审核的实际场景入手，对比了常用的敏感词匹配算法，介绍了谛听系统几个主要场景下的敏感词匹配实践方案。
使用springboot实现过滤敏感词功能
最新发布
kkddqq1121的博客
06-19 280
【代码】使用springboot实现过滤敏感词功能。
JAVA 敏感词过滤
06-17
JAVA 敏感词过滤
Java敏感词过滤
qq_40618664的博客
01-21 5826
方案一：使用String类的contains() contains()方法用于判断字符串中是否包含指定的字符或字符串。 public static void main(String[] args) { String a = "敏感词"; String b = "我的敏感词"; System.out.println(b.contains(a)); if (b.contains(a)) { System.out.pri
敏感词过滤 java
weixin_41677268的博客
11-02 2206
学习目标： 今天我们来学习一下，java 完成敏感词过滤。 完成思路： 1、 敏感词存入前缀树 前缀树： 名称：trie、字典树、查找树 特点：查找效率高、消耗内存大（也就是以空间换时间） 应用：字符串检索，词频统计、字符串串排序等。 敏感词过滤器怎么搞呢？ 定义前缀树 根据敏感词，初始化前缀树。 编写敏感词的方法 首先定义敏感词文本文档 将敏感词按顺序存入前缀树的数据结构 前缀树的数据结构如下： 本数据结构存放首先是结束标志。结束标志：其实就是说判断存放的节点值为每个敏感词的最后一个值
详细分析Java中的敏感词过滤（附Demo）
码农研究僧的博客
05-03 2590
自定义方法过滤敏感词，重在思路
java实现敏感词过滤（DFA算法）
weixin_34372728的博客
03-28 342
小Alan在最近的开发中遇到了敏感词过滤，便去网上查阅了很多敏感词过滤的资料，在这里也和大家分享一下自己的理解。 敏感词过滤应该是不用给大家过多的解释吧？讲白了就是你在项目中输入某些字（比如输入xxoo相关的文字时）时要能检 测出来，很多项目中都会有一个敏感词管理模块，在敏感词管理模块中你可以加入敏感词，然后根据加入的敏感词去过滤输 入内容中的敏感词并进行相应的处理，要么提示，要么高亮...
java利用DFA算法实现敏感词过滤功能
08-30
在本文中，我们将探讨如何使用DFA（有穷自动机）算法在Java中实现敏感词过滤功能。敏感词过滤在许多应用程序中都是必要的，例如社交媒体、论坛或博客平台，以防止用户发布不当或有害的内容。以下是对DFA算法及其在...
Java语言实现的敏感词过滤器
01-19
我们在开发系统或者应用的过程中，经常需要对用户提交的评论或者文章进行审核，对其中的敏感词进行校验或者过滤，本资源可以帮助各位小伙伴以一个简单的方式实现敏感词的过滤，代码精简易懂，可以应用在实际开发过程...
JAVA敏感词过滤
05-09
使用DFA状态机实现敏感词过滤。 使用Java实现
java敏感词过滤功能
04-20
在Java开发中，实现敏感词过滤功能是一项常见的需求，特别是在社交媒体...以上就是基于Java实现敏感词过滤功能的一些核心知识点。在实际开发中，还需要考虑到代码的可维护性、扩展性和安全性，以及对不同场景的适应性。
Java实现DFA算法敏感词过滤
imVainiycos的博客
03-02 8619
Java实现DFA算法敏感词过滤。 文章目录一. 应用场景二. 实现思路三. 源码实现 一. 应用场景 模拟非法词汇自动替换成*字符，且敏感词汇支持动态调整。 效果如下，若配置了敏感词：今天，则当用户在输入：今天，天气真不错。实际应该输出：** **，天气真不错 ** 二. 实现思路 使用MySQL作为敏感词库 使用DFA算法实现文字过滤 Q：什么是DFA？ DFA全称为：Deterministic Finite Automaton,即确定有穷自动机。其特征为：有一个有限状态集合和一些从一个状态通向.
【敏感词过滤】Java 敏感词过滤
m0_48296376的博客
09-22 846
将不同长度的敏感词放入map中
JAVA -敏感词过滤器 工具类SensitiveFilter
大漠孤烟
11-19 3139
1.添加敏感词过滤工具类 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.Serializable; import java.nio.charset.StandardCharsets; import java.util.Iterator; import java.util.NavigableSet; /** * 敏感词过滤器，以过滤速
Java过滤敏感词（String法/前缀树法）
qq_56610467的博客
06-24 867
两种代码对敏感词过滤，代码运行在SpringBoot项目下版本2.1.5,部分POM依赖。
Java实现敏感词过滤
让人生充满永动的势能
04-18 1609
1.读取敏感数据，构建DFA算法 package com.iris.nsonline.nsoweb.utils; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.util.HashMap; import java.util.HashS
Java实现的简易敏感词过滤方法
### 知识点三：Java实现敏感词过滤 在Java中实现敏感词过滤，一般需要两个主要的类：一个用于管理敏感词和构建DFA的类，另一个用于实际过滤文本的类。 #### 管理敏感词和构建DFA的类 这个类通常包含方法： - 加载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值