JSON反序列化Long变Integer或Double的问题及解决
目录
- 一、背景
- 二、研究
- 三、如何解决
- 3.0 将类型写入 JSON 字符串中
- 3.1 提供 POJO 类，慎对 Map<String,Object> 序列化
- 3.2 反序列化自定义类
- 3.3 其他
一、背景
工作中可能会遇到对 Map<String,Object> 进行 JSON 序列化，其中值中包含 Long 类型的数据，反序列化后强转 Long 时报类型转换异常的问题。
本文简单探讨下该问题，并给出解决方案，如果你想直接看建议，直接翻到第三部分即可。
二、研究
本文主要以 jackson、 gson、fastjson 三个库为例，版本分别如下：
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.13.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.78</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.8</version>
</dependency>
代码示例
package json;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.GsonBuilder;
import java.util.HashMap;
import java.util.Map;
public class ObjectDemo {
public static void main(String[] args) throws JsonProcessingException {
Map<String, Object> dataMap = new HashMap<>(2);
dataMap.put("aInteger", 1);
dataMap.put("aLong", 2L);
String jsonStr = JSON.toJSONString(dataMap);
System.out.println(jsonStr);
// fastjson
System.out.println("--- fastjson -----");
Map<String, Object> fastMap = JSON.parseObject(jsonStr, new com.alibaba.fastjson.TypeReference<Map<String, Object>>() {
});
printMap(fastMap);
System.out.println("--- gson -----");
Map<String, Object> gsonMap = new GsonBuilder().create()
.fromJson(jsonStr, (new TypeReference<Map<String, Object>>(){}).getType() );
printMap(gsonMap);
System.out.println("--- jackson -----");
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> jacksonMap = objectMapper.readValue(jsonStr, new TypeReference<Map<String, Object>>() {
});
printMap(jacksonMap);
}
private static void printMap(Map<String, Object> map) {
map.forEach((key, value) -> {
System.out.println("key:" + key + ",value=" + value + ",valueClass=" + value.getClass());
});
}
}
运行结果：
{"aInteger":1,"aLong":2}
--- fastjson -----
key:aLong,value=2,valueClass=class java.lang.Integer
key:aInteger,value=1,valueClass=class java.lang.Integer
--- gson -----
key:aInteger,value=1.0,valueClass=class java.lang.Double
key:aLong,value=2.0,valueClass=class java.lang.Double
--- jackson -----
key:aInteger,value=1,valueClass=class java.lang.Integer
key:aLong,value=2,valueClass=class java.lang.Integer
aLong 虽然原始类型为 Long 但是 fastjson 和 jackson 中被反序列化为 Integer 类型，gson 中被映射为 Double 类型。
我们观察序列化后的 json 字符串：
{"aInteger":1,"aLong":2}
会发现其实 JSON 中并没有包含类型信息，而反序列化的类型为 Map.class 或者 Map<String,Object> 类型，当你只知道这些信息时，你无法得知 aLong 原始类型为 Long 。
因此不同的JSON 序列化工具给出了自己的默认处理行为。
当我们把 aLong 的值调整到 超过 (Integer.MAX_VALUE,Long.MAX_VALUE] 的范围之间时，fastjson 和 jackson 可以解析为 Long 类型。
Map<String, Object> dataMap = new HashMap<>(2);
dataMap.put("aInteger", 1);
dataMap.put("aLong", Long.MAX_VALUE);
输出的结果：
{"aInteger":1,"aLong":9223372036854775807}
--- fastjson -----
key:aLong,value=9223372036854775807,valueClass=class java.lang.Long
key:aInteger,value=1,valueClass=class java.lang.Integer
--- gson -----
key:aInteger,value=1.0,valueClass=class java.lang.Double
key:aLong,value=9.223372036854776E18,valueClass=class java.lang.Double
--- jackson -----
key:aInteger,value=1,valueClass=class java.lang.Integer
key:aLong,value=9223372036854775807,valueClass=class java.lang.Long
我们大致了解到， fastjson 和 jackson 默认情况下整数类型优先选取 Integer ，超过 Integer 范围再选择 Long ，以此类推。
而当我们放入 Float 类型时，结果又有差异:
Map<String, Object> dataMap = new HashMap<>(2);
dataMap.put("aInteger", 1);
dataMap.put("aFLoat", 0.1F);
运行结果：
{"aInteger":1,"aFLoat":0.1}
--- fastjson -----
key:aInteger,value=1,valueClass=class java.lang.Integer
key:aFLoat,value=0.1,valueClass=class java.math.BigDecimal
--- gson -----
key:aInteger,value=1.0,valueClass=class java.lang.Double
key:aFLoat,value=0.1,valueClass=class java.lang.Double
--- jackson -----
key:aInteger,value=1,valueClass=class java.lang.Integer
key:aFLoat,value=0.1,valueClass=class java.lang.Double
fastjson 中 Float 被解析为 BigDecimal, gson 和 jackson 中被解析为 Double 类型。
具体底层如何处理，大家可以对每个框架的反序列方法单步跟进去即可得到答案。
这里以 fastjson 为例，简单调试下：
fastjson 底通过 com.alibaba.fastjson.parser.ParserConfig#getDeserializer 方法获取当前类型的反序列化器为 MapDeserializer
执行其反序列化方法：
com.alibaba.fastjson.parser.deserializer.MapDeserializer#deserialze
通过 com.alibaba.fastjson.parser.deserializer.MapDeserializer#parseMap 对 Map 类型进行解析。
由于 Map<String, Object>的 valueType 类型为 Object，因此对 aFloat 使用 JavaObjectDeserializer 反序列化器进行解析。
跟进 lexer.decimalValue 看下：
最终通过 com.alibaba.fastjson.parser.JSONScanner#decimalValue 将 aFloat 解析为 BigDecimal 类型。
三、如何解决
3.0 将类型写入 JSON 字符串中
如果我们能将原始类型写入到 JSON 字符串中，那么反序列化时自然就可以复原原始的类型。
在 fastjson 中可以使用 SerializerFeature.WriteClassName
package json;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.util.HashMap;
import java.util.Map;
public class JsonDemo {
public static void main(String[] args) {
Map<String, Object> dataMap = new HashMap<>(2);
dataMap.put("aInteger", 1);
dataMap.put("aLong", 2L);
dataMap.put("aFloat", 3F);
String jsonStr = JSON.toJSONString(dataMap, SerializerFeature.WriteClassName);
System.out.println(jsonStr);
// fastjson
System.out.println("--- fastjson -----");
Map<String, Object> fastMap = JSON.parseObject(jsonStr, new com.alibaba.fastjson.TypeReference<Map<String, Object>>() {
});
printMap(fastMap);
}
private static void printMap(Map<String, Object> map) {
map.forEach((key, value) -> {
System.out.println("key:" + key + ",value=" + value + ",valueClass=" + value.getClass());
});
}
}
打印的结果
{"@type":"java.util.HashMap","aFloat":3.0F,"aInteger":1,"aLong":2L}
--- fastjson -----
key:aLong,value=2,valueClass=class java.lang.Long
key:aFloat,value=3.0,valueClass=class java.lang.Float
key:aInteger,value=1,valueClass=class java.lang.Integer
虽然，这种方法可以解决问题，但是这也通常要求序列化和反序列化使用同一个 JSON 工具。
比如上面的 {"@type":"java.util.HashMap","aFloat":3.0F,"aInteger":1,"aLong":2L} 直接使用 jackson 进行反序列化会报错：
System.out.println("--- jackson -----");
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> jacksonMap = objectMapper.readValue(jsonStr, new TypeReference<Map<String, Object>>() {
});
printMap(jacksonMap);
报错内容：
--- jackson -----
Exception in thread "main" com.fasterxml.jackson.core.JsonParseException: Unexpected character ('F' (code 70)): was expecting comma to separate Object entries
at [Source: (String)"{"@type":"java.util.HashMap","aFloat":3.0F,"aInteger":1,"aLong":2L}"; line: 1, column: 43]
at com.fasterxml.jackson.core.JsonParser._constructError(JsonParser.java:2391)
at com.fasterxml.jackson.core.base.ParserMinimalBase._reportError(ParserMinimalBase.java:735)
at com.fasterxml.jackson.core.base.ParserMinimalBase._reportUnexpectedChar(ParserMinimalBase.java:659)
3.1 提供 POJO 类，慎对 Map<String,Object> 序列化
强烈建议不要怕麻烦，直接定义 POJO 类。
不仅不受 JSON 框架的约束，而且对方解析时也非常明确，不容易出错。
如工作中在发送MQ 消息时很多人图方便，不想定义POJO 对象，因为这样通常需要打包比较麻烦，就将要传输给其他系统的数据定义为 Map 类型，下游再根据 key 去解析，这是一个非常不好的习惯。
很容易造成上下游类型不一致，造成更换 JSON 反序列化工具时出现故障。
因此发送 MQ 消息时，最好给出相应的 POJO 类。
实际工作中，还遇到有同学将 Map<String,Object> 使用 JSON 序列化的方式存储到 Redis 中，然后反序列化后，将原本 Long 类型的值，强转为 Long 导致线上出现BUG（前面讲到，这种情况下使用 fastjson 时，如果值小于整数最大值，反序列化为 Integer 类型，强转必然会报错）。
3.2 反序列化自定义类
如果上游序列化是 Map<String,Object>， 如果类型核实清楚，我们依然可以自定义 POJO 类来反序列化。
@lombok.Data
public class Data {
private Float aFloat;
private Integer aInteger;
}
Map<String, Object> dataMap = new HashMap<>(2);
dataMap.put("aInteger", 1);
dataMap.put("aFLoat", 0.1F);
String jsonStr = JSON.toJSONString(dataMap);
Data data = JSON.parseObject(jsonStr, Data.class);
System.out.println(data);
输出结果：
Data(aFloat=0.1, aInteger=1)
可能有些同学会觉得定义 POJO 类很麻烦，其实我们可以使用 IDEA 插件或者在线工具实现 JSON 字符串生成 POJO 类。
如 Json2Pojo IDEA 插件
和一些在线生成工具：
https://json2csharp.com/json-to-pojo
https://www.javainuse.com/pojo
3.3 其他
可能网上还会有其他解决方案，比如自定义序列化和反序列化器。
我个人不太建议这么做，因为这样不够通用，跨系统使用不太方便。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。
相关推荐
-
完美解决gson将Integer默认转换成Double的问题
首先javascript只有这些个类型: 1.Number 在JavaScript中的双精度浮点格式 2.String 双引号的反斜杠转义的Unicode 3.Boolean true 或 false 4.Array 值的有序序列 5.Value 它可以是一个字符串,一个数字,真的还是假(true/false),空(null )等 6.Object 无序集合键值对 7.Whitespace 可以使用任何一对中的令牌 8.null empty 所以可以得出结论其实在javascript中20和20
-
SpringMVC Json自定义序列化和反序列化的操作方法
需求背景 需求一:SpringMVC构建的微服务系统,数据库对日期的存储是Long类型的时间戳,前端之前是默认使用Long类型时间,现在前端框架改动,要求后端响应数据时,Long类型的时间自动变成标准时间格式(yyyy-MM-dd HH:mm:ss). 涉及到这个转换的范围挺大,所有的实体表都有创建时间createTime和修改时间updateTime,目前的主要诉求也是针对这两个字段,并且在实体详情数据和列表数据都存在,需要一个统一的方法,对这两个字段进行处理. 需求二:前端请求上传的JSON
-
实例解析Json反序列化之ObjectMapper(自定义实现反序列化方法)
对于服务器端开发人员而言,调用第三方接口获取数据,将其"代理"转化并返给客户端几乎是家常便饭的事儿. 一般情况下,第三方接口返回的数据类型是json格式,而服务器开发人员则需将json格式的数据转换成对象,继而对其进行处理并封装,以返回给客户端. 在不是特别考虑效率的情况下(对于搜索.缓存等情形可以考虑使用thrift和protobuffer),通常我们会选取jackson包中的ObjectMapper类对json串反序列化以得到相应对象.通常会选取readValue(Strin
-
JSON反序列化Long变Integer或Double的问题及解决
目录 一.背景 二.研究 三.如何解决 3.0 将类型写入 JSON 字符串中 3.1 提供 POJO 类,慎对 Map<String,Object> 序列化 3.2 反序列化自定义类 3.3 其他 一.背景 工作中可能会遇到对 Map<String,Object> 进行 JSON 序列化,其中值中包含 Long 类型的数据,反序列化后强转 Long 时报类型转换异常的问题. 本文简单探讨下该问题,并给出解决方案,如果你想直接看建议,直接翻到第三部分即可. 二.研究 本文主要以 j
-
C#中Json反序列化的实现方法
前言 Json反序列化有两种方式[本人],一种是生成实体的,方便处理大量数据,复杂度稍高,一种是用匿名类写,方便读取数据,较为简单. 使用了Newtonsoft.Json,可以自行在nuget中导入 Json源数据: var data = "{'jingdong_ldop_receive_trace_get_responce':{'code':'0','querytrace_result':{'data':[{'opeTitle':'快递签收','opeRemark':'货物已交付京东物流','
-
Swift 中的 JSON 反序列化示例详解
目录 业界常用的几种方案 手动解码方案,如 Unbox(DEPRECATED) 阿里开源的 HandyJSON 基于 Sourcery 的元编程方案 Swift build-in API Codable 属性装饰器,如 BetterCodable 各个方案优缺点对比 Codable 介绍 原理浅析 Decoder.Container 协议 自研方案 功能设计 Decoder.Container 具体实现 再议 PropertyWrapper 应用场景示例 单元测试 性能对比 业界常用的几种方案
-
Go json反序列化“null“的问题解决
目录 实验 其他测试 有这么一段代码,可以先看一下有没有什么问题,作用是输入一段json字符串,反序列化成map,然后将另一个inputMap的内容,merge进这个map func mergeContent(inputJson string, inputMap map[string]interface{}) (map[string]interface{}, error) { jsonMap := make(map[string]interface{}) if inputJson != "&qu
-
json解析时遇到英文双引号报错的解决方法
有时解析json时,会碰到里面带有英文的双引号,导致解析错误,可以将json进行转义,一下: public static String htmlEscape(String input) { if(isEmpty(input)){ return input; } input = input.replaceAll("&", "&"); input = input.replaceAll("<", "<")
-
使用jpa的实体对象转json符串时懒加载的问题及解决
目录 解决转json符串时懒加载问题方法(1) 解决转json符串时懒加载问题方法(2) Rest风格中关于JPA使用懒加载的坑 解决转json符串时懒加载问题方法(1) 1.导入hibernate5转json的Maven依赖: <dependency> <groupId>com.fasterxml.jackson.datatype</groupId> <artifactId>jackson-datatype-hibernate5</a
-
Python实现JSON反序列化类对象的示例
我们的网络协议一般是把数据转换成JSON之后再传输.之前在Java里面,实现序列化和反序列化,不管是 jackson ,还是 fastjson 都非常的简单.现在有项目需要用Python来开发,很自然的希望这样的便利也能在Python中体现. 但是在网上看了一些教程,讲反序列化的时候,基本都是转换为 dict 或者 array .这种编程方式我从情感上是无法接受的.难道是这些JSON库都不支持反序列化为类对象?我马上打消了这个念头,Python这样强大的脚本语言,不可能没有完善的JSON库. 于
-
golang中json反序列化可能遇到的问题
前言 在golang中,当浮点数超过一定数值的时候,golang会把它弄成科学计数法的形式进行显示(好像只要大于七位数就变成科学计数法了) var val float64 val = 1000000 fmt.Println(val) // ==> 1e+06 而在日常开发中,我们经常遇到这样一个问题,就是要反序列化前端传递来的json,因为数据结构未知,所以我们便会使用map[string]interface{}来接收反序列化的结果.由于golang将json解析到interface{}类型的时
-
golang:json 反序列化的[]和nil操作
我就废话不多说了,大家还是直接看代码吧~ package main import ( "encoding/json" "log" ) type JS struct { A []string } func main() { v1 := &JS{} v2 := &JS{A: []string{}} o1, err := json.Marshal(&v1) log.Println(string(o1), err) o2, err2 := json.