com.video.sensitive/
├── annotation/                 # 注解層
│   └── SensitiveCheck.java    # 敏感詞檢測注解
├── aspect/                     # AOP切面層
│   └── SensitiveCheckAspect.java
├── core/                       # 核心引擎
│   ├── SensitiveWordFilter.java      # 敏感詞過濾器接口
│   ├── DfaSensitiveWordFilter.java   # DFA算法實(shí)現(xiàn)
│   ├── SensitiveWordTrie.java        # Trie樹結(jié)構(gòu)
│   └── SensitiveWordMatcher.java     # 匹配器
├── strategy/                   # 處理策略
│   ├── SensitiveStrategy.java        # 策略接口
│   ├── RejectStrategy.java           # 拒絕策略
│   ├── ReplaceStrategy.java          # 替換策略
│   └── ReviewStrategy.java           # 人工審核標(biāo)記策略
├── cache/                      # 緩存管理
│   ├── SensitiveWordCacheManager.java
│   └── WordCacheWarmer.java          # 緩存預(yù)熱
├── repository/                 # 敏感詞庫管理
│   ├── SensitiveWordRepository.java
│   └── WhitelistRepository.java
├── entity/                     # 實(shí)體類
│   ├── SensitiveWord.java           # 敏感詞實(shí)體
│   ├── SensitiveLog.java            # 審計(jì)日志實(shí)體
│   └── Whitelist.java               # 白名單實(shí)體
├── mapper/                     # MyBatis Mapper
│   ├── SensitiveWordMapper.java
│   ├── SensitiveLogMapper.java
│   └── WhitelistMapper.java
├── service/                    # 業(yè)務(wù)服務(wù)
│   ├── SensitiveWordService.java    # 敏感詞管理服務(wù)
│   └── SensitiveCheckService.java   # 檢測服務(wù)
├── controller/                 # 管理接口
│   └── SensitiveWordController.java
├── config/                     # 配置類
│   ├── SensitiveConfig.java
│   └── SensitiveProperties.java
├── enums/                      # 枚舉類
│   ├── SensitiveStrategy.java       # 處理策略枚舉
│   ├── SensitiveLevel.java          # 敏感等級枚舉
│   └── MatchType.java               # 匹配類型枚舉
├── exception/                  # 異常類
│   ├── SensitiveWordException.java
│   └── SensitiveContentException.java
└── monitor/                    # 監(jiān)控與日志
    ├── SensitiveMonitor.java        # 監(jiān)控指標(biāo)
    └── SensitiveAuditLogger.java    # 審計(jì)日志

用戶 -> Controller -> @SensitiveCheck -> SensitiveCheckAspect
                                             ↓
                         [1] 獲取待檢測文本 + 注解配置
                                             ↓
                         [2] SensitiveWordCacheManager.getWordTrie()
                                             ↓ (緩存未命中)
                         [3] Redis 獲取敏感詞列表
                                             ↓ (Redis未命中)
                         [4] MySQL 查詢敏感詞表
                                             ↓
                         [5] 構(gòu)建 Trie 樹并緩存到 Caffeine + Redis
                                             ↓
                         [6] DfaSensitiveWordFilter.filter(text, wordTrie)
                                             ↓
                         [7] 返回檢測結(jié)果（匹配詞列表 + 位置）
                                             ↓
                     根據(jù)策略處理:
                     - REJECT: 拋出異常，攔截請求
                     - REPLACE: 替換為 *** 并繼續(xù)執(zhí)行
                     - REVIEW: 標(biāo)記待審核，發(fā)送 MQ 消息
                                             ↓
                         [8] 記錄審計(jì)日志（異步）
                                             ↓
                         [9] 更新監(jiān)控指標(biāo)
                                             ↓
                         返回結(jié)果給業(yè)務(wù)層

┌─────────────────────────────────────────────────────────┐
│                    檢測請求                                       │
└────────────────────────┬────────────────────────────────┘
                         │
                         │  L1: Caffeine 本地緩存
                         │  - 過期時(shí)間：10分鐘
                         │  - 命中率：> 95%
                         │  - RT：< 1ms
                         │
                    [命中] │ [未命中]
                         ↓
                         │  L2: Redis 分布式緩存
                         │  - 過期時(shí)間：1小時(shí)
                         │  - 命中率：> 99%
                         │  - RT：< 3ms
                         │
                    [命中] │ [未命中]
                         ↓
                         │  L3: MySQL 數(shù)據(jù)庫
                         │  - 持久化存儲
                         │  - 用于緩存重建
                         │  - RT：< 10ms
                         │
                         ↓
                    返回 Trie 樹

