fastjson2 嵌套类型解析 子类型解析
Json是现在最常用的数据交互方式之一，经常需要面临Json数据解析的问题。那么如何使用解析工具，针对结果的包装类型或者嵌套的类型进行解析呢？
不确定具体的子类型，如何进行处理？
如果嵌套的类型并不清楚具体的类型是什么，终归是要想办法知道的，否则，就没有办法解析。
之前有过一篇Json解析方面的文章
https://crazybytex.com/thread-89-1-1.html
今天主要介绍的是另外的处理形式。
比如
!(data/attachment/forum/202207/30/150048o6l6zljcndyvdczv.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "image.png")
对于子类型，可以通过额外的字段进行标记，形成`key-value`的形式，参数传递的时候，能够获得一个唯一的标志符
通过这个唯一的标志符，Java代码中，通过Map或者任何形式，能够拿到对应的`Class`对象
就可以进一步进行处理。
代码样例记录如下：
### 数据封装类
type就是标志符，实际的数据是data区域
```java
package com.crazybytex.fragment.jsontyperesolver;
/**
* @description
* @Author 本文作者 程序员潇然 疯狂的字节X https://www.crazybytex.com/
* @Date 2022/7/29 10:39
* @Description 见Tester 注释
**/
public class MessageWrapper {
private Message data;
private String type;
public Message getData() {
return data;
}
public void setData(Message data) {
this.data = data;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("MessageWrapper{");
sb.append("data=").append(data);
sb.append(", type='").append(type).append('\'');
sb.append('}');
return sb.toString();
}
}
```
### 类型映射
```java
package com.crazybytex.fragment.jsontyperesolver;
import java.util.HashMap;
import java.util.Map;
/**
* @description
* @Author 本文作者 程序员潇然 疯狂的字节X https://www.crazybytex.com/
* @Date 2022/7/29 10:10
* @Description 见Tester 注释
**/
public class TypeMapperMap {
public static final Map<String, Class<? extends Message>> FRAME_HOLDER = new HashMap<>();
static {
FRAME_HOLDER.put("1", Message1.class);
FRAME_HOLDER.put("2", Message2.class);
}
public static Class<? extends Message> type(String packageType) {
return FRAME_HOLDER.get(packageType);
}
}
```
### 测试类
```java
package com.crazybytex.fragment.jsontyperesolver;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
/**
* @description
* @Author 本文作者 程序员潇然 疯狂的字节X https://www.crazybytex.com/
* @Date 2022/7/29 10:43
* @Description 用来记录 FastJson2 针对不用的子类型的解析
* <p>
* 对于常用的返回结果,通常是下面的这种形式,或者是嵌套的类型都可以使用
* <p>
* 借助于 MessageWrapper 封装类型,和实际的数据
* 格式为
* type和data
* type 用于类型标记,简单说就是可以根据这个值找到具体的类型, 比如可以通过配置,通过map进行获取等等,总之能找到具体子类型就可以
* 比如我使用的就是map详情见 TypeMapperMap
* data是具体子类型的数据的json部分,这里面的所有的字段才是真正的数据
* {
* "data": {
* "code": "2",
* "message2": "msg22",
* "message2Other": "meg2-other",
* "msg": "msg0-2"
* data里面的内容无所谓,只要是对应的子类型的json数据即可
* },
* "type": "2"
* }
* <p>
* 思路就是分两次解析
* 第一次解析,结果为MessageWrapper,这样里面的type字段就可以拿到了
* 第二次获取JSONObject中的data字段的属性,解析为对应的子类型即可
**/
public class Tester {
public static void main(String[] args) {
/*
{"code":"0","msg":"message "}
{"code":"1","message1":"msg11","msg":"msg0-1"}
{"code":"2","message2":"msg22","message2Other":"meg2-other","msg":"msg0-2"}
* */
String testJsonString1 = "{\n" +
"\t\"data\": {\n" +
"\t\t\"code\": \"1\",\n" +
"\t\t\"message1\": \"msg11\",\n" +
"\t\t\"msg\": \"msg0-1\"\n" +
"\t},\n" +
"\t\"type\": \"1\"\n" +
"}";
String testJsonString2 = "{\"data\":{\"code\":\"2\",\"message2\":\"msg22\",\"message2Other\":\"meg2-other\",\"msg\":\"msg0-2\"},\"type\":\"2\"}";
String test = testJsonString2;
/*************************************************/
MessageWrapper messageWrapper = JSON.parseObject(test, MessageWrapper.class);
JSONObject jsonObject = JSON.parseObject(test);
Message message = jsonObject.getObject("data", TypeMapperMap.type(messageWrapper.getType()));
messageWrapper.setData(message);
//可以看到已经变为具体的类型了,还可以根据具体的子类型进行不同的逻辑处理
if (messageWrapper.getData() instanceof Message1) {
System.out.println("处理消息类型1" + messageWrapper);
} else if (messageWrapper.getData() instanceof Message2) {
System.out.println("处理消息类型2" + messageWrapper);
}
}
}
```
完整代码如下:
`https://gitee.com/crazybytex/java-code-fragment/tree/master/src/main/java/com/crazybytex/fragment/jsontyperesolver`
简单说就是经过多次解析，进行处理。
!(data/attachment/forum/202206/16/141330jha7st9soow8772i.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/300 "common_log.png")
`转载务必注明出处：程序员潇然，疯狂的字节X，https://crazybytex.com/thread-103-1-1.html `
页:
[1]