// 示例：变量类型定义
public enum VariableType {
    STRING("string", String.class),
    INTEGER("integer", Integer.class),
    DECIMAL("decimal", BigDecimal.class),
    DATE("date", Date.class),
    BOOLEAN("boolean", Boolean.class),
    LIST("list", List.class),
    MAP("map", Map.class);
    
    private final String typeName;
    private final Class<?> javaType;
    
    VariableType(String typeName, Class<?> javaType) {
        this.typeName = typeName;
        this.javaType = javaType;
    }
    
    // getter方法...
}

// 示例：变量定义
public class TemplateVariable {
    private String name;
    private VariableType type;
    private boolean required;
    private String description;
    private Object defaultValue;
    private String format; // 格式化规则
    private List<String> validationRules; // 验证规则
    
    // 构造函数、getter和setter方法...
}

关键设计要点：

类型安全：支持多种变量类型确保类型安全
必填控制：支持变量的必填和可选设置
默认值：支持变量默认值设置
验证规则：支持变量值的验证规则

变量作用域

// 示例：变量作用域管理
public class VariableScope {
    // 全局变量（系统预定义）
    private Map<String, Object> globalVariables;
    
    // 模板变量（模板定义的变量）
    private Map<String, TemplateVariable> templateVariables;
    
    // 运行时变量（调用时传入的变量）
    private Map<String, Object> runtimeVariables;
    
    // 上下文变量（处理过程中生成的变量）
    private Map<String, Object> contextVariables;
    
    public Object resolveVariable(String variableName) {
        // 按照作用域优先级解析变量
        if (runtimeVariables.containsKey(variableName)) {
            return runtimeVariables.get(variableName);
        }
        
        if (contextVariables.containsKey(variableName)) {
            return contextVariables.get(variableName);
        }
        
        if (templateVariables.containsKey(variableName) && 
            templateVariables.get(variableName).getDefaultValue() != null) {
            return templateVariables.get(variableName).getDefaultValue();
        }
        
        if (globalVariables.containsKey(variableName)) {
            return globalVariables.get(variableName);
        }
        
        return null;
    }
}

关键设计要点：

作用域层次：定义清晰的变量作用域层次
优先级控制：明确各作用域的优先级顺序
默认处理：合理处理未定义变量的情况
类型转换：支持变量值的类型转换

变量替换实现

基础替换算法

// 示例：基础变量替换实现
@Component
public class BasicVariableReplacer {
    
    public String replaceVariables(String template, Map<String, Object> variables) {
        if (template == null || template.isEmpty()) {
            return template;
        }
        
        String result = template;
        Pattern pattern = Pattern.compile("\\{\\{([a-zA-Z0-9_\\.]+)\\}\\}");
        Matcher matcher = pattern.matcher(template);
        
        while (matcher.find()) {
            String variableName = matcher.group(1);
            Object variableValue = variables.get(variableName);
            
            if (variableValue != null) {
                String replacement = variableValue.toString();
                result = result.replace(matcher.group(0), replacement);
            }
        }
        
        return result;
    }
}

关键实现要点：

正则匹配：使用正则表达式匹配变量占位符
安全替换：避免重复替换和安全问题
性能优化：优化替换算法的性能
错误处理：妥善处理替换过程中的异常

高级替换功能

// 示例：高级变量替换实现
@Component
public class AdvancedVariableReplacer {
    
    public String replaceVariables(String template, VariableContext context) {
        if (template == null || template.isEmpty()) {
            return template;
        }
        
        // 支持点号访问嵌套属性
        String result = replaceNestedVariables(template, context);
        
        // 支持条件表达式
        result = evaluateConditionalExpressions(result, context);
        
        // 支持循环表达式
        result = processLoopExpressions(result, context);
        
        // 支持格式化函数
        result = applyFormattingFunctions(result, context);
        
        return result;
    }
    
