泛型TemplateEngine接口工厂设计：解决编译错误与避免不安全转换

我完全理解你遇到的这个编译错误——这是泛型通配符带来的典型类型擦除与类型安全矛盾问题。当工厂返回TemplateEngine<?>时，编译器无法确定通配符?对应的具体类型，导致compileTemplate返回的对象和merge方法要求的参数类型无法匹配，哪怕它们本质上是同一个类型。

下面我会给出几种无需强制类型转换、同时保持工厂与客户端对具体实现解耦的安全设计方案：

方案一：给工厂方法添加泛型约束，让客户端显式声明类型 #

我们可以修改TemplateEngineFactory的getTemplateEngine方法，引入泛型参数，同时在注册时确保每个模板语言对应正确的TemplateEngine类型。这样客户端可以显式指定泛型类型，编译器就能完成类型检查：

public class TemplateEngineFactory {
    private Map<String, TemplateEngine<?>> TEMPLATE_ENGINE_REGISTRY = new HashMap<>();

    @PostConstruct
    public void init() {
        // 注册实现类示例
        TEMPLATE_ENGINE_REGISTRY.put("moustache", new MoustacheTemplateEngine());
        TEMPLATE_ENGINE_REGISTRY.put("freemarker", new FreemarkerTemplateEngine());
    }

    @SuppressWarnings("unchecked")
    public <T> TemplateEngine<T> getTemplateEngine(String templateLang, Class<T> templateType) {
        TemplateEngine<?> engine = TEMPLATE_ENGINE_REGISTRY.get(templateLang);
        // 校验返回的engine泛型类型与传入的templateType匹配
        if (engine != null && templateType.isAssignableFrom(getTemplateType(engine))) {
            return (TemplateEngine<T>) engine;
        }
        throw new IllegalArgumentException("Unsupported template language or type mismatch");
    }

    // 辅助方法：获取TemplateEngine实现类的泛型实际类型
    private Class<?> getTemplateType(TemplateEngine<?> engine) {
        Type type = engine.getClass().getGenericInterfaces()[0];
        if (type instanceof ParameterizedType) {
            return (Class<?>) ((ParameterizedType) type).getActualTypeArguments()[0];
        }
        throw new IllegalArgumentException("TemplateEngine implementation does not use parameterized type");
    }
}

客户端调用时，只需指定对应的模板类型：

Map<String, Object> data = new HashMap<>();
data.put("name", "Tom");

TemplateEngine<Mustache> templateEngine = factory.getTemplateEngine("moustache", Mustache.class);
Mustache compiledTemplate = templateEngine.compileTemplate("Hi {{name}}");
templateEngine.merge(compiledTemplate, data); // 编译通过，类型安全

这个方案保留了泛型的类型安全特性，同时通过工厂内部的校验避免了不安全转换的风险。

方案二：封装模板操作，隐藏泛型参数（更友好的客户端API） #

如果不想让客户端处理复杂的泛型类型，我们可以调整接口设计，把compile和merge的逻辑封装到一个统一的Template对象中，让TemplateEngine返回这个对象，彻底隐藏底层的泛型参数T：

首先定义统一的Template接口：

public interface Template {
    void merge(Map<String, Object> data);
}

然后修改TemplateEngine接口，移除泛型参数：

public interface TemplateEngine {
    Template compileTemplate(String templateStr);
    String getTemplateLang();
}

调整实现类（以Moustache为例）：

public class MoustacheTemplateEngine implements TemplateEngine {
    @Override
    public Template compileTemplate(String templateStr) {
        Mustache mustache = // 执行模板编译逻辑
        return new Template() {
            @Override
            public void merge(Map<String, Object> data) {
                // 执行Mustache的模板合并逻辑，比如输出到控制台
                mustache.execute(new PrintWriter(System.out), data).flush();
            }
        };
    }

    @Override
    public String getTemplateLang() {
        return "moustache";
    }
}

工厂类也可以简化：

public class TemplateEngineFactory {
    private Map<String, TemplateEngine> TEMPLATE_ENGINE_REGISTRY = new HashMap<>();

    @PostConstruct
    public void init() {
        TEMPLATE_ENGINE_REGISTRY.put("moustache", new MoustacheTemplateEngine());
        TEMPLATE_ENGINE_REGISTRY.put("freemarker", new FreemarkerTemplateEngine());
    }

    public TemplateEngine getTemplateEngine(String templateLang) {
        return TEMPLATE_ENGINE_REGISTRY.get(templateLang);
    }
}

客户端调用变得异常简洁，完全无需关心泛型：

Map<String, Object> data = new HashMap<>();
data.put("name", "Tom");

TemplateEngine templateEngine = factory.getTemplateEngine("moustache");
Template template = templateEngine.compileTemplate("Hi {{name}}");
template.merge(data); // 编译通过，类型安全，API更友好

这个方案的优势在于彻底隐藏了底层模板类型，客户端API简洁直观，同时保持了类型安全，不需要任何转换，也是大多数成熟模板引擎框架的常用设计方式。

方案三：结合Spring实现自动注册（可选优化） #

如果你的项目基于Spring环境，可以利用Spring的依赖注入自动注册TemplateEngine实现类，无需手动在工厂中添加：

@Component
public class TemplateEngineFactory {
    private Map<String, TemplateEngine> TEMPLATE_ENGINE_REGISTRY = new HashMap<>();

    @Autowired
    public void setTemplateEngines(List<TemplateEngine> engines) {
        for (TemplateEngine engine : engines) {
            TEMPLATE_ENGINE_REGISTRY.put(engine.getTemplateLang(), engine);
        }
    }

    public TemplateEngine getTemplateEngine(String templateLang) {
        return TEMPLATE_ENGINE_REGISTRY.get(templateLang);
    }
}

后续新增TemplateEngine实现类时，只需给类添加@Component注解，工厂会自动完成注册，无需修改工厂代码。

内容的提问来源于stack exchange，提问作者Somu