元
購物車
fuck
abc
bf
be

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é)點(diǎn)
    private final TrieNode rootNode = new TrieNode();

    /**
     * 初始化，讀取敏感詞
     */
    @PostConstruct  // 確保在Bean初始化后執(zhí)行
    public void init() {
        // 1. 從類路徑加載敏感詞文件: 使用文件存儲(chǔ)敏感詞庫可以直接進(jìn)行一次性讀取和處理，無需依賴數(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及以后的版本中，引入了一項(xiàng)稱為"try-with-resources"的新特性，它允許自動(dòng)管理資源，確保在try語句塊執(zhí)行完畢后，不論是否發(fā)生異常，都會(huì)正確關(guān)閉或釋放資源
        ) {
            // 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. 初始化操作，將當(dāng)前處理節(jié)點(diǎn)設(shè)為根節(jié)點(diǎn)
        TrieNode tempNode = rootNode;

        // 2. 將待添加的敏感詞字符串轉(zhuǎn)換為字符數(shù)組以便遍歷
        char[] chars = keyword.toCharArray();

        // 3. 遍歷字符數(shù)組，逐個(gè)字符構(gòu)建前綴樹
        for (int i = 0; i < chars.length; i++) {
            // 3.1. 從當(dāng)前處理節(jié)點(diǎn)的子節(jié)點(diǎn)Map中獲取當(dāng)前字符對(duì)應(yīng)的節(jié)點(diǎn)
            TrieNode childrenNode = tempNode.getChildrenNode(chars[i]);
            // 3.1.1 若當(dāng)前字符沒有對(duì)應(yīng)的節(jié)點(diǎn)，則創(chuàng)建一個(gè)新節(jié)點(diǎn)，并放入當(dāng)前處理節(jié)點(diǎn)的子節(jié)點(diǎn)Map中
            if (childrenNode == null) {
                childrenNode = new TrieNode();
                tempNode.setChildrenNode(chars[i], childrenNode);
            }

            // 3.2. 若當(dāng)前字符為敏感詞字符串的最后一個(gè)字符，則標(biāo)記當(dāng)前字符的對(duì)應(yīng)節(jié)點(diǎn)為敏感詞的結(jié)尾節(jié)點(diǎn)
            if (i == chars.length - 1) {
                childrenNode.setKeywordEnd(true);
            }

            // 3.3. 移動(dòng)到下一層，使當(dāng)前字符對(duì)應(yīng)的節(jié)點(diǎn)成為新的當(dāng)前處理節(jié)點(diǎn)，繼續(xù)構(gòu)建或遍歷過程
            tempNode = childrenNode;
        }
    }

    /**
     * 過濾文本，移除或替換其中的敏感詞，并返回處理后的文本
     * @param text 待過濾的文本
     * @return 過濾后的文本
     */
    public String filter(String text) {
        // 1. 檢查輸入文本是否為空或僅包含空白字符，如果是，則直接返回null，表示無內(nèi)容無需過濾
        if (StringUtils.isBlank(text)) {
            return null;
        }

        // 2. 初始化變量
        TrieNode tempNode = rootNode;   // 2.1. 初始化為前綴樹的根節(jié)點(diǎn)，用于遍歷查找。
        int begin = 0, end = 0;         // 2.2. 分別用于標(biāo)記待檢查文本區(qū)間的起始和結(jié)束位置
        StringBuilder result = new StringBuilder(); // 2.3. 累積過濾后的文本

        // 3. 遍歷整個(gè)文本進(jìn)行過濾處理
        while (begin < text.length()) {
            char c = text.charAt(end);
            // 3.1. 遇到符號(hào)字符
            if (isSymbol(c)) {
                // 3.1.1. 如果當(dāng)前處于根節(jié)點(diǎn)，即沒有匹配到任何敏感詞的開始，直接保留符號(hào)，并移動(dòng)begin
                if (tempNode == rootNode) {
                    result.append(c);
                    begin++;
                }
                // 3.1.2. 跳過當(dāng)前符號(hào)，并繼續(xù)檢查下一個(gè)字符
                end++;
                continue;
            }

            // 3.2. 檢查當(dāng)前字符區(qū)間text[begin...end]是否是某個(gè)敏感詞的一部分
            tempNode = tempNode.getChildrenNode(c);

            // 3.2.1. 如果當(dāng)前字符沒有對(duì)應(yīng)的子節(jié)點(diǎn)，即text[begin...end]不是敏感詞的組成部分
            if (tempNode == null) {
                result.append(text.charAt(begin));  // 3.2.1.1. 保存begin位置的字符到結(jié)果
                end = ++begin;          // 3.2.1.2. 移動(dòng)begin和end指針，準(zhǔn)備檢查下一個(gè)可能的敏感詞 begin++; end = begin;
                tempNode = rootNode;    // 3.2.1.3. 重置tempNode為根節(jié)點(diǎn)準(zhǔn)備下一輪匹配
            }

            // 3.2.2. 如果當(dāng)前字符路徑已到達(dá)一個(gè)敏感詞的結(jié)尾，即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. 移動(dòng)begin和end指針，準(zhǔn)備檢查下一個(gè)可能的敏感詞 end++; begin = end;
                tempNode = rootNode;    // 3.2.2.3. 重置tempNode為根節(jié)點(diǎn)準(zhǔn)備下一輪匹配
            }

            // 3.2.3. 如果當(dāng)前字符區(qū)間text[begin...end]是潛在敏感詞的一部分但不是結(jié)尾，繼續(xù)匹配下一個(gè)字符
            else {
                // 3.2.3.1. 檢查下一個(gè)字符是否存在，存在則移動(dòng)end指針；否則，回退begin到當(dāng)前位置，準(zhǔn)備重新匹配
                if (end < text.length() - 1) {
                    end++;
                } else {
                    end = begin;
                }
            }
        }

        // 4. 將剩余未檢查的文本（若有）添加到結(jié)果中
        result.append(text.substring(begin));

        // 5. 返回過濾后的文本
        return result.toString();
    }

    /**
     * 判斷字符是否為符號(hào)字符
     * @param character 待判斷的字符
     * @return true表示是符號(hào)字符，需要跳過；false表示不是符號(hào)字符，不跳過
     */
    private boolean isSymbol(Character character) {
        // 0x2E80~0x9FFF是東亞文字: 判斷字符是否不屬于ASCII字母數(shù)字且不在東亞文字范圍內(nèi)
        return !CharUtils.isAsciiAlphanumeric(character) && (character < 0x2E80 || character > 0x9FFF);
    }

    /**
     * 內(nèi)部類，定義前綴樹的節(jié)點(diǎn)
     */
    private static class TrieNode {

        private boolean isKeywordEnd = false;   // 當(dāng)前節(jié)點(diǎn)是否為敏感詞的末尾節(jié)點(diǎn)

        private final Map<Character, TrieNode> childrenNode = new HashMap<>();  // 當(dāng)前節(jié)點(diǎn)的子節(jié)點(diǎn)

        // 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;

/**
 * 敏感詞過濾器的相關(guān)常量
 */
public class SensitiveConstant {
    /**
     * 敏感詞文件名稱
     */
    public static final String SENSITIVE_WORDS_FILE = "sensitive_words.txt";
    /**
     * 用于替換敏感詞的字符
     */
    public static final Character REPLACEMENT = '*';
}

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);
    }
}

