gson 反序列化后整形变浮点问题

深碍√TFBOYSˉ_ 2023-03-01 10:07 12阅读 0赞

## 说明 ##

此问题出于研发阶段发现的问题，经过翻阅源码分析得出如下解决方案， 个人感觉来讲 对比fastjson ，gson没有那么懂得我们的心，很多时候 我们理所当然的认为序列化的时候就应该是这样的，但是gson并没有给与那么完美的支持，更多的时候还需要我们针对性的定制插件来扩展支持。  
另外也简单说下不用fastjson的原因，fastjson在实际使用中确实是很好用，大部分情况效果都比较符合开发者的预期，但是有一点比较致命的就是安全问题，一直以来，生产环境因为fastjson升级导致的兼容问题层出不穷，这就是不选用fastjson的最主要原因

## 问题样例说明 ##

public static void main(String[] args) {
            GsonBuilder builder = new GsonBuilder();
            builder.setDateFormat("yyyy-MM-dd HH:mm:ss");
            builder.registerTypeAdapter(new TypeToken<Map<String,Object>>(){}.getType(),new MapTypeAdapter());
            Gson gson = builder.create();
            String value = "{\"amount\":20000}";
            Map<String, Object> map = gson.fromJson(value, new TypeToken<Map<String, Object>>() {
            }.getType());
            System.out.println(map.get("amount"));
    
            GsonBuilder builder2 = new GsonBuilder();
            builder2.setDateFormat("yyyy-MM-dd HH:mm:ss");
            Gson gson2 = builder2.create();
            Map<String, Object> map2 = gson2.fromJson(value, new TypeToken<Map<String, Object>>() {
            }.getType());
            System.out.println(map2.get("amount"));
        }

如上代码 一个JSON转换成Map<String, Object> 然后值类型会出现问题 从整形数据变成浮点数 ，字符串则没有任何问题  
执行结果如下

20000
    20000.0

## 问题方案 ##

如上代码 问题已经解决 解决方案和原因介绍  
com.google.gson.internal.bind.ObjectTypeAdapter 参考gson的源码的这个类  
反序列化的时候 NUMBER类型 的时候 默认是按double处理的所以加上了浮点数的。0 然后模拟此类定制一个TypeAdapter 解决此问题就可以了

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(this.read(in));
                }
    
                in.endArray();
                return list;
            case BEGIN_OBJECT:
                Map<String, Object> map = new LinkedTreeMap();
                in.beginObject();
    
                while(in.hasNext()) {
                    map.put(in.nextName(), this.read(in));
                }
    
                in.endObject();
                return map;
            case STRING:
                return in.nextString();
                // NUMBER 值类型重写下方法  把不需要是浮点数的修改一下解析返回值即可
            case NUMBER:
                return in.nextDouble();
            case BOOLEAN:
                return in.nextBoolean();
            case NULL:
                in.nextNull();
                return null;
            default:
                throw new IllegalStateException();
            }
        }

要注意的是 builder.registerTypeAdapter(new TypeToken<Map<String,Object>>()\{\}.getType(),new MapTypeAdapter());  
这段代码 注册的时候 一定要与反序列化的类型一致否则匹配不上 会导致重写数据没有生效，检查是否生效的方法  
com.google.gson.Gson\#fromJson(com.google.gson.stream.JsonReader, java.lang.reflect.Type) 参考源码这个方法

public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
            boolean isEmpty = true;
            boolean oldLenient = reader.isLenient();
            reader.setLenient(true);
    
            TypeAdapter typeAdapter;
            try {
                try {
                    reader.peek();
                    isEmpty = false;
    //                这个位置检查看下获取到的typeAdapter  是否是自己 重写的那个 
                    TypeToken<T> typeToken = TypeToken.get(typeOfT);
                    typeAdapter = this.getAdapter(typeToken);
                    T object = typeAdapter.read(reader);
                    Object var8 = object;
                    return var8;
                } catch (EOFException var15) {
                    if (!isEmpty) {
                        throw new JsonSyntaxException(var15);
                    }
                } catch (IllegalStateException var16) {
                    throw new JsonSyntaxException(var16);
                } catch (IOException var17) {
                    throw new JsonSyntaxException(var17);
                } catch (AssertionError var18) {
                    throw new AssertionError("AssertionError (GSON 2.8.5): " + var18.getMessage(), var18);
                }
    
                typeAdapter = null;
            } finally {
                reader.setLenient(oldLenient);
            }
    
            return typeAdapter;
        }

**补充 信息**

GSON实例化 装载各种适配器的工厂类

com.google.gson.Gson#Gson()
        factories.add(TypeAdapters.URL_FACTORY);
        factories.add(TypeAdapters.URI_FACTORY);
        factories.add(TypeAdapters.UUID_FACTORY);
        factories.add(TypeAdapters.CURRENCY_FACTORY);
        factories.add(TypeAdapters.LOCALE_FACTORY);
        factories.add(TypeAdapters.INET_ADDRESS_FACTORY);
        factories.add(TypeAdapters.BIT_SET_FACTORY);
        factories.add(DateTypeAdapter.FACTORY);
        factories.add(TypeAdapters.CALENDAR_FACTORY);
        factories.add(TimeTypeAdapter.FACTORY);
        factories.add(SqlDateTypeAdapter.FACTORY);
        factories.add(TypeAdapters.TIMESTAMP_FACTORY);
        factories.add(ArrayTypeAdapter.FACTORY);
        factories.add(TypeAdapters.CLASS_FACTORY);

以时间解释器为例  
com.google.gson.internal.bind.DateTypeAdapter  
静态属性初始化工厂类并实现匹配逻辑

public static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() { 
        @SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal
        @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) { 
          return typeToken.getRawType() == Date.class ? (TypeAdapter<T>) new DateTypeAdapter() : null;
        }
      };

解释器匹配逻辑  
com.google.gson.Gson\#getAdapter(com.google.gson.reflect.TypeToken)

for (TypeAdapterFactory factory : factories) { 
            TypeAdapter<T> candidate = factory.create(this, type);  // 执行上面初始化的匹配逻辑
            if (candidate != null) { 
              call.setDelegate(candidate);
              typeTokenCache.put(type, candidate);
              return candidate;
            }
          }