You need to enable JavaScript to run this app. Java 如何反序列化结构未知的嵌套JSON为多态HashMap
优惠活动
大模型
产品
解决方案
定价
更多

Java 如何反序列化结构未知的嵌套JSON为多态HashMap

适配可变嵌套JSON的解析实现方案

核心实现逻辑(基于现有Gson栈,无需替换框架)

你之前用Gson出现类型不匹配的核心原因是:Gson默认对Object类型的解析逻辑会自动根据JSON token类型推断成Integer、Double、Boolean等Java类型,长数字转Double的精度丢失问题就是这么来的。要完全符合“非结构类型统一转String,嵌套结构转Map/ArrayList”的要求,只需要自定义一个类型适配器,替换Gson默认的HashMap解析逻辑即可,不需要重写整个解析流程。
这种实现方式下,最终生成的嵌套结构中,所有非容器类值都会被统一处理为String类型,不会出现Integer、Double、Boolean等额外类型,完全匹配定义的多态结构要求。

自定义TypeAdapter代码

public class FlexibleNestedMapAdapter extends TypeAdapter<HashMap<String, Object>> {
    @Override
    public void write(JsonWriter out, HashMap<String, Object> value) throws IOException {
        // 仅做接口解析场景时,序列化逻辑可按需补充,不影响解析流程
        if (value == null) {
            out.nullValue();
            return;
        }
        out.beginObject();
        for (Map.Entry<String, Object> entry : value.entrySet()) {
            out.name(entry.getKey());
            writeValue(out, entry.getValue());
        }
        out.endObject();
    }

    private void writeValue(JsonWriter out, Object value) throws IOException {
        if (value == null) {
            out.nullValue();
            return;
        }
        if (value instanceof Map) {
            out.beginObject();
            for (Map.Entry<String, Object> entry : ((Map<String, Object>) value).entrySet()) {
                out.name(entry.getKey());
                writeValue(out, entry.getValue());
            }
            out.endObject();
        } else if (value instanceof List) {
            out.beginArray();
            for (Object item : (List<?>) value) {
                writeValue(out, item);
            }
            out.endArray();
        } else {
            out.value(value.toString());
        }
    }

    @Override
    public HashMap<String, Object> read(JsonReader in) throws IOException {
        HashMap<String, Object> result = new LinkedHashMap<>();
        in.beginObject();
        while (in.peek() != JsonToken.END_OBJECT) {
            String key = in.nextName();
            result.put(key, readValue(in));
        }
        in.endObject();
        return result;
    }

    private Object readValue(JsonReader in) throws IOException {
        JsonToken currentToken = in.peek();
        switch (currentToken) {
            case BEGIN_OBJECT:
                // 递归解析嵌套对象,用LinkedHashMap保留原JSON的键顺序
                HashMap<String, Object> nestedMap = new LinkedHashMap<>();
                in.beginObject();
                while (in.peek() != JsonToken.END_OBJECT) {
                    String nestedKey = in.nextName();
                    nestedMap.put(nestedKey, readValue(in));
                }
                in.endObject();
                return nestedMap;
            case BEGIN_ARRAY:
                // 递归解析嵌套数组
                ArrayList<Object> arrayList = new ArrayList<>();
                in.beginArray();
                while (in.peek() != JsonToken.END_ARRAY) {
                    arrayList.add(readValue(in));
                }
                in.endArray();
                return arrayList;
            case STRING:
                return in.nextString();
            case NUMBER:
                // 关键:直接读取数字的原始字符串,不做数值类型转换,从根源避免精度丢失
                return in.nextString();
            case BOOLEAN:
                return String.valueOf(in.nextBoolean());
            case NULL:
                in.nextNull();
                return null;
            default:
                in.skipValue();
                return null;
        }
    }
}

接入配置

把自定义适配器注册到Gson实例中即可,不管是独立解析JSON还是搭配Retrofit使用,都和之前的代码逻辑兼容,不需要修改已有的接口字段定义:

// 构建带自定义适配器的Gson实例
Gson customGson = new GsonBuilder()
        .registerTypeAdapter(HashMap.class, new FlexibleNestedMapAdapter())
        .create();

// 若搭配Retrofit,直接传入自定义Gson实例即可
Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("你的接口地址")
        .addConverterFactory(GsonConverterFactory.create(customGson))
        .build();

过往踩坑原因说明

  • 为什么Moshi会抛Unable to create converter报错:Moshi默认的HashMap<String, Object>适配器依赖泛型类型擦除后的识别逻辑,碰到无明确类型的Object值时,默认会把标量值转成Integer/Double类型,且没有匹配到对应泛型的适配器时就会抛错。如果要切Moshi实现,也需要写和上述逻辑一致的自定义JsonAdapter,但从现有技术栈成本考虑,用Gson自定义适配器的方案不需要额外迁移框架,实现成本最低。
  • 为什么会出现Long时间戳转Double的问题:Gson默认解析NUMBER类型token时,会优先判断数字的范围,超过Integer范围的直接转成Double类型,精度丢失后再转回字符串也无法还原原始数值。上述自定义实现是在JsonReader层直接读取NUMBER的原始文本,完全跳过数值类型转换环节,从根源上避免精度问题。

其他可选实现方案

如果项目已经引入Jackson依赖,也可以直接遍历JsonNode树实现相同逻辑:递归遍历每个节点,对象节点转LinkedHashMap、数组节点转ArrayList、标量节点直接取asText()得到String值,整体逻辑和上述自定义适配器的逻辑完全一致,不需要额外引入新的依赖。

内容的提问来源于stack exchange,提问作者bliako

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.10.27 18:54:03