    private String replaceNestedVariables(String template, VariableContext context) {
        Pattern pattern = Pattern.compile("\\{\\{([a-zA-Z0-9_\\.]+)\\}\\}");
        Matcher matcher = pattern.matcher(template);
        StringBuffer buffer = new StringBuffer();
        
        while (matcher.find()) {
            String variablePath = matcher.group(1);
            Object value = getNestedValue(context, variablePath);
            String replacement = value != null ? value.toString() : "";
            matcher.appendReplacement(buffer, replacement);
        }
        matcher.appendTail(buffer);
        
        return buffer.toString();
    }
    
    private Object getNestedValue(VariableContext context, String path) {
        String[] parts = path.split("\\.");
        Object currentValue = context.resolveVariable(parts[0]);
        
        for (int i = 1; i < parts.length && currentValue != null; i++) {
            if (currentValue instanceof Map) {
                currentValue = ((Map<?, ?>) currentValue).get(parts[i]);
            } else {
                try {
                    // 尝试通过反射获取属性值
                    currentValue = PropertyUtils.getProperty(currentValue, parts[i]);
                } catch (Exception e) {
                    currentValue = null;
                }
            }
        }
        
        return currentValue;
    }
}

关键功能要点：

嵌套访问：支持通过点号访问嵌套属性
条件表达式：支持基于条件的动态内容生成
循环处理：支持列表数据的迭代处理
格式化函数：支持变量值的格式化处理

内容审核机制

内容审核是确保通知内容安全合规的重要保障：

敏感词过滤

敏感词库设计

// 示例：敏感词库设计
@Component
public class SensitiveWordFilter {
    
    private final TrieNode root = new TrieNode();
    private final Set<String> whiteList = new HashSet<>();
    
    @PostConstruct
    public void initSensitiveWords() {
        // 初始化敏感词库
        List<String> sensitiveWords = loadSensitiveWords();
        for (String word : sensitiveWords) {
            addSensitiveWord(word.trim());
        }
        
        // 初始化白名单
        List<String> whiteWords = loadWhiteList();
        whiteList.addAll(whiteWords);
    }
    
    public void addSensitiveWord(String word) {
        if (word == null || word.isEmpty()) {
            return;
        }
        
        TrieNode current = root;
        for (char c : word.toCharArray()) {
            current = current.getChildren().computeIfAbsent(c, k -> new TrieNode());
        }
        current.setEnd(true);
        current.setWord(word);
    }
    
    public ContentCheckResult filterContent(String content) {
        if (content == null || content.isEmpty()) {
            return new ContentCheckResult(true, Collections.emptyList());
        }
        
        List<SensitiveWordHit> hits = new ArrayList<>();
        char[] chars = content.toCharArray();
        
        for (int i = 0; i < chars.length; i++) {
            TrieNode current = root;
            for (int j = i; j < chars.length; j++) {
                char c = chars[j];
                current = current.getChildren().get(c);
                if (current == null) {
                    break;
                }
                
                if (current.isEnd()) {
                    String word = current.getWord();
                    // 检查是否在白名单中
                    if (!whiteList.contains(word)) {
                        hits.add(new SensitiveWordHit(word, i, j));
                    }
                }
            }
        }
        
        return new ContentCheckResult(hits.isEmpty(), hits);
    }
    
    // Trie节点定义
    private static class TrieNode {
        private final Map<Character, TrieNode> children = new HashMap<>();
        private boolean end = false;
        private String word;
        
        // getter和setter方法...
    }
}

关键设计要点：

Trie树结构：使用Trie树提高敏感词匹配效率
白名单机制：支持白名单避免误杀
实时更新：支持敏感词库的实时更新
性能优化：优化匹配算法的性能

过滤策略配置

// 示例：过滤策略配置
@Configuration
public class ContentFilterConfig {
    
    @Bean
    public ContentFilterChain contentFilterChain() {
        ContentFilterChain chain = new ContentFilterChain();
        
        // 敏感词过滤
        chain.addFilter(new SensitiveWordContentFilter());
        
        // 政治敏感内容过滤
        chain.addFilter(new PoliticalContentFilter());
        
        // 色情内容过滤
        chain.addFilter(new PornographicContentFilter());
        
        // 广告内容过滤
        chain.addFilter(new AdvertisementContentFilter());
        
        // 自定义过滤器
        chain.addFilter(new CustomContentFilter());
        
        return chain;
    }
}