package com.video.sensitive.annotation;

import com.video.sensitive.enums.MatchType;
import com.video.sensitive.enums.SensitiveStrategyType;
import java.lang.annotation.*;

/**
 * 敏感詞檢測注解
 * 用于標(biāo)記需要進(jìn)行敏感詞檢測的方法參數(shù)或返回值
 */
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SensitiveCheck {
    
    /**
     * 需要檢測的參數(shù)名稱（支持SpEL表達(dá)式）
     * 示例："#dto.content" 或 "#comment.content"
     */
    String[] fields() default {};
    
    /**
     * 處理策略
     * - REJECT: 直接拒絕請求（默認(rèn)）
     * - REPLACE: 替換敏感詞為 ***
     * - REVIEW: 標(biāo)記為待人工審核
     */
    SensitiveStrategyType strategy() default SensitiveStrategyType.REJECT;
    
    /**
     * 匹配類型
     * - EXACT: 精確匹配（默認(rèn)）
     * - FUZZY: 模糊匹配（支持變體、拆分、諧音）
     */
    MatchType matchType() default MatchType.EXACT;
    
    /**
     * 是否啟用白名單
     */
    boolean useWhitelist() default true;
    
    /**
     * 業(yè)務(wù)場景描述（用于日志和監(jiān)控）
     */
    String scene() default "";
    
    /**
     * 是否啟用降級保護(hù)
     * 當(dāng)檢測服務(wù)異常時(shí)，是否允許請求通過
     */
    boolean enableFallback() default true;
    
    /**
     * 超時(shí)時(shí)間（毫秒）
     * 超過此時(shí)間未完成檢測，觸發(fā)降級
     */
    long timeout() default 100;
}

package com.video.sensitive.core;

import java.util.HashMap;
import java.util.Map;

/**
 * 敏感詞 Trie 樹節(jié)點(diǎn)
 */
public class SensitiveWordTrie {
    
    /**
     * 根節(jié)點(diǎn)
     */
    private final TrieNode root = new TrieNode();
    
    /**
     * Trie 樹節(jié)點(diǎn)
     */
    private static class TrieNode {
        /**
         * 子節(jié)點(diǎn) Map（字符 -> 子節(jié)點(diǎn)）
         */
        private Map<Character, TrieNode> children = new HashMap<>();
        
        /**
         * 是否為敏感詞結(jié)尾
         */
        private boolean isEnd = false;
        
        /**
         * 敏感詞等級（1-低，2-中，3-高）
         */
        private int level = 1;
        
        /**
         * 敏感詞原始文本（用于日志記錄）
         */
        private String word;
    }
    
    /**
     * 添加敏感詞到 Trie 樹
     * 
     * @param word 敏感詞
     * @param level 敏感等級
     */
    public void addWord(String word, int level) {
        if (word == null || word.isEmpty()) {
            return;
        }
        
        TrieNode node = root;
        for (char c : word.toCharArray()) {
            // 轉(zhuǎn)為小寫統(tǒng)一處理
            c = Character.toLowerCase(c);
            node = node.children.computeIfAbsent(c, k -> new TrieNode());
        }
        node.isEnd = true;
        node.level = level;
        node.word = word;
    }
    
    /**
     * 檢測文本中的敏感詞（DFA算法）
     * 
     * @param text 待檢測文本
     * @return 匹配結(jié)果列表
     */
    public List<MatchResult> match(String text) {
        if (text == null || text.isEmpty()) {
            return Collections.emptyList();
        }
        
        List<MatchResult> results = new ArrayList<>();
        int length = text.length();
        
        for (int i = 0; i < length; i++) {
            int matchLength = 0;
            TrieNode node = root;
            
            // DFA 狀態(tài)機(jī)匹配
            for (int j = i; j < length && node != null; j++) {
                char c = Character.toLowerCase(text.charAt(j));
                node = node.children.get(c);
                
                if (node != null) {
                    matchLength++;
                    // 找到完整敏感詞
                    if (node.isEnd) {
                        MatchResult result = new MatchResult();
                        result.setWord(node.word);
                        result.setStartIndex(i);
                        result.setEndIndex(j + 1);
                        result.setLevel(node.level);
                        result.setMatchedText(text.substring(i, j + 1));
                        results.add(result);
                        break;
                    }
                }
            }
        }
        
        return results;
    }
    