<dependency>
    <groupId>com.github.houbb</groupId>
    <artifactId>sensitive-word</artifactId>
    <version>0.17.0</version>
</dependency>

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);
    }
}

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;

/**
 * 配置類，用于設(shè)置敏感詞過濾器的自定義過濾策略
 * 更多配置見 https://github.com/houbb/sensitive-word
 */
@Configuration
public class SensitiveWordConfig {

    /**
     * 初始化引導(dǎo)類
     * @return 初始化引導(dǎo)類
     * @since 1.0.0
     */
    @Bean
    public SensitiveWordBs sensitiveWordBs() {
        SensitiveWordBs wordBs = SensitiveWordBs.newInstance()
                .ignoreCase(true)           // 忽略大小寫，默認(rèn)值為true
                .ignoreWidth(true)          // 忽略半角圓角，默認(rèn)值為true
                .ignoreNumStyle(true)       // 忽略數(shù)字的寫法，默認(rèn)值為true
                .ignoreChineseStyle(true)   // 忽略中文的書寫格式，默認(rèn)值為true
                .ignoreEnglishStyle(true)   // 忽略英文的書寫格式，默認(rèn)值為true
                .ignoreRepeat(false)        // 忽略重復(fù)詞，默認(rèn)值為false
                .enableNumCheck(false)      // 是否啟用數(shù)字檢測(cè)，默認(rèn)值為false
                .enableEmailCheck(false)    // 是有啟用郵箱檢測(cè)，默認(rèn)值為false
                .enableUrlCheck(false)      // 是否啟用鏈接檢測(cè)，默認(rèn)值為false
                .enableIpv4Check(false)     // 是否啟用IPv4檢測(cè)，默認(rèn)值為false
                .enableWordCheck(true)      // 是否啟用敏感單詞檢測(cè)，默認(rèn)值為true
                .numCheckLen(8)             // 數(shù)字檢測(cè)，自定義指定長(zhǎng)度，默認(rèn)值為8
                .wordTag(WordTags.none())   // 詞對(duì)應(yīng)的標(biāo)簽，默認(rèn)值為none
                .charIgnore(SensitiveWordCharIgnores.defaults())            // 忽略的字符，默認(rèn)值為none
                .wordResultCondition(WordResultConditions.alwaysTrue())     // 針對(duì)匹配的敏感詞額外加工，比如可以限制英文單詞必須全匹配，默認(rèn)恒為真
                .init();

        return wordBs;
    }
}

.enableNumCheck(true)      // 是否啟用數(shù)字檢測(cè)，默認(rèn)值為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("這個(gè)是我的微信：9?二肆??③⑸⒋?㈤五");
        System.out.println(result);
    }
}