<dependencies>
        <!-- SpringBoot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Redis依賴 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- Lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- Commons Lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
    </dependencies>

@Component
@Slf4j
public class SensitiveWordFilter {

    // 敏感詞字典樹，用于存儲(chǔ)敏感詞
    private Map<Character, Map> sensitiveWordMap;

    // 最小匹配規(guī)則，表示找到第一個(gè)匹配到的敏感詞就返回
    public static final int MATCH_TYPE_MIN = 1;

    // 最大匹配規(guī)則，表示找到最長(zhǎng)的匹配敏感詞再返回
    public static final int MATCH_TYPE_MAX = 2;

    // 注入Redis模板，用于從Redis中加載敏感詞
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 初始化敏感詞過(guò)濾器，包括從Redis加載敏感詞
     */
    @PostConstruct
    public void init() {
        sensitiveWordMap = new HashMap<>();
        // 從Redis加載敏感詞并初始化字典樹
        loadSensitiveWordsFromRedis();
    }

    /**
     * 從Redis加載敏感詞并初始化到字典樹中
     */
    private void loadSensitiveWordsFromRedis() {
        try {
            // 從Redis的sensitive_words集合中獲取所有敏感詞
            Set<String> words = stringRedisTemplate.opsForSet().members("sensitive_words");
            if (words != null) {
                // 遍歷敏感詞集合，將每個(gè)敏感詞添加到字典樹中
                words.forEach(this::addWordToMap);
            }
        } catch (Exception e) {
            // 記錄加載敏感詞失敗日志
            log.error("Failed to load sensitive words from Redis", e);
        }
    }