    /**
     * 匹配結(jié)果
     */
    @Data
    public static class MatchResult {
        private String word;           // 原始敏感詞
        private String matchedText;    // 匹配到的文本
        private int startIndex;        // 開始位置
        private int endIndex;          // 結(jié)束位置
        private int level;             // 敏感等級
    }
}

package com.video.sensitive.core;

import com.video.sensitive.enums.MatchType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Set;

/**
 * DFA 算法實(shí)現(xiàn)的敏感詞過濾器
 */
@Slf4j
@Component
public class DfaSensitiveWordFilter implements SensitiveWordFilter {
    
    @Override
    public FilterResult filter(String text, SensitiveWordTrie wordTrie, 
                               MatchType matchType, Set<String> whitelist) {
        if (text == null || text.isEmpty()) {
            return FilterResult.clean();
        }
        
        // 1. 執(zhí)行敏感詞匹配
        List<SensitiveWordTrie.MatchResult> matches = wordTrie.match(text);
        
        // 2. 過濾白名單
        if (whitelist != null && !whitelist.isEmpty()) {
            matches = matches.stream()
                    .filter(m -> !whitelist.contains(m.getWord()))
                    .collect(Collectors.toList());
        }
        
        // 3. 模糊匹配增強(qiáng)（可選）
        if (matchType == MatchType.FUZZY && !matches.isEmpty()) {
            matches = enhanceFuzzyMatch(text, matches);
        }
        
        // 4. 構(gòu)建結(jié)果
        FilterResult result = new FilterResult();
        result.setHasSensitiveWord(!matches.isEmpty());
        result.setMatches(matches);
        result.setOriginalText(text);
        
        if (!matches.isEmpty()) {
            result.setFilteredText(replaceMatches(text, matches));
            result.setHighestLevel(matches.stream()
                    .mapToInt(SensitiveWordTrie.MatchResult::getLevel)
                    .max()
                    .orElse(1));
        } else {
            result.setFilteredText(text);
            result.setHighestLevel(0);
        }
        
        return result;
    }
    
    /**
     * 替換敏感詞為 ***
     */
    private String replaceMatches(String text, List<SensitiveWordTrie.MatchResult> matches) {
        StringBuilder sb = new StringBuilder(text);
        
        // 從后往前替換，避免索引位移
        matches.stream()
                .sorted((a, b) -> Integer.compare(b.getStartIndex(), a.getStartIndex()))
                .forEach(match -> {
                    int length = match.getEndIndex() - match.getStartIndex();
                    String replacement = "*".repeat(length);
                    sb.replace(match.getStartIndex(), match.getEndIndex(), replacement);
                });
        
        return sb.toString();
    }
    
    /**
     * 模糊匹配增強(qiáng)
     * 處理變體詞（如：法輪功 -> 法_輪_功、falungong）
     */
    private List<SensitiveWordTrie.MatchResult> enhanceFuzzyMatch(
            String text, List<SensitiveWordTrie.MatchResult> exactMatches) {
        // TODO: 實(shí)現(xiàn)模糊匹配邏輯
        // 1. 去除特殊符號后重新匹配
        // 2. 諧音轉(zhuǎn)換后匹配
        // 3. 拼音匹配
        return exactMatches;
    }
    
    /**
     * 過濾結(jié)果
     */
    @Data
    public static class FilterResult {
        private boolean hasSensitiveWord;               // 是否包含敏感詞
        private String originalText;                    // 原始文本
        private String filteredText;                    // 過濾后文本
        private List<SensitiveWordTrie.MatchResult> matches;  // 匹配結(jié)果列表
        private int highestLevel;                       // 最高敏感等級
        
        public static FilterResult clean() {
            FilterResult result = new FilterResult();
            result.setHasSensitiveWord(false);
            result.setMatches(Collections.emptyList());
            result.setHighestLevel(0);
            return result;
        }
    }
}

package com.video.sensitive.cache;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.video.sensitive.core.SensitiveWordTrie;
import com.video.sensitive.entity.SensitiveWord;
import com.video.sensitive.mapper.SensitiveWordMapper;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * 敏感詞緩存管理器（三級緩存）
 */
