Jackson ObjectMapper泛型方法类型解析异常，如何封装TypeReference？

给定JSON：

{
 "List": [
  {
   "Field1": 1678493915,
   "Field2": "A string"
  }
 ]
}

在工具类中定义非泛型方法时：

public static Map<String, List<Map<String, String>>> readJSON(String json) throws JsonProcessingException {
    return new ObjectMapper().readValue(json, new TypeReference<>() {});
}

字段Field1会被解析为String，符合预期。但为了通用性，编写泛型方法：

public static <T> T readJSON2(String json) throws JsonProcessingException {
    return new ObjectMapper().readValue(json, new TypeReference<>(){});
}

调用方式：

Map<String, List<Map<String, String>>> data = readJSON2(jsonString);

此时Field1被解析为Integer，不符合需求。

改用带TypeReference参数的方法可正常工作（Field1被解析为String）：

public static <T> T readJSON3(String json, TypeReference<T> typeReference) throws JsonProcessingException {
    return new ObjectMapper().readValue(json, typeReference);
}

调用方式：

Map<String, List<Map<String, String>>> data = readJSON3(jsonString, new TypeReference<>(){});

但希望将TypeReference等Jackson相关逻辑封装在工具类中，不让调用者直接使用TypeReference，求解决办法。

方案一：全局配置ObjectMapper，强制数值转String #

在工具类中初始化一个全局配置好的ObjectMapper，让所有目标类型为String的字段自动将数值转成字符串，无需调用者额外处理：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.DeserializationProblemHandler;
import com.fasterxml.jackson.databind.type.TypeReference;

import java.io.IOException;

public class JsonUtils {
    // 全局配置的ObjectMapper
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    static {
        // 添加自定义处理逻辑：当目标类型是String且遇到数值时，转成字符串
        OBJECT_MAPPER.addDeserializationProblemHandler(new DeserializationProblemHandler() {
            @Override
            public Object handleUnexpectedToken(DeserializationContext ctxt, Class<?> targetType, com.fasterxml.jackson.core.JsonToken token, com.fasterxml.jackson.core.JsonParser parser, String failureMsg) throws IOException {
                if (targetType == String.class && token.isNumeric()) {
                    return parser.getText();
                }
                return super.handleUnexpectedToken(ctxt, targetType, token, parser, failureMsg);
            }
        });
        // 可选：关闭严格类型检查，避免因类型不匹配抛出异常
        OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    // 通用泛型方法，调用者无需关心TypeReference
    public static <T> T readJSON(String json) throws JsonProcessingException {
        return OBJECT_MAPPER.readValue(json, new TypeReference<T>() {});
    }
}

调用方式和之前的泛型方法一致，但Field1会被自动解析为String：

Map<String, List<Map<String, String>>> data = JsonUtils.readJSON(jsonString);

方案二：自定义类型令牌封装泛型信息（无额外依赖） #

自己实现一个简单的类型令牌类，让调用者通过它传递泛型类型，工具类内部转换为Jackson可识别的类型：

// 自定义类型令牌类
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public abstract class TypeToken<T> {
    protected final Type type;

    protected TypeToken() {
        Type superClass = getClass().getGenericSuperclass();
        if (superClass instanceof ParameterizedType) {
            this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
        } else {
            throw new IllegalArgumentException("TypeToken必须使用泛型子类实例化");
        }
    }

    public Type getType() {
        return type;
    }
}

工具类方法：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonUtils {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    public static <T> T readJSON(String json, TypeToken<T> typeToken) throws JsonProcessingException {
        return OBJECT_MAPPER.readValue(json, typeToken.getType());
    }
}

调用时，调用者只需创建TypeToken实例，无需直接接触TypeReference：

Map<String, List<Map<String, String>>> data = JsonUtils.readJSON(jsonString, new TypeToken<Map<String, List<Map<String, String>>>>() {});

方案三：通过匿名内部类传递泛型信息 #

让调用者传递一个泛型类型的匿名内部类实例，工具类内部提取泛型类型：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class JsonUtils {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    // 辅助类，用于传递嵌套泛型
    public abstract static class GenericType<T> {
        private final Type type;

        protected GenericType() {
            Type superClass = getClass().getGenericSuperclass();
            if (superClass instanceof ParameterizedType) {
                this.type = ((ParameterizedType) superClass).getActualTypeArguments()[0];
            } else {
                throw new IllegalArgumentException("GenericType必须使用泛型子类实例化");
            }
        }

        public Type getType() {
            return type;
        }
    }

    public static <T> T readJSON(String json, GenericType<T> genericType) throws JsonProcessingException {
        return OBJECT_MAPPER.readValue(json, genericType.getType());
    }
}

调用嵌套泛型的情况：

Map<String, List<Map<String, String>>> data = JsonUtils.readJSON(jsonString, new JsonUtils.GenericType<Map<String, List<Map<String, String>>>>() {});

方案一适合需要全局统一将数值转String的场景，配置一次即可，调用方式最简单；方案二、三适合仅部分场景需要特殊类型转换的情况，灵活性更高，同时封装了Jackson的TypeReference细节，调用者无需直接接触Jackson的API。

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