问如何使用Map<Integer、Object>将JSON数据映射到自定义类型

EN

JSONObject jsonObject = null;
        try {
            jsonObject = new JSONObject(jsonString);

            jsonObject = jsonObject.getJSONObject("custom");
            Iterator<String> iter = jsonObject.keys();
            while (iter.hasNext()){
                String key = iter.next();
                JSONObject jsonObject1 = jsonObject.getJSONObject(key);
                ModelClass model = new ModelClass();
                if(jsonObject1.has("name"))
                model.setName(jsonObject1.getString("name"));
                if(jsonObject1.has("value"))
                model.setValue(jsonObject1.getString("value"));
                map.put(Integer.parseInt(key),model);

            }
        } catch (JSONException e) {
            e.printStackTrace();
        }

final class Response {

    @JsonAdapter(SpecialMapTypeAdapterFactory.class)
    final Map<Integer, Object> custom = null;

}

final class SpecialMapTypeAdapterFactory
        implements TypeAdapterFactory {

    // This is a holder for "wrapped" strings
    private static final class Single {

        @SuppressWarnings("unused")
        final String v;

        private Single(final String v) {
            this.v = v;
        }

    }

    private SpecialMapTypeAdapterFactory() {
    }

    @Override
    public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
        // Returning the custom type adapter that's now aware of the current Gson instance type adapters
        // (no need to lookup for a type adapter using gson.fromJson over and over)
        @SuppressWarnings("unchecked")
        final TypeAdapter<T> typeAdapter = (TypeAdapter<T>) new SpecialMapTypeAdapter(
                gson.getAdapter(JsonElement.class),
                gson.getAdapter(Single.class),
                gson.getAdapter(Pair.class)
        );
        return typeAdapter.nullSafe();
    }

    private static final class SpecialMapTypeAdapter
            extends TypeAdapter<Map<Integer, Object>> {

        private final TypeAdapter<JsonElement> jsonElementTypeAdapter;
        private final TypeAdapter<Single> singleTypeAdapter;
        private final TypeAdapter<Pair> entryTypeAdapter;

        private SpecialMapTypeAdapter(final TypeAdapter<JsonElement> jsonElementTypeAdapter, final TypeAdapter<Single> singleTypeAdapter,
                final TypeAdapter<Pair> entryTypeAdapter) {
            this.jsonElementTypeAdapter = jsonElementTypeAdapter;
            this.singleTypeAdapter = singleTypeAdapter;
            this.entryTypeAdapter = entryTypeAdapter;
        }

        // write will work too
        @Override
        @SuppressWarnings("resource")
        public void write(final JsonWriter out, final Map<Integer, Object> map)
                throws IOException {
            out.beginObject();
            for ( final Entry<Integer, Object> e : map.entrySet() ) {
                out.name(String.valueOf(e.getKey()));
                final Object value = e.getValue();
                if ( value == null ) {
                    out.nullValue();
                } else if ( value instanceof String ) {
                    singleTypeAdapter.write(out, new Single((String) value));
                } else if ( value instanceof Pair ) {
                    entryTypeAdapter.write(out, (Pair) value);
                } else {
                    throw new IllegalArgumentException("Cannot write " + value);
                }
            }
            out.endObject();
        }

        @Override
        public Map<Integer, Object> read(final JsonReader in)
                throws IOException {
            final Map<Integer, Object> map = new LinkedHashMap<>();
            in.beginObject();
            while ( in.hasNext() ) {
                final int key = parseInt(in.nextName());
                final Object value = parseValue((JsonObject) jsonElementTypeAdapter.read(in));
                map.put(key, value);
            }
            in.endObject();
            return map;
        }

        // This method attempts to analyze weakly the content of the given JsonObject respecting its properties
        // Thus either a String is returned or a Pair
        private Object parseValue(final JsonObject jsonObject)
                throws MalformedJsonException {
            if ( jsonObject.has("v") ) {
                return singleTypeAdapter.fromJsonTree(jsonObject).v;
            }
            if ( jsonObject.has("NAME") && jsonObject.has("VALUE") ) {
                return entryTypeAdapter.fromJsonTree(jsonObject);
            }
            throw new MalformedJsonException("Cannot parse " + jsonObject);
        }

    }

}

final class Pair {

    @SerializedName("NAME")
    final String name = null;

    @SerializedName("VALUE")
    final String value = null;

    @Override
    public String toString() {
        return name + "=>" + value;
    }

}

private static final Gson gson = new Gson();

public static void main(final String... args)
        throws IOException {
    try ( final JsonReader jsonReader = getPackageResourceJsonReader(Q43846710.class, "dynamic.json") ) {
        final Response response = gson.fromJson(jsonReader, Response.class);
        for ( final Map.Entry<Integer, Object> e : response.custom.entrySet() ) {
            final Integer key = e.getKey();
            final Object value = e.getValue();
            System.out.println(key + " is " + value.getClass().getSimpleName() + ": " + value);
        }
        System.out.println(gson.toJson(response));
    }
}