@Slf4j
@Component
public class SensitiveWordCacheManager {
    
    private static final String REDIS_KEY_WORDS = "sensitive:words:all";
    private static final String REDIS_KEY_WHITELIST = "sensitive:whitelist:all";
    private static final String REDIS_KEY_VERSION = "sensitive:version";
    
    @Resource
    private SensitiveWordMapper sensitiveWordMapper;
    
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    
    /**
     * L1: Caffeine 本地緩存 Trie 樹
     * 緩存時(shí)間：10分鐘，最大 1000 個(gè) key
     */
    private final Cache<String, SensitiveWordTrie> trieCache = Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(1000)
            .build();
    
    /**
     * L1: 白名單本地緩存
     */
    private final Cache<String, Set<String>> whitelistCache = Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(100)
            .build();
    
    /**
     * 應(yīng)用啟動時(shí)預(yù)熱緩存
     */
    @PostConstruct
    public void warmUp() {
        log.info("開始預(yù)熱敏感詞緩存...");
        try {
            // 預(yù)加載敏感詞 Trie 樹
            getWordTrie();
            // 預(yù)加載白名單
            getWhitelist();
            log.info("敏感詞緩存預(yù)熱完成");
        } catch (Exception e) {
            log.error("敏感詞緩存預(yù)熱失敗", e);
        }
    }
    
    /**
     * 獲取敏感詞 Trie 樹（三級緩存）
     */
    public SensitiveWordTrie getWordTrie() {
        String cacheKey = "default";
        
        // L1: 本地緩存
        SensitiveWordTrie trie = trieCache.getIfPresent(cacheKey);
        if (trie != null) {
            log.debug("命中 Caffeine 緩存");
            return trie;
        }
        
        // L2: Redis 緩存
        try {
            Set<String> redisWords = stringRedisTemplate.opsForSet().members(REDIS_KEY_WORDS);
            if (redisWords != null && !redisWords.isEmpty()) {
                log.debug("命中 Redis 緩存，詞庫大小: {}", redisWords.size());
                trie = buildTrieFromWords(redisWords);
                trieCache.put(cacheKey, trie);
                return trie;
            }
        } catch (Exception e) {
            log.warn("從 Redis 加載敏感詞失敗，降級到數(shù)據(jù)庫", e);
        }
        
        // L3: MySQL 數(shù)據(jù)庫
        List<SensitiveWord> words = sensitiveWordMapper.selectList(
                new LambdaQueryWrapper<SensitiveWord>()
                        .eq(SensitiveWord::getStatus, 1)
                        .eq(SensitiveWord::getIsDeleted, 0)
        );
        
        log.info("從數(shù)據(jù)庫加載敏感詞，數(shù)量: {}", words.size());
        
        // 構(gòu)建 Trie 樹
        trie = new SensitiveWordTrie();
        for (SensitiveWord word : words) {
            trie.addWord(word.getWord(), word.getLevel());
        }
        
        // 回寫緩存
        trieCache.put(cacheKey, trie);
        
        // 回寫 Redis
        try {
            Set<String> wordSet = words.stream()
                    .map(SensitiveWord::getWord)
                    .collect(Collectors.toSet());
            stringRedisTemplate.opsForSet().add(REDIS_KEY_WORDS, wordSet.toArray(new String[0]));
            stringRedisTemplate.expire(REDIS_KEY_WORDS, 1, TimeUnit.HOURS);
        } catch (Exception e) {
            log.warn("回寫 Redis 緩存失敗", e);
        }
        
        return trie;
    }
    
