评论脏词过滤：基于DFA算法的高性能动态过滤方案

脏词过滤系统架构
├── 数据存储层 (MySQL + Redis)
├── 算法核心层 (DFA引擎)
├── 业务服务层 (过滤服务、管理服务)
└── 应用接入层 (AOP切面、注解)

public class TrieNode {
    // 子节点映射：Key为字符，Value为对应的子节点
    private Map<Character, TrieNode> children = new HashMap<>();
    // 标记当前节点是否为某个脏词的结尾
    private boolean isEnd = false;
    // 可选：用于记录到达此节点的完整脏词
    private String keyword;
    
    // Getter和Setter方法
    public TrieNode getChild(char c) {
        return children.get(c);
    }
    
    public TrieNode addChild(char c) {
        return children.computeIfAbsent(c, k -> new TrieNode());
    }
    
    public boolean isEnd() {
        return isEnd;
    }
}

@Component
public class SensitiveWordFilter {
    private volatile TrieNode root; // 使用volatile保证多线程可见性
    
    /**
     * 构建Trie树
     */
    private TrieNode buildTrie(Set<String> sensitiveWords) {
        TrieNode root = new TrieNode();
        for (String word : sensitiveWords) {
            if (word == null || word.trim().isEmpty()) continue;
            TrieNode currentNode = root;
            for (char c : word.toCharArray()) {
                currentNode = currentNode.addChild(c);
            }
            currentNode.setEnd(true);
            currentNode.setKeyword(word);
        }
        return root;
    }
    
    /**
     * 核心DFA匹配：判断是否包含脏词
     */
    public boolean containsSensitiveWord(String text) {
        if (text == null || text.length() < minWordLength) return false;
        
        char[] chars = text.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            TrieNode node = root;
            for (int j = i; j < chars.length; j++) {
                node = node.getChild(chars[j]);
                if (node == null) break; // 转移失败，从i+1开始下一轮
                if (node.isEnd()) return true; // 匹配到一个脏词
            }
        }
        return false;
    }
    
    /**
     * 替换文本中的脏词
     */
    public String filter(String text, String replacement) {
        if (text == null) return null;
        
        StringBuilder result = new StringBuilder(text);
        List<SensitiveWordResult> foundWords = findAllWords(text);
        
        // 从后往前替换，避免影响索引
        for (int i = foundWords.size() - 1; i >= 0; i--) {
            SensitiveWordResult word = foundWords.get(i);
            String replaceStr = String.valueOf(replacement)
                .repeat(word.getEnd() - word.getStart() + 1);
            result.replace(word.getStart(), word.getEnd() + 1, replaceStr);
        }
        return result.toString();
    }
}

@Service
public class SensitiveWordManager {
    @Autowired
    private SensitiveWordRepository wordRepository;
    
    private volatile SensitiveWordFilter currentFilter;
    private ScheduledExecutorService scheduler = 
        Executors.newSingleThreadScheduledExecutor();
    
    @PostConstruct
    public void init() {
        loadWords();
        // 每隔1小时自动刷新一次
        scheduler.scheduleAtFixedRate(this::loadWords, 1, 1, TimeUnit.HOURS);
    }
    
    public void loadWords() {
        try {
            Set<String> newWordSet = wordRepository.findAllActiveWords();
            SensitiveWordFilter newFilter = new SensitiveWordFilter();
            newFilter.init(newWordSet);
            this.currentFilter = newFilter; // 原子性切换引用
        } catch (Exception e) {
            // 记录日志，继续使用旧版本词库
        }
    }
    
    // 提供手动刷新接口
    @EventListener
    public void handleRefreshEvent(RefreshEvent event) {
        loadWords();
    }
}

@Aspect
@Component
public class SensitiveWordAspect {
    @Autowired
    private SensitiveWordFilter sensitiveWordFilter;
    
    // 拦截所有带有@SensitiveFilter注解的方法
    @Around("@annotation(sensitiveFilter)")
    public Object filterSensitiveWords(ProceedingJoinPoint joinPoint, 
                                     SensitiveFilter sensitiveFilter) throws Throwable {
        Object[] args = joinPoint.getArgs();
        
        // 遍历方法参数，处理String类型参数
        for (int i = 0; i < args.length; i++) {
            if (args[i] instanceof String) {
                String originalText = (String) args[i];
                
                if (sensitiveFilter.action() == Action.REPLACE) {
                    args[i] = sensitiveWordFilter.filter(originalText, 
                        sensitiveFilter.replacement());
                } else if (sensitiveFilter.action() == Action.REJECT) {
                    if (sensitiveWordFilter.containsSensitiveWord(originalText)) {
                        throw new IllegalArgumentException("内容包含违规词汇");
                    }
                }
            }
        }
        
        return joinPoint.proceed(args);
    }
}

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SensitiveFilter {
    Action action() default Action.REPLACE;
    String replacement() default "***";
}

@Entity
public class Comment {
    @Id
    private Long id;
    private String content;
    private String author;
    private LocalDateTime createTime;
    private String status; // PENDING, APPROVED, REJECTED
    
    // 审核后可见内容
    public String getVisibleContent() {
        return "APPROVED".equals(status) ? content : "该评论正在审核中";
    }
}