SpringBoot過濾敏感詞的兩種實現(xiàn)方式
更新時間：2024年06月11日 10:25:10 作者：甜鯨魚
Spring Boot本身并不直接提供過濾敏感詞的功能,但你可以使用第三方庫或者自定義過濾器來實現(xiàn)這個需求,所以本文給大家介紹了SpringBoot過濾敏感詞的兩種實現(xiàn)方式,感興趣的朋友可以參考下
項目場景
基于 Spring Boot 的論壇系統(tǒng)：用戶發(fā)布的內容需進行敏感詞過濾。
前置知識
前綴樹
- Q：前綴樹和普通N叉樹的區(qū)別？
- A：前綴樹（Trie，也稱字典樹、單詞查找樹或鍵樹）。
- 設計目的：
- 前綴樹：專門設計用于高效地存儲和檢索字符串集合中的鍵（字符串）。它的結構允許快速的查找、插入和刪除操作，特別適合于字符串前綴匹配，如自動補全、拼寫檢查、敏感詞過濾等場景。
- 普通N叉樹：是一種更通用的樹形數(shù)據(jù)結構，其中每個節(jié)點可以有任意數(shù)量（包括零）的子節(jié)點，最多可達N個。它沒有特定于字符串處理的特性，廣泛應用于各種需要多路分支的數(shù)據(jù)結構場景，如文件系統(tǒng)的目錄結構、表達式樹等。
- 節(jié)點結構：
- 前綴樹：每個節(jié)點通常包含一個字符和一個映射到其子節(jié)點的字符到節(jié)點的映射（如HashMap或數(shù)組）。根節(jié)點通常不表示任何字符，而從根到任意葉節(jié)點的路徑上的字符序列組成一個字符串，葉節(jié)點或標記為關鍵詞結束的節(jié)點代表一個完整的字符串。
- 普通N叉樹：節(jié)點可能包含數(shù)據(jù)以及指向其子節(jié)點的指針數(shù)組或列表，但這些子節(jié)點之間的關系不一定有特定的字符關聯(lián)，節(jié)點的數(shù)據(jù)結構和含義更多樣。
- 查找效率：
- 前綴樹：由于其特殊的結構設計，前綴樹支持高效的前綴匹配，可以在O(L)時間內（L為關鍵詞長度）查找到所有具有相同前綴的字符串，或者確定某個字符串是否在集合中。
- 普通N叉樹：查找效率依賴于樹的具體形態(tài)和查找算法，一般情況下不如前綴樹在字符串前綴匹配上的效率高。
- 空間利用率：
- 前綴樹：可能會有較高的空間消耗，因為它存儲了所有字符串的公共前綴，特別是當存儲的字符串有很多相似前綴時。
- 普通N叉樹：空間使用更加靈活，取決于樹的形狀，但通常不會為了存儲前綴信息而額外消耗空間。
- 設計目的：
總之，前綴樹是一種針對字符串處理優(yōu)化的特殊N叉樹，強調了字符串前綴的高效存儲和查詢，而普通N叉樹則是一種更為通用的結構，適用于多種類型的多路分支數(shù)據(jù)組織。
實現(xiàn)方式
解決方案一：讀取敏感詞文件生成前綴樹+構建敏感詞過濾器
前綴樹
- 名稱：Trie 、字典樹、查找樹
- 特點：查找效率高，消耗內存大
- 應用：字符串檢索、詞頻統(tǒng)計、字符串排序等
敏感詞過濾器
- 定義前綴樹
- 根據(jù)敏感詞，初始化前綴樹
- 編寫過濾敏感詞的方法
1. 導入敏感詞文件 src/main/resources/sensitive_words.txt
此處為示例文件內容。
元 購物車 fuck abc bf be
2. 構建敏感詞過濾器 SensitiveFilter
package com.example.filter;
import com.example.constant.SensitiveConstant;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.CharUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
/**
* 敏感詞過濾器
*/
@Slf4j
@Component
public class SensitiveFilter {
// 創(chuàng)建前綴樹的根節(jié)點
private final TrieNode rootNode = new TrieNode();
/**
* 初始化，讀取敏感詞
*/
@PostConstruct // 確保在Bean初始化后執(zhí)行
public void init() {
// 1. 從類路徑加載敏感詞文件: 使用文件存儲敏感詞庫可以直接進行一次性讀取和處理，無需依賴數(shù)據(jù)庫系統(tǒng)，并且保證離線可用。
try (InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(SensitiveConstant.SENSITIVE_WORDS_FILE);
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
// Java 7及以后的版本中，引入了一項稱為"try-with-resources"的新特性，它允許自動管理資源，確保在try語句塊執(zhí)行完畢后，不論是否發(fā)生異常，都會正確關閉或釋放資源
) {
// 2. 逐行讀取敏感詞并加入到前綴樹中
String keyword;
while ((keyword = bufferedReader.readLine()) != null) {
this.addKeyWord(keyword);
}
} catch (IOException ex) {
log.error("敏感詞文件讀取失敗: " + ex.getMessage());
}
}
/**
* 將敏感詞添加到前綴樹中
* @param keyword 待添加的敏感詞
*/
private void addKeyWord(String keyword) {
// 1. 初始化操作，將當前處理節(jié)點設為根節(jié)點
TrieNode tempNode = rootNode;
// 2. 將待添加的敏感詞字符串轉換為字符數(shù)組以便遍歷
char[] chars = keyword.toCharArray();
// 3. 遍歷字符數(shù)組，逐個字符構建前綴樹
for (int i = 0; i < chars.length; i++) {
// 3.1. 從當前處理節(jié)點的子節(jié)點Map中獲取當前字符對應的節(jié)點
TrieNode childrenNode = tempNode.getChildrenNode(chars[i]);
// 3.1.1 若當前字符沒有對應的節(jié)點，則創(chuàng)建一個新節(jié)點，并放入當前處理節(jié)點的子節(jié)點Map中
if (childrenNode == null) {
childrenNode = new TrieNode();
tempNode.setChildrenNode(chars[i], childrenNode);
}
// 3.2. 若當前字符為敏感詞字符串的最后一個字符，則標記當前字符的對應節(jié)點為敏感詞的結尾節(jié)點
if (i == chars.length - 1) {
childrenNode.setKeywordEnd(true);
}
// 3.3. 移動到下一層，使當前字符對應的節(jié)點成為新的當前處理節(jié)點，繼續(xù)構建或遍歷過程
tempNode = childrenNode;
}
}
/**
* 過濾文本，移除或替換其中的敏感詞，并返回處理后的文本
* @param text 待過濾的文本
* @return 過濾后的文本
*/
public String filter(String text) {
// 1. 檢查輸入文本是否為空或僅包含空白字符，如果是，則直接返回null，表示無內容無需過濾
if (StringUtils.isBlank(text)) {
return null;
}
// 2. 初始化變量
TrieNode tempNode = rootNode; // 2.1. 初始化為前綴樹的根節(jié)點，用于遍歷查找。
int begin = 0, end = 0; // 2.2. 分別用于標記待檢查文本區(qū)間的起始和結束位置
StringBuilder result = new StringBuilder(); // 2.3. 累積過濾后的文本
// 3. 遍歷整個文本進行過濾處理
while (begin < text.length()) {
char c = text.charAt(end);
// 3.1. 遇到符號字符
if (isSymbol(c)) {
// 3.1.1. 如果當前處于根節(jié)點，即沒有匹配到任何敏感詞的開始，直接保留符號，并移動begin
if (tempNode == rootNode) {
result.append(c);
begin++;
}
// 3.1.2. 跳過當前符號，并繼續(xù)檢查下一個字符
end++;
continue;
}
// 3.2. 檢查當前字符區(qū)間text[begin...end]是否是某個敏感詞的一部分
tempNode = tempNode.getChildrenNode(c);
// 3.2.1. 如果當前字符沒有對應的子節(jié)點，即text[begin...end]不是敏感詞的組成部分
if (tempNode == null) {
result.append(text.charAt(begin)); // 3.2.1.1. 保存begin位置的字符到結果
end = ++begin; // 3.2.1.2. 移動begin和end指針，準備檢查下一個可能的敏感詞 begin++; end = begin;
tempNode = rootNode; // 3.2.1.3. 重置tempNode為根節(jié)點準備下一輪匹配
}
// 3.2.2. 如果當前字符路徑已到達一個敏感詞的結尾，即text[begin...end]是敏感詞
else if (tempNode.isKeywordEnd()) {
result.append(StringUtils.repeat(SensitiveConstant.REPLACEMENT, end - begin + 1)); // 3.2.2.1. 替換敏感詞區(qū)間
begin = ++end; // 3.2.2.2. 移動begin和end指針，準備檢查下一個可能的敏感詞 end++; begin = end;
tempNode = rootNode; // 3.2.2.3. 重置tempNode為根節(jié)點準備下一輪匹配
}
// 3.2.3. 如果當前字符區(qū)間text[begin...end]是潛在敏感詞的一部分但不是結尾，繼續(xù)匹配下一個字符
else {
// 3.2.3.1. 檢查下一個字符是否存在，存在則移動end指針；否則，回退begin到當前位置，準備重新匹配
if (end < text.length() - 1) {
end++;
} else {
end = begin;
}
}
}
// 4. 將剩余未檢查的文本（若有）添加到結果中
result.append(text.substring(begin));
// 5. 返回過濾后的文本
return result.toString();
}
/**
* 判斷字符是否為符號字符
* @param character 待判斷的字符
* @return true表示是符號字符，需要跳過；false表示不是符號字符，不跳過
*/
private boolean isSymbol(Character character) {
// 0x2E80~0x9FFF是東亞文字: 判斷字符是否不屬于ASCII字母數(shù)字且不在東亞文字范圍內
return !CharUtils.isAsciiAlphanumeric(character) && (character < 0x2E80 || character > 0x9FFF);
}
/**
* 內部類，定義前綴樹的節(jié)點
*/
private static class TrieNode {
private boolean isKeywordEnd = false; // 當前節(jié)點是否為敏感詞的末尾節(jié)點
private final Map<Character, TrieNode> childrenNode = new HashMap<>(); // 當前節(jié)點的子節(jié)點
// Getter和Setter方法
public boolean isKeywordEnd() {
return isKeywordEnd;
}
public void setKeywordEnd(boolean keywordEnd) {
isKeywordEnd = keywordEnd;
}
public TrieNode getChildrenNode(Character c) {
return childrenNode.get(c);
}
public void setChildrenNode(Character c, TrieNode node) {
childrenNode.put(c, node);
}
}
}
這里我把敏感詞過濾器的相關常量都寫到一個常量類里了，也可以直接寫在過濾器里。
package com.example.constant;
/**
* 敏感詞過濾器的相關常量
*/
public class SensitiveConstant {
/**
* 敏感詞文件名稱
*/
public static final String SENSITIVE_WORDS_FILE = "sensitive_words.txt";
/**
* 用于替換敏感詞的字符
*/
public static final Character REPLACEMENT = '*';
}
3. 測試與使用
創(chuàng)建一個測試類測一下就行。
package com.example.filter;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class SensitiveFilterTest {
@Autowired
private SensitiveFilter sensitiveFilter;
@Test
void filter() {
String result = sensitiveFilter.filter("accfuckxx元bitch購物車bitchjwbc");
System.out.println(result);
}
}
運行結果：
acc****xx*bitch***bitchjwbc
可以實現(xiàn)過濾，但是完全基于敏感詞文件內容，需要自行完善文件。也許可以結合正則表達式擴展？不是很靈活，沒研究過了。
解決方案二：使用第三方插件 houbb/sensitive-word（推薦）
houbb/sensitive-word項目源碼：https://github.com/houbb/sensitive-word
1. 添加依賴
<dependency>
<groupId>com.github.houbb</groupId>
<artifactId>sensitive-word</artifactId>
<version>0.17.0</version>
</dependency>
2. 測試與使用（使用默認過濾策略）
package com.example.filter;
import com.github.houbb.sensitive.word.core.SensitiveWordHelper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class SensitiveFilterTest {
@Autowired
private SensitiveFilter sensitiveFilter;
@Test
void filter() {
String result = sensitiveFilter.filter("accfuckxx元bitch購物車bitchjwbc");
System.out.println(result);
System.out.println("-------------------------------");
result = SensitiveWordHelper.replace("accfuckxx元bitch購物車bitchjwbc");
System.out.println(result);
result = SensitiveWordHelper.replace("??c? the bad words");
System.out.println(result);
result = SensitiveWordHelper.replace("???f?u??c?? the bad words");
System.out.println(result);
result = SensitiveWordHelper.replace("fffuuck the bad words");
System.out.println(result);
}
}
運行結果：
acc****xx*bitch***bitchjwbc
-------------------------------
acc****xx元bitch購物車bitchjwbc
**** the bad words
???f?u??c?? the bad words
fffuuck the bad words
可以實現(xiàn)基礎過濾。比讀取文件更方便。
（忽略掉這里的“元”和“購物車”。只是為了文章過審把一些很offensive的詞換成了隨便寫的詞嗯。）
如果要設置更多需要過濾的內容，可以參考以下步驟。
3. 構建配置類SensitiveWordConfig（使用自定義過濾策略）
自己按照需求調一下就好。
package com.example.config;
import com.github.houbb.sensitive.word.bs.SensitiveWordBs;
import com.github.houbb.sensitive.word.support.ignore.SensitiveWordCharIgnores;
import com.github.houbb.sensitive.word.support.resultcondition.WordResultConditions;
import com.github.houbb.sensitive.word.support.tag.WordTags;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* 配置類，用于設置敏感詞過濾器的自定義過濾策略
* 更多配置見 https://github.com/houbb/sensitive-word
*/
@Configuration
public class SensitiveWordConfig {
/**
* 初始化引導類
* @return 初始化引導類
* @since 1.0.0
*/
@Bean
public SensitiveWordBs sensitiveWordBs() {
SensitiveWordBs wordBs = SensitiveWordBs.newInstance()
.ignoreCase(true) // 忽略大小寫，默認值為true
.ignoreWidth(true) // 忽略半角圓角，默認值為true
.ignoreNumStyle(true) // 忽略數(shù)字的寫法，默認值為true
.ignoreChineseStyle(true) // 忽略中文的書寫格式，默認值為true
.ignoreEnglishStyle(true) // 忽略英文的書寫格式，默認值為true
.ignoreRepeat(false) // 忽略重復詞，默認值為false
.enableNumCheck(false) // 是否啟用數(shù)字檢測，默認值為false
.enableEmailCheck(false) // 是有啟用郵箱檢測，默認值為false
.enableUrlCheck(false) // 是否啟用鏈接檢測，默認值為false
.enableIpv4Check(false) // 是否啟用IPv4檢測，默認值為false
.enableWordCheck(true) // 是否啟用敏感單詞檢測，默認值為true
.numCheckLen(8) // 數(shù)字檢測，自定義指定長度，默認值為8
.wordTag(WordTags.none()) // 詞對應的標簽，默認值為none
.charIgnore(SensitiveWordCharIgnores.defaults()) // 忽略的字符，默認值為none
.wordResultCondition(WordResultConditions.alwaysTrue()) // 針對匹配的敏感詞額外加工，比如可以限制英文單詞必須全匹配，默認恒為真
.init();
return wordBs;
}
}
4. 測試與使用（使用自定義過濾策略）
在剛剛的配置類中已經(jīng)啟用了數(shù)字檢測。
.enableNumCheck(true) // 是否啟用數(shù)字檢測，默認值為false
測一下。
package com.example.filter;
import com.github.houbb.sensitive.word.bs.SensitiveWordBs;
import com.github.houbb.sensitive.word.core.SensitiveWordHelper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class SensitiveFilterTest {
...
@Autowired
private SensitiveWordBs sensitiveWordBs;
...
@Test
void test() {
String result = sensitiveWordBs.replace("accfuckxx元bitch購物車bitchjwbc");
System.out.println(result);
result = sensitiveWordBs.replace("??c? the bad words");
System.out.println(result);
result = sensitiveWordBs.replace("???f?u??c?? the bad words");
System.out.println(result);
result = sensitiveWordBs.replace("fffuuck the bad words");
System.out.println(result);
result = sensitiveWordBs.replace("12345678dwnoxcw");
System.out.println(result);
result = sensitiveWordBs.replace("123456789dwnoxcw");
System.out.println(result);
result = sensitiveWordBs.replace("一二三四五六七八九dwnoxcw");
System.out.println(result);
result = sensitiveWordBs.replace("這個是我的微信：9?二肆??③⑸⒋?㈤五");
System.out.println(result);
}
}
運行結果：
acc****xx元bitch購物車bitchjwbc
**** the bad words
*********** the bad words
******* the bad words
********dwnoxcw
*********dwnoxcw
*********dwnoxcw
這個是我的微信：************
就很好用了。
（忽略掉這里的“元”和“購物車”。只是為了文章過審把一些很offensive的詞換成了隨便寫的詞嗯。）
兩種實現(xiàn)方式的對比
- 自行構建前綴樹過濾器：
- 優(yōu)勢：高度定制，易于理解與維護，無外部依賴。
- 劣勢：開發(fā)耗時，需優(yōu)化性能，學習成本。
- 使用第三方開源項目：
- 優(yōu)勢：快速集成，功能成熟，社區(qū)支持。
- 劣勢：依賴管理，安全風險，定制受限。
根據(jù)項目需求緊迫性、定制化需求及團隊技術背景綜合選擇。簡單需求或有定制化要求傾向自建；追求快速、功能全面則推薦使用現(xiàn)成開源方案。
以上就是SpringBoot過濾敏感詞的兩種實現(xiàn)方式的詳細內容，更多關于SpringBoot過濾敏感詞的資料請關注腳本之家其它相關文章！
相關文章
這篇文章主要介紹了Spring Boot maven框架搭建教程圖解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-07-07
這篇文章主要介紹了在mybatis 中使用if else 進行判斷的操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-02-02
java中BeanUtils.copyProperties的用法(超詳細)
本文介紹了BeanUtils.copyProperties()方法的使用,包括其功能、用法、注意事項和示例代碼,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2023-08-08
Java Class.forName()用法和newInstance()方法原理解析
這篇文章主要介紹了Java Class.forName()用法和newInstance()方法原理解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-08-08
容器組件（Container）可以理解為在Android中的RelativeLayout或LinearLayout等，在其中你可以放置你想布局的元素控件，從而形成最終你想要的頁面布局。這篇文章主要介紹了Flutter實現(xiàn)容器組件、圖片組件 的代碼,需要的朋友可以參考下2019-07-07
java 數(shù)據(jù)結構 冒泡排序實現(xiàn)代碼
這篇文章主要介紹了java 數(shù)據(jù)結構 冒泡排序的相關資料，并附實例代碼，有需要的小伙伴可以參考下2016-09-09
這篇文章主要介紹了Java如何獲取接口所有的實現(xiàn)類，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-01-01
Spring Boot中使用JSR-303實現(xiàn)請求參數(shù)校驗
這篇文章主要介紹了Spring Boot中使用JSR-303實現(xiàn)請求參數(shù)校驗,JSR-303校驗我們一般都是對Java的實體類對象進行校驗,主要檢驗JSR-303是Java中的一個規(guī)范,用于實現(xiàn)請求參數(shù)校驗在我們的實體類對象的屬性上,感興趣的朋友跟隨小編一起看看吧2023-10-10
java前后端使用ajax數(shù)據(jù)交互問題(簡單demo)
這篇文章主要介紹了java前后端使用ajax數(shù)據(jù)交互問題(簡單demo)，具有很好的參考價值，希望對大家有所幫助。2023-06-06
Spring容器初始化擴展點之ApplicationContextInitializer詳解
ApplicationContextInitializer是Spring框架提供的一個接口,用于在Spring應用上下文刷新之前對其進行自定義初始化,本文介紹Spring容器初始化擴展點之ApplicationContextInitializer,感興趣的朋友一起看看吧2025-02-02