    /**
     * 獲取白名單（三級緩存）
     */
    public Set<String> getWhitelist() {
        String cacheKey = "default";
        
        // L1: 本地緩存
        Set<String> whitelist = whitelistCache.getIfPresent(cacheKey);
        if (whitelist != null) {
            return whitelist;
        }
        
        // L2: Redis 緩存
        try {
            Set<String> redisWhitelist = stringRedisTemplate.opsForSet().members(REDIS_KEY_WHITELIST);
            if (redisWhitelist != null && !redisWhitelist.isEmpty()) {
                whitelistCache.put(cacheKey, redisWhitelist);
                return redisWhitelist;
            }
        } catch (Exception e) {
            log.warn("從 Redis 加載白名單失敗", e);
        }
        
        // L3: 數(shù)據(jù)庫
        List<Whitelist> list = whitelistMapper.selectList(
                new LambdaQueryWrapper<Whitelist>()
                        .eq(Whitelist::getStatus, 1)
        );
        
        whitelist = list.stream()
                .map(Whitelist::getWord)
                .collect(Collectors.toSet());
        
        // 回寫緩存
        whitelistCache.put(cacheKey, whitelist);
        try {
            stringRedisTemplate.opsForSet().add(REDIS_KEY_WHITELIST, whitelist.toArray(new String[0]));
            stringRedisTemplate.expire(REDIS_KEY_WHITELIST, 1, TimeUnit.HOURS);
        } catch (Exception e) {
            log.warn("回寫白名單 Redis 緩存失敗", e);
        }
        
        return whitelist;
    }
    
    /**
     * 清除所有緩存（用于敏感詞更新后刷新）
     */
    public void clearCache() {
        log.info("清除敏感詞緩存");
        trieCache.invalidateAll();
        whitelistCache.invalidateAll();
        
        try {
            stringRedisTemplate.delete(REDIS_KEY_WORDS);
            stringRedisTemplate.delete(REDIS_KEY_WHITELIST);
            // 版本號+1，通知其他節(jié)點(diǎn)刷新
            stringRedisTemplate.opsForValue().increment(REDIS_KEY_VERSION);
        } catch (Exception e) {
            log.error("清除 Redis 緩存失敗", e);
        }
    }
    
    /**
     * 從詞列表構(gòu)建 Trie 樹
     */
    private SensitiveWordTrie buildTrieFromWords(Set<String> words) {
        SensitiveWordTrie trie = new SensitiveWordTrie();
        for (String word : words) {
            trie.addWord(word, 1); // 從 Redis 加載默認(rèn)等級為 1
        }
        return trie;
    }
}

package com.video.sensitive.aspect;

import com.video.common.Result;
import com.video.sensitive.annotation.SensitiveCheck;
import com.video.sensitive.cache.SensitiveWordCacheManager;
import com.video.sensitive.core.DfaSensitiveWordFilter;
import com.video.sensitive.core.SensitiveWordTrie;
import com.video.sensitive.enums.SensitiveStrategyType;
import com.video.sensitive.exception.SensitiveContentException;
import com.video.sensitive.monitor.SensitiveAuditLogger;
import com.video.sensitive.monitor.SensitiveMonitor;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * 敏感詞檢測切面
 */
@Slf4j
@Aspect
@Component
public class SensitiveCheckAspect {
    
    @Resource
    private DfaSensitiveWordFilter sensitiveWordFilter;
    
    @Resource
    private SensitiveWordCacheManager cacheManager;
    
    @Resource
    private SensitiveAuditLogger auditLogger;
    
    @Resource
    private SensitiveMonitor monitor;
    
    private final ExpressionParser parser = new SpelExpressionParser();
    
    @Around("@annotation(com.video.sensitive.annotation.SensitiveCheck)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        SensitiveCheck annotation = method.getAnnotation(SensitiveCheck.class);
        
        try {
            // 1. 提取待檢測文本
            String[] fields = annotation.fields();
            if (fields.length == 0) {
                return joinPoint.proceed();
            }
            
            Object[] args = joinPoint.getArgs();
            String[] paramNames = signature.getParameterNames();
            
            // 2. 使用 SpEL 提取字段值
            StandardEvaluationContext context = new StandardEvaluationContext();
            for (int i = 0; i < paramNames.length; i++) {
                context.setVariable(paramNames[i], args[i]);
            }
            
            // 3. 檢測每個(gè)字段
            for (String field : fields) {
                Expression expression = parser.parseExpression(field);
                Object value = expression.getValue(context);
                
                if (value instanceof String) {
                    String text = (String) value;
                    checkText(text, annotation, method.getName());
                }
            }
            
            // 4. 執(zhí)行業(yè)務(wù)邏輯
            Object result = joinPoint.proceed();
            
            // 5. 記錄監(jiān)控指標(biāo)
            long cost = System.currentTimeMillis() - startTime;
            monitor.recordCheckSuccess(annotation.scene(), cost);
            
            return result;
            
        } catch (SensitiveContentException e) {
            // 6. 敏感詞檢測失敗
            long cost = System.currentTimeMillis() - startTime;
            monitor.recordCheckReject(annotation.scene(), cost);
            throw e;
            
        } catch (Exception e) {
            // 7. 系統(tǒng)異常，觸發(fā)降級
            long cost = System.currentTimeMillis() - startTime;
            monitor.recordCheckError(annotation.scene(), cost);
            
            if (annotation.enableFallback()) {
                log.warn("敏感詞檢測異常，觸發(fā)降級保護(hù)，允許請求通過", e);
                return joinPoint.proceed();
            } else {
                throw e;
            }
        }
    }
    