    /**
     * 將敏感詞添加到字典樹中
     * @param word 要添加的敏感詞
     */
    public void addWordToMap(String word) {
        Map<Character, Map> currentMap = sensitiveWordMap;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            Map<Character, Map> subMap = currentMap.get(c);

            if (subMap == null) {
                // 如果當(dāng)前字符不存在于字典樹中，則創(chuàng)建新的節(jié)點(diǎn)
                subMap = new HashMap<>();
                currentMap.put(c, subMap);
            }

            currentMap = subMap;

            // 如果是敏感詞的最后一個(gè)字符，則標(biāo)記為敏感詞結(jié)束
            if (i == word.length() - 1) {
                currentMap.put('$', null);
            }
        }
    }

    /**
     * 檢查文本中是否包含敏感詞（最小匹配規(guī)則）
     * @param text 要檢查的文本
     * @return 如果包含敏感詞則返回true，否則返回false
     */
    public boolean containsSensitiveWord(String text) {
        if (StringUtils.isBlank(text)) {
            return false;
        }

        // 遍歷文本中的每個(gè)字符，檢查是否存在敏感詞
        for (int i = 0; i < text.length(); i++) {
            int length = checkSensitiveWord(text, i, MATCH_TYPE_MIN);
            if (length > 0) {
                return true;
            }
        }
        return false;
    }

    /**
     * 在文本中找到所有敏感詞（最大匹配規(guī)則）
     * @param text 要查找的文本
     * @return 包含所有找到的敏感詞的集合
     */
    public Set<String> findSensitiveWords(String text) {
        Set<String> sensitiveWords = new HashSet<>();
        if (StringUtils.isBlank(text)) {
            return sensitiveWords;
        }

        // 遍歷文本中的每個(gè)字符，查找敏感詞并添加到集合中
        for (int i = 0; i < text.length(); i++) {
            int length = checkSensitiveWord(text, i, MATCH_TYPE_MAX);
            if (length > 0) {
                sensitiveWords.add(text.substring(i, i + length));
                // 更新索引以跳過(guò)已找到的敏感詞
                i = i + length - 1;
            }
        }
        return sensitiveWords;
    }

    /**
     * 過(guò)濾文本中的敏感詞，用'*'替換
     * @param text 要過(guò)濾的文本
     * @return 過(guò)濾后的文本
     */
    public String filter(String text) {
        if (StringUtils.isBlank(text)) {
            return text;
        }

        StringBuilder result = new StringBuilder(text);
        Set<String> words = findSensitiveWords(text);

        // 遍歷找到的敏感詞，用'*'替換
        for (String word : words) {
            int index = result.indexOf(word);
            while (index != -1) {
                for (int i = index; i < index + word.length(); i++) {
                    result.setCharAt(i, '*');
                }
                index = result.indexOf(word, index + 1);
            }
        }

        return result.toString();
    }

    /**
     * 檢查文本中從指定索引開始的子串是否包含敏感詞
     * @param text 要檢查的文本
     * @param beginIndex 開始檢查的索引
     * @param matchType 匹配規(guī)則（最小匹配或最大匹配）
     * @return 找到的敏感詞長(zhǎng)度，如果沒(méi)有找到則返回0
     */
    private int checkSensitiveWord(String text, int beginIndex, int matchType) {
        Map<Character, Map> currentMap = sensitiveWordMap;
        int wordLength = 0;
        int maxLength = 0;

        // 從指定索引開始遍歷文本字符
        for (int i = beginIndex; i < text.length(); i++) {
            char c = text.charAt(i);
            currentMap = currentMap.get(c);

            if (currentMap == null) {
                break;
            }

            wordLength++;

            // 如果當(dāng)前節(jié)點(diǎn)標(biāo)記為敏感詞結(jié)束
            if (currentMap.containsKey('$')) {
                if (matchType == MATCH_TYPE_MIN) {
                    // 最小匹配規(guī)則，返回當(dāng)前敏感詞長(zhǎng)度
                    return wordLength;
                } else {
                    // 最大匹配規(guī)則，記錄當(dāng)前敏感詞長(zhǎng)度，繼續(xù)檢查是否還有更長(zhǎng)的敏感詞
                    maxLength = wordLength;
                }
            }
        }

        // 最大匹配規(guī)則下返回最長(zhǎng)敏感詞長(zhǎng)度
        return maxLength;
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.context.annotation.Bean;

@Configuration
public class RedisConfig {

    /**
     * 創(chuàng)建并配置StringRedisTemplate的Bean實(shí)例
     *
     * @param connectionFactory Redis連接工廠實(shí)例，用于創(chuàng)建與Redis服務(wù)器的連接
     * @return 配置好的StringRedisTemplate實(shí)例，可用于在Spring應(yīng)用中方便地操作Redis中的字符串?dāng)?shù)據(jù)類型
     */
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory connectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(connectionFactory);
        return template;
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Resource;
import java.util.Set;

@RestController
@RequestMapping("/api/sensitive")
@Slf4j
public class SensitiveWordController {

    @Resource
    private SensitiveWordFilter sensitiveWordFilter;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 處理添加敏感詞的請(qǐng)求
     *
     * @param word 要添加的敏感詞內(nèi)容，通過(guò)請(qǐng)求體傳入
     * @return 返回添加結(jié)果的響應(yīng)實(shí)體，添加成功則返回狀態(tài)碼200及"添加成功"消息，添加失敗則返回狀態(tài)碼500及"添加失敗"消息
     */
    @PostMapping("/word")
    public ResponseEntity<String> addSensitiveWord(@RequestBody String word) {
        try {
            // 將敏感詞添加到Redis的集合中
            stringRedisTemplate.opsForSet().add("sensitive_words", word);
            // 將敏感詞添加到敏感詞過(guò)濾器的字典樹中
            sensitiveWordFilter.addWordToMap(word);
            return ResponseEntity.ok("添加成功");
        } catch (Exception e) {
            log.error("添加敏感詞失敗", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("添加失敗");
        }
    }

    /**
     * 處理檢查文本是否包含敏感詞的請(qǐng)求
     *
     * @param text 要檢查的文本內(nèi)容，通過(guò)請(qǐng)求體傳入
     * @return 返回檢查結(jié)果的響應(yīng)實(shí)體，包含文本是否包含敏感詞的布爾值，狀態(tài)碼為200
     */
    @PostMapping("/check")
    public ResponseEntity<Boolean> checkText(@RequestBody String text) {
        return ResponseEntity.ok(sensitiveWordFilter.containsSensitiveWord(text));
    }

    /**
     * 處理過(guò)濾文本中敏感詞的請(qǐng)求
     *
     * @param text 要過(guò)濾的文本內(nèi)容，通過(guò)請(qǐng)求體傳入
     * @return 返回過(guò)濾后的文本內(nèi)容的響應(yīng)實(shí)體，狀態(tài)碼為200
     */
    @PostMapping("/filter")
    public ResponseEntity<String> filterText(@RequestBody String text) {
        return ResponseEntity.ok(sensitiveWordFilter.filter(text));
    }

    /**
     * 處理獲取文本中所有敏感詞的請(qǐng)求
     *
     * @param text 要獲取敏感詞的文本內(nèi)容，通過(guò)請(qǐng)求體傳入
     * @return 返回包含文本中所有敏感詞的集合的響應(yīng)實(shí)體，狀態(tài)碼為200
     */
    @PostMapping("/find")
    public ResponseEntity<Set<String>> findSensitiveWords(@RequestBody String text) {
        return ResponseEntity.ok(sensitiveWordFilter.findSensitiveWords(text));
    }
}

spring:  
    redis:    
        host: localhost    
        port: 6379    
        database: 0    
        timeout: 10000