java - 让 Gson 解析整数而不是 float

Question

我试图让Gson将没有浮点的值解析为长整型，而不是像默认情况下那样解析为 double 型:

Gson gson = new GsonBuilder()
            .registerTypeAdapter(Object.class, (JsonDeserializer<Object>) (json, type, context) -> {
                // we don't want integer values to be parsed as floats
                String value = json.getAsJsonPrimitive().getAsString();
                if (value.matches("\\d+")) {
                    return Long.valueOf(value);
                } else {
                    return context.deserialize(json, type);
                }
            }).create();
...
gson.fromJson(payload);

我只是想测试一下该值是否包含.，如果不包含，则将其解析为Long。否则使用默认的解析方法。

但是，当我在那里放置断点时，该方法永远不会被调用。我想我以错误的方式注册了适配器。

EDIT1:Json 可能包含带有字符串、整数、 double 和映射的列表。我需要一个通用的解决方案。

EDIT2:我还尝试了各种.registerTypeAdapter(Number.class或.registerTypeAdapter(Double.class)但没有效果。仍然没有被调用。

Answer 1

除了完全重写 Gson 函数之外，我找不到更好的方法。这确实是一个黑客，但似乎没有其他解决方案可以解决这个问题:

public class Gson {

    private static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() {
        public <T> TypeAdapter<T> create(com.google.gson.Gson gson, TypeToken<T> type) {
            return type.getRawType() == Object.class ? (TypeAdapter<T>) new LongObjectTypeAdapter(gson) : null;
        }
    };



    static {
        try {
            Field field = ObjectTypeAdapter.class.getDeclaredField("FACTORY");

            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

            field.setAccessible(true);
            field.set(null, FACTORY);

        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }



    private com.google.gson.Gson gson = new com.google.gson.Gson();



    public <T> T fromJson(String payload, Class<T> c) {
        return gson.fromJson(payload, c);
    }



    public String toJson(Object object) {
        return gson.toJson(object);
    }



    public static class LongObjectTypeAdapter extends TypeAdapter<Object> {

        private com.google.gson.Gson gson;

        public LongObjectTypeAdapter(com.google.gson.Gson gson) {
            this.gson = gson;
        }

        public Object read(JsonReader in) throws IOException {
            JsonToken token = in.peek();

            switch (token) {
                case BEGIN_ARRAY:
                    ArrayList list = new ArrayList();
                    in.beginArray();

                    while(in.hasNext()) {
                        list.add(this.read(in));
                    }

                    in.endArray();
                    return list;
                case BEGIN_OBJECT:
                    LinkedTreeMap map = new LinkedTreeMap();
                    in.beginObject();

                    while(in.hasNext()) {
                        map.put(in.nextName(), this.read(in));
                    }

                    in.endObject();
                    return map;
                case STRING:
                    return in.nextString();
                case NUMBER:
                    String value = in.nextString();
                    if (value.contains(".")) {
                        return Double.valueOf(value);
                    } else {
                        return Long.valueOf(value);
                    }

                case BOOLEAN:
                    return Boolean.valueOf(in.nextBoolean());
                case NULL:
                    in.nextNull();
                    return null;
                default:
                    throw new IllegalStateException();
            }
        }

        public void write(JsonWriter out, Object value) throws IOException {
            if (value == null) {
                out.nullValue();
            } else {
                TypeAdapter typeAdapter = gson.getAdapter(value.getClass());
                if (typeAdapter instanceof LongObjectTypeAdapter) {
                    out.beginObject();
                    out.endObject();
                } else {
                    typeAdapter.write(out, value);
                }
            }
        }
    }
}