基于Jackson实现从字符串到策略模式的类型安全转换方案

问题背景 #

当前从UI执行带逻辑运算符的过滤查询时，采用枚举映射+switch语句将运算符转换为Hibernate Criteria Builder的Predicate。但随着匹配器类型增多，switch会变得臃肿难维护；用Map查找本质上只是换了形式，同样需要大量硬编码配置，无法从根本上解决问题。

需要一种类型安全的方案，直接将JSON中的匹配器字符串（如"text_equals"）反序列化为对应的策略实现类（如TextEqualsMatcher），每个实现类独立负责构建对应的Predicate。同时希望结合枚举常量管理匹配器类型名，避免硬编码字符串。

期望处理的JSON示例：

{
  "type": "field",
  "id": "104e578c-6841-48e5-8ee0-927a1eaa0fbe",
  "value": "Ukraine",
  "matcher": "text_equals"
}

核心实现思路 #

利用Jackson的多态反序列化特性，结合枚举统一管理匹配器类型与实现类的映射，实现类型安全的转换，完全消除switch/Map硬编码问题。

1. 定义匹配器类型枚举 #

用枚举统一管理所有匹配器的类型名和对应的实现类，避免字符串硬编码：

public enum MatcherType {
    TEXT_EQUALS("text_equals", TextEqualsMatcher.class),
    TEXT_CONTAINS("text_contains", TextContainsMatcher.class),
    NUMBER_GREATER_THAN("number_greater_than", NumberGreaterThanMatcher.class);

    private final String typeName;
    private final Class<? extends FieldMatcher> matcherClass;

    MatcherType(String typeName, Class<? extends FieldMatcher> matcherClass) {
        this.typeName = typeName;
        this.matcherClass = matcherClass;
    }

    public String getTypeName() {
        return typeName;
    }

    public Class<? extends FieldMatcher> getMatcherClass() {
        return matcherClass;
    }

    // 根据类型名获取枚举值，用于校验未知类型
    public static MatcherType fromTypeName(String typeName) {
        for (MatcherType type : values()) {
            if (type.typeName.equals(typeName)) {
                return type;
            }
        }
        throw new IllegalArgumentException("未知匹配器类型: " + typeName);
    }
}

2. 配置FieldMatcher接口的多态反序列化 #

在FieldMatcher接口上配置Jackson多态规则，指定类型信息来自外部的matcher字段：

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;

@JsonTypeInfo(
        use = JsonTypeInfo.Id.NAME,
        include = JsonTypeInfo.As.EXTERNAL_PROPERTY,
        property = "matcher" // 类型信息来自外部的"matcher"字段
)
public interface FieldMatcher {
    // 泛化参数支持不同字段类型（字符串、数字等）
    Predicate toPredicate(CriteriaBuilder cb, Path<?> path, Object value);
}

3. 实现具体的匹配器类 #

每个匹配器类通过@JsonTypeName绑定枚举中的类型名，独立实现Predicate构建逻辑：

import com.fasterxml.jackson.annotation.JsonTypeName;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;

@JsonTypeName(MatcherType.TEXT_EQUALS.getTypeName())
public class TextEqualsMatcher implements FieldMatcher {
    @Override
    public Predicate toPredicate(CriteriaBuilder cb, Path<?> path, Object value) {
        return cb.equal(path, value);
    }
}

@JsonTypeName(MatcherType.TEXT_CONTAINS.getTypeName())
public class TextContainsMatcher implements FieldMatcher {
    @Override
    public Predicate toPredicate(CriteriaBuilder cb, Path<?> path, Object value) {
        return cb.like(path, "%" + value + "%");
    }
}

@JsonTypeName(MatcherType.NUMBER_GREATER_THAN.getTypeName())
public class NumberGreaterThanMatcher implements FieldMatcher {
    @Override
    public Predicate toPredicate(CriteriaBuilder cb, Path<?> path, Object value) {
        return cb.greaterThan(path.as(Number.class), (Number) value);
    }
}

4. 实现Filter接口与FieldElement记录 #

定义Filter统一接口，FieldElement作为字段过滤的具体实现，Jackson会自动反序列化matcher字段为对应实现类：

import com.fasterxml.jackson.annotation.JsonTypeName;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Root;
import jakarta.persistence.criteria.Predicate;
import java.util.UUID;

public interface Filter {
    Predicate toPredicate(CriteriaBuilder cb, Root<?> root);
}

@JsonTypeName("field")
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
public record FieldElement(
        UUID id, // 实体字段的唯一标识（假设为字段名或映射ID）
        String value,
        FieldMatcher matcher
) implements Filter {
    @Override
    public Predicate toPredicate(CriteriaBuilder cb, Root<?> root) {
        // 根据id获取实体对应的字段Path
        Path<?> path = root.get(id.toString());
        return matcher.toPredicate(cb, path, value);
    }
}

5. 配置Jackson支持多态反序列化 #

在Spring Boot环境中，通过配置ObjectMapper注册所有匹配器子类，确保Jackson能正确识别并反序列化：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JacksonConfig {
    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        // 注册Filter的子类（FieldElement）
        mapper.registerSubtypes(FieldElement.class);
        // 注册所有FieldMatcher的子类（从枚举中批量获取）
        mapper.registerSubtypes(
                MatcherType.values()
                        .stream()
                        .map(MatcherType::getMatcherClass)
                        .toArray(Class[]::new)
        );
        return mapper;
    }
}

方案优势 #

• 开闭原则：新增匹配器只需添加枚举值和实现类，无需修改原有代码，彻底消除switch/Map维护问题。
• 类型安全：所有匹配器类型由枚举统一管理，避免字符串拼写错误，编译期即可发现问题。
• 职责单一：每个匹配器独立负责自身的Predicate构建逻辑，代码清晰易维护。
• 低耦合：JSON与Hibernate的耦合被限制在匹配器实现类中，核心逻辑无冗余依赖。

注意事项 #

• 依赖注入支持：如果匹配器需要依赖Spring Bean（如自定义函数、国际化服务），可将匹配器类标记为@Component，并通过Jackson的SpringModule实现依赖注入。
• 字段类型适配：若需处理多种字段类型（日期、布尔等），可在toPredicate方法中添加类型判断，或拆分出更细分的Matcher接口（如DateMatcher）。
• 异常处理：在枚举的fromTypeName方法中处理未知匹配器类型，抛出明确异常便于调试。

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