    /**
     * 檢測文本
     */
    private void checkText(String text, SensitiveCheck annotation, String methodName) {
        if (text == null || text.trim().isEmpty()) {
            return;
        }
        
        // 1. 獲取敏感詞 Trie 樹
        SensitiveWordTrie wordTrie = cacheManager.getWordTrie();
        
        // 2. 獲取白名單
        Set<String> whitelist = annotation.useWhitelist() ? 
                cacheManager.getWhitelist() : null;
        
        // 3. 執(zhí)行過濾
        DfaSensitiveWordFilter.FilterResult result = sensitiveWordFilter.filter(
                text, wordTrie, annotation.matchType(), whitelist);
        
        // 4. 處理結(jié)果
        if (result.isHasSensitiveWord()) {
            // 記錄審計(jì)日志
            auditLogger.logSensitive(
                    annotation.scene(),
                    methodName,
                    text,
                    result.getMatches(),
                    annotation.strategy()
            );
            
            // 根據(jù)策略處理
            handleByStrategy(annotation.strategy(), text, result);
        }
    }
    
    /**
     * 根據(jù)策略處理敏感內(nèi)容
     */
    private void handleByStrategy(SensitiveStrategyType strategy, 
                                   String text, 
                                   DfaSensitiveWordFilter.FilterResult result) {
        switch (strategy) {
            case REJECT:
                // 直接拒絕
                throw new SensitiveContentException(
                        "內(nèi)容包含敏感詞，禁止發(fā)布",
                        result.getMatches()
                );
                
            case REPLACE:
                // 替換敏感詞（修改原對象）
                // 注意：需要通過反射修改原始對象的字段值
                log.info("替換敏感詞: {} -> {}", text, result.getFilteredText());
                break;
                
            case REVIEW:
                // 標(biāo)記待審核，發(fā)送 MQ 消息
                log.info("標(biāo)記內(nèi)容待審核: {}", text);
                // TODO: 發(fā)送 RabbitMQ 消息給審核系統(tǒng)
                break;
                
            default:
                throw new IllegalArgumentException("未知策略: " + strategy);
        }
    }
}