// 内容过滤链
public class ContentFilterChain {
    private final List<ContentFilter> filters = new ArrayList<>();
    
    public void addFilter(ContentFilter filter) {
        filters.add(filter);
    }
    
    public ContentCheckResult filterContent(String content, FilterContext context) {
        ContentCheckResult result = new ContentCheckResult(true, Collections.emptyList());
        
        for (ContentFilter filter : filters) {
            if (!filter.isEnabled(context)) {
                continue;
            }
            
            ContentCheckResult filterResult = filter.filter(content, context);
            if (!filterResult.isPass()) {
                result = filterResult;
                if (filter.isBlocking()) {
                    break; // 阻断式过滤器，发现违规立即停止
                }
            }
        }
        
        return result;
    }
}

关键配置要点：

过滤链设计：支持多种过滤器的组合使用
策略配置：支持不同场景的过滤策略配置
阻断机制：支持阻断式和非阻断式过滤
扩展支持：支持自定义过滤器的扩展

合规性检查

法规适配

// 示例：法规适配检查
@Component
public class ComplianceChecker {
    
    private final Map<String, ComplianceRule> rules = new HashMap<>();
    
    @PostConstruct
    public void initComplianceRules() {
        // 加载各地区法规规则
        rules.put("GDPR", new GDPRComplianceRule());
        rules.put("CCPA", new CCPAComplianceRule());
        rules.put("个人信息保护法", new PersonalInfoProtectionRule());
        rules.put("广告法", new AdvertisingLawRule());
    }
    
    public ComplianceCheckResult checkCompliance(String content, String region, 
                                               Map<String, Object> context) {
        ComplianceRule rule = rules.get(region);
        if (rule == null) {
            return new ComplianceCheckResult(true, "未找到对应法规规则");
        }
        
        return rule.check(content, context);
    }
}

// GDPR合规规则示例
public class GDPRComplianceRule implements ComplianceRule {
    
    @Override
    public ComplianceCheckResult check(String content, Map<String, Object> context) {
        List<String> violations = new ArrayList<>();
        
        // 检查是否包含个人敏感信息
        if (containsPersonalSensitiveInfo(content)) {
            violations.add("包含个人敏感信息，需用户明确同意");
        }
        
        // 检查是否包含追踪标识
        if (containsTrackingIdentifiers(content)) {
            violations.add("包含追踪标识，需符合GDPR要求");
        }
        
        // 检查是否包含数据处理说明
        if (!containsDataProcessingNotice(content)) {
            violations.add("缺少数据处理说明");
        }
        
        if (violations.isEmpty()) {
            return new ComplianceCheckResult(true, "符合GDPR要求");
        } else {
            return new ComplianceCheckResult(false, String.join("; ", violations));
        }
    }
    
    private boolean containsPersonalSensitiveInfo(String content) {
        // 实现个人敏感信息检测逻辑
        return false;
    }
    
    private boolean containsTrackingIdentifiers(String content) {
        // 实现追踪标识检测逻辑
        return false;
    }
    
    private boolean containsDataProcessingNotice(String content) {
        // 实现数据处理说明检测逻辑
        return content.contains("数据处理") || content.contains("privacy");
    }
}

关键检查要点：

法规适配：支持不同地区的法规要求
动态检查：根据上下文动态检查合规性
详细反馈：提供详细的违规信息和建议
规则扩展：支持新法规规则的快速添加

多语言支持

多语言支持是国际化通知平台的重要特性：

语言包管理

本地化资源设计

// 示例：本地化资源管理
@Component
public class LocalizationManager {
    
    private final Map<String, ResourceBundle> languageBundles = new HashMap<>();
    private final Map<String, MessageFormat> messageFormats = new ConcurrentHashMap<>();
    
    @PostConstruct
    public void initLanguageBundles() {
        // 加载各语言的资源包
        languageBundles.put("zh-CN", ResourceBundle.getBundle("messages", Locale.SIMPLIFIED_CHINESE));
        languageBundles.put("en-US", ResourceBundle.getBundle("messages", Locale.US));
        languageBundles.put("ja-JP", ResourceBundle.getBundle("messages", Locale.JAPAN));
        // 更多语言...
    }
    
