Gson将json字符串转map致使int型被转换成double的采坑之旅

时间 2019-11-17

标签 gson json 字符串 map 致使 int 转换 double 之旅栏目 JavaScript 繁體版

原文原文链接

前言：平常开发中，与json打交道的机会不少，通常对象json转都不会出现什么问题，可是json转对象就有可能出现问题了，今天就来讲说json转map致使int型转换成double的问题json

问题重现

以前解决过long型被转化成科学计数法的问题，全部就拿之前的公用方法，一个泛型工具类

public class MyType<T> {
    public T gsonToMap(String strJson) {
        return new Gson().fromJson(strJson, new TypeToken<T>() {
        }.getType());
    }
}

String json = "{\"identifier\":\"18111111111\",\"opType\":1,\"platform\":0}";
Map<String, Object> map = new MyType<Map<String, Object>>().gsonToMap(json);
复制代码

直接将需求类型对象传入泛型就行了。
然而事与愿违，int成功的转换成double，1->1.0、0->0.0，如上图所示

接下来的操做你们都知道了，借助于网络平台，因而乎找到几种解决方式，细心的我发现有人评论解决他们的问题，看来有戏啊【手动滑稽】bash

解决方案

一、须要gson解析的类型 , 重写他的deserialize方法, 就是将其中json手动解析成map , 不对数据进行处理网络

public HashMap<String,Object> gsonToMap(String strJson) {
        Gson gson = new GsonBuilder()
                .registerTypeAdapter(
                new TypeToken<HashMap<String,Object>>(){}.getType(),
                        new JsonDeserializer<HashMap<String, Object>>() {
                            @Override
                            public HashMap<String, Object> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {

                                HashMap<String, Object> hashMap = new HashMap<>();
                                JsonObject jsonObject = json.getAsJsonObject();
                                Set<Map.Entry<String, JsonElement>> entrySet = jsonObject.entrySet();
                                for (Map.Entry<String, JsonElement> entry : entrySet) {
                                    hashMap.put(entry.getKey(), entry.getValue());
                                }
                                return hashMap;
                            }
                        }).create();

        return gson.fromJson(strJson, new TypeToken<HashMap<String,Object>>() {
        }.getType());
    }
复制代码

通过实践，是能够转化成功，可是本着复用的思想，我把map替换成泛型，而后就不行，一脸蒙蔽；（问题暂时搁置一旁）

二、自定义TypeAdapter替代Gson默认的adapter（此处埋下伏笔【偷笑】）解决，自定义TypeAdapter以下：ide

public class MapTypeAdapter extends TypeAdapter<Object> {

    private final TypeAdapter<Object> delegate = new Gson().getAdapter(Object.class);

    @Override
    public Object read(JsonReader in) throws IOException {
        JsonToken token = in.peek();
        switch (token) {
            case BEGIN_ARRAY:
                List<Object> list = new ArrayList<>();
                in.beginArray();
                while (in.hasNext()) {
                    list.add(read(in));
                }
                in.endArray();
                return list;

            case BEGIN_OBJECT:
                Map<String, Object> map = new LinkedTreeMap<>();
                in.beginObject();
                while (in.hasNext()) {
                    map.put(in.nextName(), read(in));
                }
                in.endObject();
                return map;
                
            case STRING:
                return in.nextString();

            case NUMBER:
                /**
                 * 改写数字的处理逻辑，将数字值分为整型与浮点型。
                 */
                double dbNum = in.nextDouble();

                // 数字超过long的最大值，返回浮点类型
                if (dbNum > Long.MAX_VALUE) {
                    return String.valueOf(dbNum);
                }

                // 判断数字是否为整数值
                long lngNum = (long) dbNum;
                if (dbNum == lngNum) {
                    return String.valueOf(lngNum);
                } else {
                    return String.valueOf(dbNum);
                }

            case BOOLEAN:
                return in.nextBoolean();

            case NULL:
                in.nextNull();
                return null;

            default:
                throw new IllegalStateException();
        }
    }

    @Override
    public void write(JsonWriter out, Object value) throws IOException {
        delegate.write(out,value);
    }
}
复制代码

而后如法炮制，仍然执拗的使用泛型，并将咱们自定义的注册到gson上

public T gsonToMap(String strJson) {
        Gson gson = new GsonBuilder()
                .registerTypeAdapter(new TypeToken<T>(){}.getType(),new MapTypeAdapter()).create();
        return gson.fromJson(strJson, new TypeToken<T>() {
        }.getType());
    }
    
String json = "{\"identifier\":\"18111111111\",\"opType\":1,\"platform\":0}";
Map<String, Object> map = new MyType<Map<String, Object>>().gsonToMap(json);
复制代码

等待结果中...，每错就是这么刺激，int同样会转化成double

把泛型直接替换成目标对象类型，再试了试，证实是没问题的

public static Map<String, Object> gsonToMap(String strJson) {
        Gson gson = new GsonBuilder()
                .registerTypeAdapter(new TypeToken<Map<String,Object>>(){}.getType(),new MapTypeAdapter()).create();
        return gson.fromJson(strJson, new TypeToken<Map<String, Object>>() {
        }.getType());
    }
    
String json = "{\"identifier\":\"18111111111\",\"opType\":1,\"platform\":0}";
Map<String, Object> map = new MyType<Map<String, Object>>().gsonToMap(json);
复制代码