CREATE TABLE `a_sensitive_word` (
  `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主鍵ID',
  `word` VARCHAR(200) NOT NULL COMMENT '敏感詞',
  `level` TINYINT NOT NULL DEFAULT 1 COMMENT '敏感等級：1-低，2-中，3-高',
  `category` VARCHAR(50) DEFAULT NULL COMMENT '分類：政治、色情、暴力、廣告等',
  `status` TINYINT NOT NULL DEFAULT 1 COMMENT '狀態(tài)：0-禁用，1-啟用',
  `remark` VARCHAR(500) DEFAULT NULL COMMENT '備注說明',
  `create_user` BIGINT DEFAULT NULL COMMENT '創(chuàng)建人',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '創(chuàng)建時(shí)間',
  `update_user` BIGINT DEFAULT NULL COMMENT '修改人',
  `update_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改時(shí)間',
  `is_deleted` TINYINT NOT NULL DEFAULT 0 COMMENT '是否刪除：0-未刪除，1-已刪除',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_word` (`word`),
  KEY `idx_level` (`level`),
  KEY `idx_category` (`category`),
  KEY `idx_status` (`status`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='敏感詞表';

CREATE TABLE `a_sensitive_whitelist` (
  `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主鍵ID',
  `word` VARCHAR(200) NOT NULL COMMENT '白名單詞匯',
  `status` TINYINT NOT NULL DEFAULT 1 COMMENT '狀態(tài)：0-禁用，1-啟用',
  `remark` VARCHAR(500) DEFAULT NULL COMMENT '備注說明',
  `create_user` BIGINT DEFAULT NULL COMMENT '創(chuàng)建人',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '創(chuàng)建時(shí)間',
  `update_user` BIGINT DEFAULT NULL COMMENT '修改人',
  `update_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改時(shí)間',
  `is_deleted` TINYINT NOT NULL DEFAULT 0 COMMENT '是否刪除：0-未刪除，1-已刪除',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_word` (`word`),
  KEY `idx_status` (`status`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='敏感詞白名單';

CREATE TABLE `a_sensitive_log` (
  `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主鍵ID',
  `user_id` BIGINT DEFAULT NULL COMMENT '用戶ID',
  `scene` VARCHAR(50) NOT NULL COMMENT '業(yè)務(wù)場景',
  `method_name` VARCHAR(200) DEFAULT NULL COMMENT '方法名',
  `original_text` TEXT COMMENT '原始文本',
  `matched_words` VARCHAR(500) DEFAULT NULL COMMENT '匹配的敏感詞（JSON數(shù)組）',
  `strategy` VARCHAR(20) NOT NULL COMMENT '處理策略',
  `result` VARCHAR(20) NOT NULL COMMENT '處理結(jié)果：PASS-通過，REJECT-拒絕，REVIEW-審核',
  `ip` VARCHAR(50) DEFAULT NULL COMMENT '客戶端IP',
  `user_agent` VARCHAR(500) DEFAULT NULL COMMENT '客戶端UA',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '創(chuàng)建時(shí)間',
  PRIMARY KEY (`id`),
  KEY `idx_user_id` (`user_id`),
  KEY `idx_scene` (`scene`),
  KEY `idx_create_time` (`create_time`),
  KEY `idx_result` (`result`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='敏感詞審計(jì)日志';

-- 按月分區(qū)
ALTER TABLE `a_sensitive_log` PARTITION BY RANGE (TO_DAYS(`create_time`)) (
    PARTITION p202601 VALUES LESS THAN (TO_DAYS('2026-02-01')),
    PARTITION p202602 VALUES LESS THAN (TO_DAYS('2026-03-01')),
    PARTITION p202603 VALUES LESS THAN (TO_DAYS('2026-04-01')),
    PARTITION p_max VALUES LESS THAN MAXVALUE
);

@PostMapping("/add")
@Operation(summary = "發(fā)表評論")
@SensitiveCheck(
    fields = {"#dto.content"},
    strategy = SensitiveStrategyType.REJECT,
    matchType = MatchType.EXACT,
    scene = "comment_publish",
    enableFallback = true,
    timeout = 100
)
public Result<CommentOperationVO> addComment(
        @RequestHeader("userId") Long userId,
        @RequestBody CommentDTO dto) {
    VideoComment comment = videoCommentService.addComment(userId, dto);
    return Result.success(CommentOperationVO.of(comment));
}

@PostMapping("/send")
@SensitiveCheck(
    fields = {"#message.content"},
    strategy = SensitiveStrategyType.REVIEW,  // 私信使用人工審核
    matchType = MatchType.FUZZY,               // 使用模糊匹配
    scene = "private_message",
    enableFallback = false                      // 不允許降級
)
public Result<Void> sendMessage(
        @RequestHeader("userId") Long userId,
        @RequestBody PrivateMessage message) {
    privateMessageService.send(userId, message);
    return Result.success();
}

@PostMapping("/add")
@Operation(summary = "發(fā)表劇情評論")
@SensitiveCheck(
    fields = {"#dto.content"},
    strategy = SensitiveStrategyType.REJECT,
    scene = "story_comment_publish"
)
public Result<StoryComment> addComment(
        @RequestParam Long userId,
        @RequestBody CommentDTO dto) {
    StoryComment comment = storyCommentService.addComment(userId, dto);
    return Result.success(comment);
}

@RestController
@RequestMapping("/api/admin/sensitive")
@Tag(name = "敏感詞管理", description = "敏感詞庫管理接口（需管理員權(quán)限）")
public class SensitiveWordController {
    
    @Resource
    private SensitiveWordService sensitiveWordService;
    
    /**
     * 添加敏感詞
     */
    @PostMapping("/word/add")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public Result<Void> addWord(@RequestBody SensitiveWordDTO dto) {
        sensitiveWordService.addWord(dto);
        return Result.success();
    }
    
    /**
     * 批量導(dǎo)入敏感詞
     */
    @PostMapping("/word/batch/import")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public Result<ImportResult> batchImport(@RequestBody List<SensitiveWordDTO> words) {
        ImportResult result = sensitiveWordService.batchImport(words);
        return Result.success(result);
    }
    
    /**
     * 刪除敏感詞
     */
    @DeleteMapping("/word/{id}")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public Result<Void> deleteWord(@PathVariable Long id) {
        sensitiveWordService.deleteWord(id);
        return Result.success();
    }
    
    /**
     * 更新敏感詞
     */
    @PutMapping("/word/{id}")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public Result<Void> updateWord(@PathVariable Long id, @RequestBody SensitiveWordDTO dto) {
        sensitiveWordService.updateWord(id, dto);
        return Result.success();
    }
    
    /**
     * 刷新緩存（熱更新）
     */
    @PostMapping("/cache/refresh")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public Result<Void> refreshCache() {
        sensitiveWordService.refreshCache();
        return Result.success();
    }
    
    /**
     * 分頁查詢敏感詞
     */
    @GetMapping("/word/page")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public Result<IPage<SensitiveWord>> getWordPage(
            @RequestParam(defaultValue = "1") int pageNum,
            @RequestParam(defaultValue = "20") int pageSize,
            @RequestParam(required = false) String keyword) {
        IPage<SensitiveWord> page = sensitiveWordService.getWordPage(pageNum, pageSize, keyword);
        return Result.success(page);
    }
    
    /**
     * 測試文本檢測
     */
    @PostMapping("/test")
    @PreAuthorize("hasAuthority('ROLE_ADMIN')")
    public Result<FilterResult> testCheck(@RequestBody TestRequest request) {
        FilterResult result = sensitiveWordService.testCheck(request.getText());
        return Result.success(result);
    }
}

性能基線:
  QPS: ≥ 15,000
  響應(yīng)時(shí)間:
    P50: < 5ms
    P95: < 10ms
    P99: < 20ms
  緩存命中率: ≥ 99%
  錯(cuò)誤率: < 0.1%
  可用性: ≥ 99.9%

@Component
public class SensitiveMonitor {
    
    @Resource
    private MeterRegistry meterRegistry;
    
    /**
     * 記錄檢測成功
     */
    public void recordCheckSuccess(String scene, long costMs) {
        Counter.builder("sensitive.check.success")
                .tag("scene", scene)
                .register(meterRegistry)
                .increment();
        
        Timer.builder("sensitive.check.latency")
                .tag("scene", scene)
                .register(meterRegistry)
                .record(costMs, TimeUnit.MILLISECONDS);
    }
    
    /**
     * 記錄檢測拒絕
     */
    public void recordCheckReject(String scene, long costMs) {
        Counter.builder("sensitive.check.reject")
                .tag("scene", scene)
                .register(meterRegistry)
                .increment();
    }
    
    /**
     * 記錄檢測異常
     */
    public void recordCheckError(String scene, long costMs) {
        Counter.builder("sensitive.check.error")
                .tag("scene", scene)
                .register(meterRegistry)
                .increment();
    }
}

# application.yml
sensitive:
  enabled: true                    # 是否啟用敏感詞檢測
  fallback-enabled: true           # 是否啟用降級保護(hù)
  default-strategy: REJECT         # 默認(rèn)處理策略
  cache:
    caffeine:
      expire-minutes: 10           # 本地緩存過期時(shí)間
      maximum-size: 1000           # 本地緩存最大數(shù)量
    redis:
      expire-hours: 1              # Redis 緩存過期時(shí)間
  performance:
    timeout-ms: 100                # 檢測超時(shí)時(shí)間
    async-log: true                # 異步寫入審計(jì)日志
  match:
    fuzzy-enabled: false           # 是否啟用模糊匹配
    whitelist-enabled: true        # 是否啟用白名單

-- 插入測試敏感詞
INSERT INTO `a_sensitive_word` (`word`, `level`, `category`, `status`) VALUES
('測試敏感詞', 1, '測試', 1),
('法輪功', 3, '政治', 1),
('色情', 2, '色情', 1);

-- 插入白名單
INSERT INTO `a_sensitive_whitelist` (`word`, `status`) VALUES
('正常詞匯', 1);

Field field = dto.getClass().getDeclaredField("content");
field.setAccessible(true);
field.set(dto, result.getFilteredText());