脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → JSON反序列化Long变Integer或Double

JSON反序列化Long变Integer或Double的问题及解决

 更新时间：2022年01月13日 16:08:12   作者：明明如月学长  
这篇文章主要介绍了JSON反序列化Long变Integer或Double的问题及解决方案，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

一、背景

工作中可能会遇到对 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 其他

可能网上还会有其他解决方案，比如自定义序列化和反序列化器。

我个人不太建议这么做，因为这样不够通用，跨系统使用不太方便。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • spring redis 如何实现模糊查找key

    spring redis 如何实现模糊查找key

    这篇文章主要介绍了spring redis 如何实现模糊查找key的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2021-08-08
  • mybatis映射表结构的使用

    mybatis映射表结构的使用

    MyBatis通过表结构映射实现数据库操作,本文就来介绍一下mybatis映射表结构的使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-11-11
  • Java插入JSON对象到PostgreSQL的步骤详解

    Java插入JSON对象到PostgreSQL的步骤详解

    在现代软件开发中,由于 JSON 数据的轻量和通用性,处理 JSON 数据已经变得无处不在,PostgreSQL 凭借其对 JSON 的强大支持,为存储和查询 JSON 数据提供了出色的平台,本文给大家介绍了Java插入JSON对象到PostgreSQL的步骤,需要的朋友可以参考下
    2024-11-11
  • Java如何使用ConfigurationProperties获取yml中的配置

    Java如何使用ConfigurationProperties获取yml中的配置

    这篇文章主要介绍了Java如何使用ConfigurationProperties获取yml中的配置，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-02-02
  • 浅谈一下RabbitMQ、Kafka和RocketMQ消息中间件对比

    浅谈一下RabbitMQ、Kafka和RocketMQ消息中间件对比

    这篇文章主要介绍了浅谈一下RabbitMQ、Kafka和RocketMQ消息中间件对比,消息中间件属于分布式系统中一个字系统，关注于数据的发送和接收，利用高效可靠的异步信息传递机制对分布式系统中的其余各个子系统进行集成,需要的朋友可以参考下
    2023-05-05
  • Java前后端分离项目跨域问题解决方案

    Java前后端分离项目跨域问题解决方案

    本文主要介绍了Java前后端分离项目跨域问题解决方案,其中后端基于SpringBoot,前端使用了jQuery、axios等框架,具有一定的参考价值,感兴趣的可以了解一下
    2024-03-03
  • idea +junit单元测试获取不到bean注入的解决方式

    idea +junit单元测试获取不到bean注入的解决方式

    这篇文章主要介绍了idea +junit单元测试获取不到bean注入的解决方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2020-08-08
  • java利用递归实现类别树示例代码

    java利用递归实现类别树示例代码

    这篇文章主要给大家介绍了关于java利用递归实现类别树的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2020-12-12
  • Springboot Druid 自定义加密数据库密码的几种方案

    Springboot Druid 自定义加密数据库密码的几种方案

    这篇文章主要介绍了Springboot Druid 自定义加密数据库密码的步骤，帮助大家更好的理解和使用springboot，感兴趣的朋友可以了解下
    2020-12-12
  • Java中Comparable与Comparator的区别解析

    Java中Comparable与Comparator的区别解析

    这篇文章主要介绍了Java中Comparable与Comparator的区别解析,实现Comparable接口,重写compareTo方法,一般在实体类定义的时候就可以选择实现该接口,提供一个默认的排序方式,供Arrays.sort和Collections.sort使用,需要的朋友可以参考下
    2024-01-01

最新评论