    public String getMessage(String key, String language, Object... params) {
        ResourceBundle bundle = languageBundles.get(language);
        if (bundle == null) {
            // 回退到默认语言
            bundle = languageBundles.get("zh-CN");
        }
        
        if (bundle != null && bundle.containsKey(key)) {
            String pattern = bundle.getString(key);
            if (params.length > 0) {
                // 使用MessageFormat进行参数替换
                String cacheKey = language + ":" + key;
                MessageFormat format = messageFormats.computeIfAbsent(cacheKey, 
                    k -> new MessageFormat(pattern, Locale.forLanguageTag(language)));
                return format.format(params);
            }
            return pattern;
        }
        
        return key; // 未找到时返回键名
    }
    
    public String localizeTemplate(String templateId, String language) {
        // 构造语言特定的模板键
        String localizedKey = templateId + "." + language;
        
        // 从数据库或缓存中获取本地化模板
        Template localizedTemplate = templateRepository.findByTemplateIdAndLanguage(
            templateId, language);
            
        if (localizedTemplate != null) {
            return localizedTemplate.getContent();
        }
        
        // 回退到默认语言模板
        return templateRepository.findByTemplateIdAndLanguage(
            templateId, "zh-CN").getContent();
    }
}

关键设计要点：

资源包管理：统一管理各语言的资源包
参数替换：支持带参数的消息格式化
语言回退：支持语言回退机制
缓存优化：缓存格式化对象提高性能

模板本地化

// 示例：模板本地化实现
@Service
public class TemplateLocalizationService {
    
    @Autowired
    private TemplateRepository templateRepository;
    
    @Autowired
    private LocalizationManager localizationManager;
    
    public LocalizedTemplateResult renderLocalizedTemplate(
        String templateId, String language, Map<String, Object> variables) {
        
        // 获取本地化模板
        String templateContent = localizationManager.localizeTemplate(templateId, language);
        
        // 获取本地化变量
        Map<String, Object> localizedVariables = localizeVariables(variables, language);
        
        // 渲染模板
        String renderedContent = renderTemplate(templateContent, localizedVariables);
        
        return new LocalizedTemplateResult(renderedContent, language);
    }
    
    private Map<String, Object> localizeVariables(
        Map<String, Object> variables, String language) {
        
        Map<String, Object> localizedVariables = new HashMap<>();
        
        for (Map.Entry<String, Object> entry : variables.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            
            if (value instanceof String) {
                // 对字符串变量进行本地化处理
                String localizedValue = localizationManager.getMessage(
                    (String) value, language);
                localizedVariables.put(key, localizedValue);
            } else if (value instanceof List) {
                // 对列表变量进行本地化处理
                localizedVariables.put(key, localizeList((List<?>) value, language));
            } else {
                localizedVariables.put(key, value);
            }
        }
        
        return localizedVariables;
    }
    
    private List<?> localizeList(List<?> list, String language) {
        List<Object> localizedList = new ArrayList<>();
        for (Object item : list) {
            if (item instanceof String) {
                localizedList.add(localizationManager.getMessage((String) item, language));
            } else if (item instanceof Map) {
                localizedList.add(localizeVariables((Map<String, Object>) item, language));
            } else {
                localizedList.add(item);
            }
        }
        return localizedList;
    }
}

关键实现要点：

模板本地化：支持模板内容的本地化
变量本地化：支持变量值的本地化处理
嵌套结构：支持复杂数据结构的本地化
性能优化：优化本地化处理的性能

模板引擎架构设计

合理的架构设计是模板引擎高效稳定运行的基础：

分层架构

解析层设计

// 示例：模板解析层
@Component
public class TemplateParser {
    
    private final List<TemplateProcessor> processors = Arrays.asList(
        new VariableReplacementProcessor(),
        new ConditionalProcessor(),
        new LoopProcessor(),
        new FunctionProcessor()
    );
    
