如何在Thymeleaf中通过编程方式处理缺失或拼写错误的模板参数？

完全理解你的痛点——手动给所有模板加校验太繁琐，而且难保不会漏掉。好在Thymeleaf提供了扩展点，让你可以在TemplateRenderer内部全局处理缺失/拼写错误的变量，不需要修改任何模板文件。下面给你两种实用方案：

方案一：自定义变量解析器（全局生效） #

通过实现IVariableResolver，我们可以拦截所有变量的解析过程，当变量不存在时直接抛出异常或记录警告。这种方式是全局生效的，所有模板都会遵循这个规则。

1. 编写严格模式的变量解析器 #

import org.thymeleaf.context.IExpressionContext;
import org.thymeleaf.exceptions.TemplateProcessingException;
import org.thymeleaf.expression.AbstractVariableResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;

public class StrictVariableResolver extends AbstractVariableResolver {
    private static final Logger logger = LoggerFactory.getLogger(StrictVariableResolver.class);
    // 排除Thymeleaf内置变量，避免误判
    private static final Set<String> INTERNAL_VARS = Set.of(
        "ctx", "vars", "locale", "dates", "numbers", "strings", "objects", "lists", "maps"
    );
    
    private final boolean throwOnMissing;

    public StrictVariableResolver(boolean throwOnMissing) {
        this.throwOnMissing = throwOnMissing;
    }

    @Override
    public Object resolveVariable(IExpressionContext context, String varName) {
        // 跳过内置变量的检查
        if (INTERNAL_VARS.contains(varName) || varName.startsWith("#")) {
            return super.resolveVariable(context, varName);
        }
        
        Object value = context.getVariable(varName);
        if (value == null) {
            String msg = String.format("模板变量 '%s' 未在上下文定义（可能拼写错误或缺失）", varName);
            if (throwOnMissing) {
                throw new TemplateProcessingException(msg);
            } else {
                logger.warn(msg);
            }
        }
        return value;
    }
}

2. 在TemplateRenderer中注册这个解析器 #

修改你的TemplateRenderer初始化逻辑，把自定义解析器添加到模板引擎中：

class TemplateRenderer {
    private final TemplateEngine templateEngine;

    public TemplateRenderer() {
        this.templateEngine = new TemplateEngine();
        StringTemplateResolver resolver = new StringTemplateResolver();
        templateEngine.setTemplateResolver(resolver);
        
        // 注册严格解析器：true表示缺失变量时抛异常，false只打警告
        templateEngine.addVariableResolver(new StrictVariableResolver(true));
    }

    public String render(String template, Map<String, Object> variables) {
        IContext context = new Context(Locale.GERMAN, variables);
        return templateEngine.process(template, context);
    }
}

方案二：自定义上下文（灵活控制） #

如果你需要针对不同的渲染请求灵活切换严格模式（比如某些模板允许缺失变量），可以自定义Context类，重写变量获取逻辑：

1. 编写严格模式的Context #

import org.thymeleaf.context.Context;
import org.thymeleaf.exceptions.TemplateProcessingException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

public class StrictContext extends Context {
    private static final Logger logger = LoggerFactory.getLogger(StrictContext.class);
    private static final Set<String> INTERNAL_VARS = Set.of(
        "ctx", "vars", "locale", "dates", "numbers", "strings"
    );
    
    private final boolean throwOnMissing;

    public StrictContext(Locale locale, Map<String, Object> variables, boolean throwOnMissing) {
        super(locale, variables);
        this.throwOnMissing = throwOnMissing;
    }

    @Override
    public Object getVariable(String varName) {
        // 跳过内置变量检查
        if (INTERNAL_VARS.contains(varName) || varName.startsWith("#")) {
            return super.getVariable(varName);
        }
        
        Object value = super.getVariable(varName);
        if (value == null) {
            String msg = String.format("模板变量 '%s' 未在上下文定义", varName);
            if (throwOnMissing) {
                throw new TemplateProcessingException(msg);
            } else {
                logger.warn(msg);
            }
        }
        return value;
    }
}

2. 在render方法中使用自定义Context #

修改TemplateRenderer的render方法，替换默认的Context：

public String render(String template, Map<String, Object> variables) {
    // 这里可以根据需求动态设置throwOnMissing的值
    IContext context = new StrictContext(Locale.GERMAN, variables, true);
    return templateEngine.process(template, context);
}

效果测试 #

用你提供的Main类测试，当变量缺失或拼写错误时：

• 如果设置throwOnMissing=true，会直接抛出TemplateProcessingException，终止渲染
• 如果设置throwOnMissing=false，会在日志中输出警告，同时继续渲染（缺失变量的位置会显示空内容）

这样就完美解决了你的问题——不需要修改任何模板，所有校验逻辑都集中在TemplateRenderer内部，而且能有效防止变量拼写错误或遗漏。

备注：内容来源于stack exchange，提问作者Sören