上述方案的确是能够解决个人问题，可是却给我留下了疑问；本着知其然知其因此然的目的，以为解决这些疑惑工具

解决疑惑

为何传递泛型不行？
为何是把int转化成了double，而不是其余类型好比string?

一、关于泛型这里就要提到 泛型擦除，及泛型只在编译阶段有效，运行时就无效了ui

跟踪源码会发现 TypeAdapter 就已是一个泛型抽象类了

public abstract class TypeAdapter<T>
复制代码

我在外层又传了一次泛型，运行时根本就不认识我传递的目标对象类型了
在外层直接传递目标对象类型，这里我传递的是HashMap<String,Object>，可我彻底正确的识别出来

因此我这里的操做彻底是符合泛型擦除，因此运行时代码根本不认识这是个什么东西，天然不回你达到咱们想要的效果了

二、int转double，其实这是Gson在源码中故意为之的，其实不只是int,long也会转化成double,接下来咱们去寻找证据this

跟踪源码，走你 => 过程省略1000步，忽略1000000字，咱们会来到Gson下的这个地方
这里处理Number型的adapter,除此以外还有

处理double：
private TypeAdapter<Number> doubleAdapter(boolean serializeSpecialFloatingPointValues) {
    if (serializeSpecialFloatingPointValues) {
      return TypeAdapters.DOUBLE;
    }
    return new TypeAdapter<Number>() {
      @Override public Double read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
          in.nextNull();
          return null;
        }
        return in.nextDouble();
      }
      @Override public void write(JsonWriter out, Number value) throws IOException {
        if (value == null) {
          out.nullValue();
          return;
        }
        double doubleValue = value.doubleValue();
        checkValidFloatingPoint(doubleValue);
        out.value(value);
      }
    };
  }
  
  处理float:
  private TypeAdapter<Number> floatAdapter(boolean serializeSpecialFloatingPointValues) {
    if (serializeSpecialFloatingPointValues) {
      return TypeAdapters.FLOAT;
    }
    return new TypeAdapter<Number>() {
      @Override public Float read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
          in.nextNull();
          return null;
        }
        return (float) in.nextDouble();
      }
      @Override public void write(JsonWriter out, Number value) throws IOException {
        if (value == null) {
          out.nullValue();
          return;
        }
        float floatValue = value.floatValue();
        checkValidFloatingPoint(floatValue);
        out.value(value);
      }
    };
  }
复制代码

其实这里就是在寻找与咱们目标对象想匹配的类型，可是若是找不到相匹配的类型，就会去调用 ObjectTypeAdapter，继续跟踪，它终于要在这里正式寻找喜欢的适配器了【斜眼笑】

咋们运气比较好，这 for (TypeAdapterFactory factory : factories) 里有40几个适配器，第二个就是咱们寻找的 ObjectTypeAdapter
它一看你们都是 T 就你跟我长得最像了，那就调用你了，因而乎就来到新世界

public final class ObjectTypeAdapter extends TypeAdapter<Object> {
  public static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() {
    @SuppressWarnings("unchecked")
    @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
      if (type.getRawType() == Object.class) {
        return (TypeAdapter<T>) new ObjectTypeAdapter(gson);
      }
      return null;
    }
  };

  private final Gson gson;

  ObjectTypeAdapter(Gson gson) {
    this.gson = gson;
  }

  @Override public Object read(JsonReader in) throws IOException {
    JsonToken token = in.peek();
    switch (token) {
    case BEGIN_ARRAY:
      List<Object> list = new ArrayList<Object>();
      in.beginArray();
      while (in.hasNext()) {
        list.add(read(in));
      }
      in.endArray();
      return list;

    case BEGIN_OBJECT:
      Map<String, Object> map = new LinkedTreeMap<String, Object>();
      in.beginObject();
      while (in.hasNext()) {
        map.put(in.nextName(), read(in));
      }
      in.endObject();
      return map;

    case STRING:
      return in.nextString();

    case NUMBER:
      return in.nextDouble();

    case BOOLEAN:
      return in.nextBoolean();

    case NULL:
      in.nextNull();
      return null;

    default:
      throw new IllegalStateException();
    }
  }

  @SuppressWarnings("unchecked")
  @Override public void write(JsonWriter out, Object value) throws IOException {
    if (value == null) {
      out.nullValue();
      return;
    }

    TypeAdapter<Object> typeAdapter = (TypeAdapter<Object>) gson.getAdapter(value.getClass());
    if (typeAdapter instanceof ObjectTypeAdapter) {
      out.beginObject();
      out.endObject();
      return;
    }

    typeAdapter.write(out, value);
  }
}
复制代码

是否是跟咱们以前自定义的adapter如出一辙，这就是为何咱们要复写这个TypeAdapter，重点看下面

case NUMBER:
      return in.nextDouble();
复制代码

只要是Number（包括int、long、float、double等）型，都会被强制转化成double，至于为何这么作，由于这里全部的类型均可以转换成double，而反过来则不行。

Gson将json字符串转map致使int型被转换成double的采坑之旅

问题重现

解决方案

解决疑惑

其实，还有一个更简单的方法，那就是不用Gson，好比使用FastJson，彻底不会出现这个问题

后记：解决问题不是根本，须要寻找问题产生的根本，从根源上杜绝它的发生，这是之后须要多多增强的地方。加油（若有纰漏，欢迎指教）！！！