    public ParsedTemplate parse(String templateContent) {
        TemplateAST ast = new TemplateAST();
        
        // 词法分析
        List<Token> tokens = lexer.tokenize(templateContent);
        
        // 语法分析
        ast = parser.parse(tokens);
        
        return new ParsedTemplate(ast, templateContent);
    }
    
    public String render(ParsedTemplate parsedTemplate, TemplateContext context) {
        String result = parsedTemplate.getOriginalContent();
        
        // 按顺序执行各处理器
        for (TemplateProcessor processor : processors) {
            result = processor.process(result, context);
        }
        
        return result;
    }
}

// 抽象语法树节点
public abstract class ASTNode {
    protected String content;
    protected Map<String, Object> attributes;
    protected List<ASTNode> children;
    
    // 构造函数、getter和setter方法...
}

// 变量节点
public class VariableNode extends ASTNode {
    private String variableName;
    private String format;
    private List<String> filters;
    
    @Override
    public String evaluate(TemplateContext context) {
        Object value = context.getVariable(variableName);
        if (value == null) {
            return "";
        }
        
        // 应用格式化和过滤器
        value = applyFormatting(value, format);
        value = applyFilters(value, filters);
        
        return value.toString();
    }
}

关键架构要点：

分层设计：清晰的分层架构便于维护和扩展
模块化：各功能模块独立设计便于替换
AST设计：使用抽象语法树提高处理效率
可扩展：支持新功能的快速扩展

执行引擎

// 示例：模板执行引擎
@Component
public class TemplateExecutionEngine {
    
    @Autowired
    private TemplateParser templateParser;
    
    @Autowired
    private ContentValidator contentValidator;
    
    @Autowired
    private PerformanceMonitor performanceMonitor;
    
    public TemplateRenderResult renderTemplate(
        String templateId, Map<String, Object> variables, RenderOptions options) {
        
        long startTime = System.currentTimeMillis();
        
        try {
            // 获取模板
            Template template = templateRepository.findByTemplateId(templateId);
            if (template == null) {
                throw new TemplateNotFoundException("模板未找到: " + templateId);
            }
            
            // 验证变量
            ValidationResult validation = validateVariables(template, variables);
            if (!validation.isValid()) {
                return TemplateRenderResult.failure(validation.getErrors());
            }
            
            // 解析模板
            ParsedTemplate parsedTemplate = templateParser.parse(template.getContent());
            
            // 创建上下文
            TemplateContext context = new TemplateContext(variables, options);
            
            // 渲染模板
            String renderedContent = templateParser.render(parsedTemplate, context);
            
            // 内容审核
            if (options.isContentValidationEnabled()) {
                ContentCheckResult checkResult = contentValidator.validate(renderedContent);
                if (!checkResult.isPass()) {
                    return TemplateRenderResult.failure(
                        "内容审核失败: " + checkResult.getViolations());
                }
            }
            
            // 性能监控
            long executionTime = System.currentTimeMillis() - startTime;
            performanceMonitor.recordTemplateRender(templateId, executionTime);
            
            return TemplateRenderResult.success(renderedContent);
            
        } catch (Exception e) {
            log.error("模板渲染失败: templateId={}, error={}", templateId, e.getMessage(), e);
            return TemplateRenderResult.failure("模板渲染失败: " + e.getMessage());
        }
    }
    
    private ValidationResult validateVariables(Template template, Map<String, Object> variables) {
        ValidationResult result = new ValidationResult();
        
        for (TemplateVariable templateVar : template.getVariables()) {
            Object value = variables.get(templateVar.getName());
            
            // 必填检查
            if (templateVar.isRequired() && value == null) {
                result.addError("变量 " + templateVar.getName() + " 为必填项");
                continue;
            }
            
            // 类型检查
            if (value != null && !isTypeMatch(value, templateVar.getType())) {
                result.addError("变量 " + templateVar.getName() + " 类型不匹配");
            }
            
            // 格式验证
            if (value != null && !validateFormat(value, templateVar.getFormat())) {
                result.addError("变量 " + templateVar.getName() + " 格式验证失败");
            }
        }
        
        return result;
    }
}