json反序列化问题踩坑

前言

最近我在做知识星球中的商品秒杀系统,昨天遇到了一个诡异的json反序列化问题,感觉挺有意思的,现在拿出来跟大家一起分享一下,希望对你会有所帮助。

案发现场

我最近在做知识星球中的商品秒杀系统,写了一个filter,获取用户请求的header中获取JWT的token信息。

然后根据token信息,获取到用户信息。

在转发到业务接口之前,将用户信息设置到用户上下文当中。

这样接口中的业务代码,就能通过用户上下文,获取到当前登录的用户信息了。

我们的token和用户信息,为了性能考虑都保存到了Redis当中。

用户信息是一个json字符串。

当时在用户登录接口中,将用户实体,使用fastjson工具,转换成了字符串:

JSON.toJSONString(userDetails);

保存到了Redis当中。

然后在filter中,通过一定的key,获取Redis中的字符串,反序列化成用户实体。

使用的同样是fastjson工具:

JSON.parseObject(json, UserEntity.class);

但在反序列化的过程中,filter抛异常了:
com.alibaba.fastjson.JSONException: illegal identifier : \pos 1, line 1, column 2{\"accountNonExpired\":true,\"accountNonLocked\":true,\"authorities\":[{\"authority\":\"admin\"}],\"credentialsNonExpired\":true,\"enabled\":true,\"id\":13,\"password\":\"$2a$10$o3XfeGr0SHStAwLuJRW6y.kE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe\",\"roles\":[\"admin\"],\"username\":\"admin\"}

2 分析问题

我刚开始以为是json数据格式有问题。

将json字符串复制到在线json工具:https://www.sojson.com,先去掉化之后,再格式数据,发现json格式没有问题:

然后写了一个专门的测试类,将日志中打印的json字符串复制到json变量那里,使用JSON.parseObject方法,将json字符串转换成Map对象:

public class Test {

    public static void main(String[] args) {
        String json = "{\"accountNonExpired\":true,\"accountNonLocked\":true,\"authorities\":[{\"authority\":\"admin\"}],\"credentialsNonExpired\":true,\"enabled\":true,\"id\":13,\"password\":\"$2a$10$o3XfeGr0SHStAwLuJRW6y.kE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe\",\"roles\":[\"admin\"],\"username\":\"admin\"}";
        Map map = JSON.parseObject(json, Map.class);
        // 输出解析后的 JSON 对象
        System.out.println(map);
    }
}

执行结果:

{password=$2a$10$o3XfeGr0SHStAwLuJRW6y.kE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe, credentialsNonExpired=true, roles=["admin"], accountNonExpired=true, id=13, authorities=[{"authority":"admin"}], enabled=true, accountNonLocked=true, username=admin}

竟然转换成功了。

这就让我有点懵逼了。。。

为什么相同的json字符串,在Test类中能够正常解析,而在filter当中却不行?

当时怕搞错了,debug了一下filter,发现获取到的json数据,跟Test类中的一模一样:

带着一脸的疑惑,我做了下面的测试。

莫非是反序列化工具有bug?

3 改成gson工具

我尝试了一下将json的反序列化工具改成google的gson,代码如下:

 Map map = new Gson().fromJson(userJson, Map.class);

运行之后,报了一个新的异常:
com.google.gson.JsonSyntaxException: java.lang.IllegalStateException: Expected BEGIN_OBJECT but was STRING at line 1 column 2 path $

这里提示json字符串中包含了:$

$是特殊字符,password是做了加密处理的,里面包含$.,这两种特殊字符。

为了快速解决问题,我先将这两个特字符替换成空字符串:

json = json.replace("$","").replace(".","");

日志中打印出的json中的password,已经不包含这两个特殊字符了:

2a10o3XfeGr0SHStAwLuJRW6ykE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe

但调整之后代码报了下面的异常:
com.google.gson.JsonSyntaxException: com.google.gson.stream.MalformedJsonException: Expected name at line 1 column 2 path $.

跟刚刚有点区别,但还是有问题。

4 改成jackson工具

我又尝试了一下json的反序列化工具,改成Spring自带的的jackson工具,代码如下:

ObjectMapper objectMapper = new ObjectMapper();
try {
    Map map = objectMapper.readValue(json, Map.class);
} catch (JsonProcessingException e) {
    e.printStackTrace();
}

调整之后,反序列化还是报错:
com.fasterxml.jackson.core.JsonParseException: Unexpected character ('\' (code 92)): was expecting double-quote to start field name

3种反序列化工具都不行,说明应该不是fastjson的bug导致的当前json字符串,反序列化失败。

到底是什么问题呢?

5 转义

之前的数据,我在仔细看了看。

里面是对双引号,是使用了转义的,具体是这样做的:\"

莫非还是这个转义的问题?

其实我之前已经注意到了转义的问题,但使用Test类测试过,没有问题。

当时的代码是这样的:

public class Test {

    public static void main(String[] args) {
        String json = "{\"accountNonExpired\":true,\"accountNonLocked\":true,\"authorities\":[{\"authority\":\"admin\"}],\"credentialsNonExpired\":true,\"enabled\":true,\"id\":13,\"password\":\"$2a$10$o3XfeGr0SHStAwLuJRW6y.kE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe\",\"roles\":[\"admin\"],\"username\":\"admin\"}";
        Map map = JSON.parseObject(json, Map.class);
        // 输出解析后的 JSON 对象
        System.out.println(map);
    }
}

里面也包含了一些转义字符。

我带着试一试的心态,接下来,打算将转义字符去掉。

看看原始的json字符串,解析有没有问题。

怎么去掉转义字符呢?

手写工具类,感觉不太好,可能会写漏一些特殊字符的场景。

我想到了org.apache.commons包下的StringEscapeUtils类,它里面的unescapeJava方法,可以轻松去掉Java代码中的转义字符。

于是,我调整了一下代码:

json = StringEscapeUtils.unescapeJava(json);
JSON.parseObject(json, UserEntity.class);

这样处理之后,发现反序列化成功了。

总结

这个问题最终发现还是转义的问题。

那么,之前Test类中json字符串,也使用了转义,为什么没有问题?

当时的代码是这样的:

public class Test {

    public static void main(String[] args) {
        String json = "{\"accountNonExpired\":true,\"accountNonLocked\":true,\"authorities\":[{\"authority\":\"admin\"}],\"credentialsNonExpired\":true,\"enabled\":true,\"id\":13,\"password\":\"$2a$10$o3XfeGr0SHStAwLuJRW6y.kE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe\",\"roles\":[\"admin\"],\"username\":\"admin\"}";
        Map map = JSON.parseObject(json, Map.class);
        System.out.println(map);
    }
}

但在filter中的程序,在读取到这个json字符串之后,发现该字符串中包含了\转义符号,程序自动把它变成了\\\

调整一下Test类的main方法,改成三个斜杠的json字符串:

public static void main(String[] args) {
    String json = "{\\\"accountNonExpired\\\":true,\\\"accountNonLocked\\\":true,\\\"authorities\\\":[{\\\"authority\\\":\\\"admin\\\"}],\\\"credentialsNonExpired\\\":true,\\\"enabled\\\":true,\\\"id\\\":13,\\\"password\\\":\\\"$2a$10$o3XfeGr0SHStAwLuJRW6y.kE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe\\\",\\\"roles\\\":[\\\"admin\\\"],\\\"username\\\":\\\"admin\\\"}";
    Map map = JSON.parseObject(json, Map.class);
    System.out.println(map);
}

执行结果:
Exception in thread "main" com.alibaba.fastjson.JSONException: illegal identifier : \pos 1, line 1, column 2{\"accountNonExpired\":true,\"accountNonLocked\":true,\"authorities\":[{\"authority\":\"admin\"}],\"credentialsNonExpired\":true,\"enabled\":true,\"id\":13,\"password\":\"$2a$10$o3XfeGr0SHStAwLuJRW6y.kE0UTerQfv3SXrAcVLuJ6M3hEsC9RKe\",\"roles\":[\"admin\"],\"username\":\"admin\"}
抛出了跟文章最开始一样的异常。

说明其实就是转义的问题。

之前,我将项目的日志中的json字符串,复制到idea的Test的json变量中,当时将最外层的双引号一起复制过来了,保存的是1个斜杠的数据。

这个操作把我误导了。

而后面从在线的json工具中,把相同的json字符串,复制到idea的Test的json变量中,在双引号当中粘贴数据,保存的却是3个斜杠的数据,它会自动转义。

让我意识到了问题。

好了,下次如果遇到类似的问题,可以直接使用org.apache.commons包下的StringEscapeUtils类,先去掉转义,再反序列化,这样可以快速解决问题。

此外,这次使用了3种不同的反序列化工具,也看到了其中的一些差异。

如果你对日常工作中的一些坑,比较感兴趣,可以看看我的技术专栏《程序员最常见的100个问题》,里面有很多干货,还是非常值得一看的。

JSON是基于JAVA8编写,对比阿里的JSON三次测试结果如下: 10万次序列化,1万次反序列化,毫秒。 阿里序列化时间 1122 1054 1115 阿里反序列化时间 409 423 412 HZS序列化时间 884 864 880 HZS反序列化时间 392 375 394 JAVA7版已经逼近阿里的速度,JAVA8版利用了闭包技术,充份发挥多核优势,已经超过阿里的速度。 测试代码如下: { org.hzs.json.JSONObject bjson; java.util.LinkedList<String> jd_Set = new java.util.LinkedList<>(); java.util.Random d1 = new java.util.Random(); java.util.UUID d2; int ji_i; long ji起始时间_i; long ji截至时间_i; java.util.Date date = new java.util.Date(); //生成1万个序列化後的文本 for (ji_i = 0; ji_i < 10000; ji_i++) { bjson = org.hzs.json.JSONObject.d副本(); bjson.put("a1", d1.nextDouble()); bjson.put("a2", d1.nextDouble()); bjson.put("a3", d1.nextDouble()); bjson.put("a4", d1.nextInt()); bjson.put("a5", d1.nextInt()); bjson.put("a6", d1.nextLong()); bjson.put("a7", d1.nextBoolean()); d2 = java.util.UUID.randomUUID(); bjson.put("b1", d2.toString()); d2 = java.util.UUID.randomUUID(); bjson.put("b2", d2.toString()); d2 = java.util.UUID.randomUUID(); bjson.put("b3", d2.toString()); d2 = java.util.UUID.randomUUID(); bjson.put("b4", d2.toString()); bjson.put("c", new java.util.Date()); jd_Set.add(bjson.toString()); } com.alibaba.fastjson.JSONObject ajson, a1json = new com.alibaba.fastjson.JSONObject(); ji起始时间_i = java.util.Calendar.getInstance().getTimeInMillis(); for (ji_i = 0; ji_i < 100000; ji_i++) { ajson = (com.alibaba.fastjson.JSONObject) a1json.clone(); ajson.put("a1", d1.nextDouble()); ajson.put("a2", d1.nextDouble()); ajson.put("a3", d1.nextDouble()); ajson.put("a4", d1.nextInt()); ajson.put("a5", d1.nextInt()); ajson.put("a6", d1.nextLong()); ajson.put("a7", d1.nextBoolean()); d2 = java.util.UUID.randomUUID(); ajson.put("b1", d2.toString()); d2 = java.util.UUID.randomUUID(); ajson.put("b2", d2.toString()); d2 = java.util.UUID.randomUUID(); ajson.put("b3", d2.toString()); d2 = java.util.UUID.randomUUID(); ajson.put("b4", d2.toString()); ajson.put("c", new java.util.Date()); ajson.toString(); } ji截至时间_i = java.util.Calendar.getInstance().getTimeInMillis(); System.out.print("阿里变量序列化时间:"); System.out.println(ji截至时间_i - ji起始时间_i); ji起始时间_i = java.util.Calendar.getInstance().getTimeInMillis(); for (ji_i = 0; ji_i < 10000; ji_i++) { ajson = com.alibaba.fastjson.JSONObject.parseObject(jd_Set.get(ji_i)); } ji截至时间_i = java.util.Calendar.getInstance().getTimeInMillis(); System.out.print("阿里反序列化时间:"); System.out.println(ji截至时间_i - ji起始时间_i); ji起始时间_i = java.util.Calendar.getInstance().getTimeInMillis(); for (ji_i = 0; ji_i < 100000; ji_i++) { bjson = org.hzs.json.JSONObject.d副本(); bjson.put("a1", d1.nextDouble()); bjson.put("a2", d1.nextDouble()); bjson.put("a3", d1.nextDouble()); bjson.put("a4", d1.nextInt()); bjson.put("a5", d1.nextInt()); bjson.put("a6", d1.nextLong()); bjson.put("a7", d1.nextBoolean()); d2 = java.util.UUID.randomUUID(); bjson.put("b1", d2.toString()); d2 = java.util.UUID.randomUUID(); bjson.put("b2", d2.toString()); d2 = java.util.UUID.randomUUID(); bjson.put("b3", d2.toString()); d2 = java.util.UUID.randomUUID(); bjson.put("b4", d2.toString()); bjson.put("c", new java.util.Date()); bjson.toString(); } ji截至时间_i = java.util.Calendar.getInstance().getTimeInMillis(); System.out.print("HZS变量序列化时间:"); System.out.println(ji截至时间_i - ji起始时间_i); ji起始时间_i = java.util.Calendar.getInstance().getTimeInMillis(); for (ji_i = 0; ji_i < 10000; ji_i++) { bjson = org.hzs.json.JSONObject.d副本(jd_Set.get(ji_i)); } ji截至时间_i = java.util.Calendar.getInstance().getTimeInMillis(); System.out.print("HZS反序列化时间:"); System.out.println(ji截至时间_i - ji起始时间_i); }
<think>嗯,用户之前问过Protobuf是什么,现在又问如何在Java反序列化。这说明他们已经对Protobuf有了基本了解,现在需要具体的实现步骤。可能是在实际开发中遇到了反序列化问题,或者在学习过程中想深入实践。 用户可能想知道具体的代码示例,步骤是否清晰,以及需要注意哪些问题。他们可能希望得到一个从定义.proto文件到生成Java代码,再到实际反序列化的完整流程。需要确保步骤详细,尤其是protoc编译器的使用和依赖配置,因为Java项目需要特定的库支持。 另外,用户可能对异常处理感兴趣,比如如何处理无效数据。或者是否需要考虑不同版本的兼容性,比如proto2和proto3的区别。还有可能想了解性能优化的技巧,比如复用对象来减少内存分配。 需要注意的是,用户可能对Maven或Gradle的依赖配置不太熟悉,所以需要给出具体的依赖示例。同时,反序列化的代码示例要简洁明了,展示如何从字节数组转换回对象。 最后,可能还需要提醒用户关于字段编号的兼容性,修改.proto文件时的注意事项,以及如何确保生成的代码与现有代码兼容。这些都是实际开发中容易遇到的问题,提前说明可以避免用户。</think>--- ### **Protobuf 在 Java 中的反序列化步骤** Protobuf 在 Java 中的反序列化需要以下步骤: **1. 定义 `.proto` 文件 → 2. 生成 Java 类 → 3. 使用生成的类解析字节流**。 以下是详细实现: --- #### **1. 定义 `.proto` 文件** 假设定义一个简单的消息结构 `User`: ```protobuf syntax = "proto3"; message User { int32 id = 1; string name = 2; repeated string emails = 3; // 列表类型字段 } ``` --- #### **2. 生成 Java 类** 使用 `protoc` 编译器生成 Java 代码: ```bash # 安装 Protobuf 编译器(需提前安装) # 生成代码命令: protoc --java_out=./src/main/java user.proto ``` 生成的 Java 类路径为: `src/main/java/com/example/User.java`(根据 `.proto` 中的 `package` 定义生成)。 --- #### **3. 添加 Maven/Gradle 依赖** 在项目中引入 Protobuf 的 Java 运行时库: **Maven**: ```xml <dependency> <groupId>com.google.protobuf</groupId> <artifactId>protobuf-java</artifactId> <version>3.22.0</version> <!-- 使用最新版本 --> </dependency> ``` **Gradle**: ```groovy implementation 'com.google.protobuf:protobuf-java:3.22.0' ``` --- #### **4. Java 反序列化代码示例** 假设已通过网络或文件获取到字节流 `byte[] data`,反序列化步骤如下: ```java import com.example.User; // 导入生成的类 public class ProtoDeserializer { public static void main(String[] args) { try { // 假设 data 是从外部接收的字节流 byte[] data = ...; // 反序列化:字节流 → User 对象 User user = User.parseFrom(data); // 访问字段 System.out.println("ID: " + user.getId()); System.out.println("Name: " + user.getName()); System.out.println("Emails: " + user.getEmailsList()); } catch (InvalidProtocolBufferException e) { System.err.println("反序列化失败: " + e.getMessage()); } } } ``` --- ### **关键方法解析** | **方法** | **作用** | |-------------------------|--------------------------------------------------------------------------| | `User.parseFrom(byte[])` | 将字节数组直接反序列化为 `User` 对象(最常用方式)。 | | `User.parseFrom(InputStream)` | 从输入流(如网络流、文件流)逐步解析数据。 | | `User.newBuilder().mergeFrom(...).build()` | 通过 Builder 合并多个数据源(适用于分块读取场景)。 | --- ### **注意事项** 1. **异常处理** - 反序列化可能抛出 `InvalidProtocolBufferException`,需捕获处理。 - 无效数据(如字段类型不匹配、缺失必填字段)会导致解析失败。 2. **字段兼容性** - 反序列化时,若字节流中的字段在 `.proto` 定义中不存在,会被忽略(不报错)。 - 新增字段需确保新旧版本 `.proto` 文件的字段编号不冲突。 3. **性能优化** - 复用 `Builder` 对象以减少内存分配(高频调用场景适用): ```java User.Builder builder = User.newBuilder(); for (byte[] chunk : dataChunks) { builder.mergeFrom(chunk); // 合并分片数据 } User user = builder.build(); ``` --- ### **完整流程图示** ``` 字节流(网络/文件) → User.parseFrom(data) → Java 对象 → 读取字段 ``` --- ### **常见问题** **Q1:反序列化时字段缺失怎么办?** - Protobuf 的字段默认是**可选**的(proto3 中所有字段均为 `optional`),缺失字段会返回默认值(如 `0`、`""`、`空列表`)。 **Q2:如何处理旧数据与新 `.proto` 定义的兼容性?** - 新增字段时,确保新字段的编号在旧版本中未使用,旧代码会直接忽略未知字段。 **Q3:如何解析 JSON 到 Protobuf 对象?** - 使用 Protobuf 的 `JsonFormat` 工具类: ```java import com.google.protobuf.util.JsonFormat; User.Builder builder = User.newBuilder(); JsonFormat.parser().merge(jsonString, builder); User user = builder.build(); ``` --- ### **总结** - Protobuf 在 Java反序列化的核心是 **`parseFrom` 方法**。 - 需预先通过 `protoc` 生成 Java 类,并引入 Protobuf 运行时库。 - 支持灵活处理字段缺失和版本兼容性,适合高性能数据传输场景。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值