在实际开发中，我们经常会遇到第三方api返回的json数据结构不一致的情况。例如，某个表示“报告列表”的字段，在只有一条报告时可能直接返回一个json对象，而在有多条报告时则返回一个json数组。这给传统的java对象映射（pojo）带来了挑战，因为pojo的字段类型通常是固定的（如list
以下是两种常见的JSON结构示例，其中RadarReport字段的类型是动态变化的：
示例1：RadarReport为单个对象
{"RadarReports": {
"executionTime": "135",
"RadarReport": {
"abc": "1116591",
"name": "abc",
"id": "2019050311582056119",
"ownerId": "xyz"
},
"size" :"1"
}}示例2：RadarReport为对象数组
{"RadarReports": {
"executionTime": "113",
"RadarReport": [
{
"abc": "1116591",
"name": "abc",
"id": "2019050311582056119",
"ownerId": "xyz"
},
{
"abc": "1116591",
"name": "abc",
"id": "2019050311582056119",
"ownerId": "xyz"
}
],
"size" : "2"
}}为了统一处理这两种情况，我们可以利用Gson提供的扩展机制——自定义TypeAdapterFactory。
解决方案：自定义TypeAdapterFactory
TypeAdapterFactory是一个接口，允许我们为特定类型创建自定义的TypeAdapter。TypeAdapter则负责定义Java对象与JSON数据之间的序列化和反序列化逻辑。
核心思想是：在反序列化RadarReport字段时，我们首先检查当前JSON令牌的类型。如果它是一个JSON对象（BEGIN_OBJECT），我们就将其读取为一个JsonObject，然后手动将其包装到一个JsonArray中。这样，无论是单个对象还是对象数组，最终都会被转换为JsonArray，然后我们就可以委托给Gson内置的列表适配器进行后续解析。
以下是自定义SingleObjectOrListAdapterFactory的实现：
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.TypeAdapter;
import com.google.gson.TypeAdapterFactory;
import com.google.gson.annotations.JsonAdapter;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.util.ArrayList;
// 仅用于 @JsonAdapter 注解
class SingleObjectOrListAdapterFactory implements TypeAdapterFactory {
@Override
public TypeAdapter create(Gson gson, TypeToken type) {
// 获取处理列表类型（如ArrayList）的默认适配器
// 注意：此处不能直接使用 gson.getDelegateAdapter(this, type)
// 因为可能导致无限递归或与Gson的内部机制冲突（参考GitHub issue 1028）
TypeAdapter listAdapterDelegate = gson.getAdapter(type);
// 获取处理JsonObject的适配器，用于读取单个JSON对象
TypeAdapter jsonObjectAdapter = gson.getAdapter(JsonObject.class);
return new TypeAdapter() {
@Override
public void write(JsonWriter out, T value) throws IOException {
// 序列化逻辑，通常直接委托给默认的列表适配器
listAdapterDelegate.write(out, value);
}
@Override
public T read(JsonReader in) throws IOException {
// 在读取之前，先“窥视”下一个JSON令牌的类型
if (in.peek() == JsonToken.BEGIN_OBJECT) {
// 如果当前令牌是JSON对象（即单个对象而非数组）
// 1. 读取该JSON对象
JsonObject jsonObject = jsonObjectAdapter.read(in);
// 2. 创建一个新的JSON数组
JsonArray jsonArray = new JsonArray();
// 3. 将读取到的单个JSON对象添加到数组中
jsonArray.add(jsonObject);
// 4. 将这个包装后的JSON数组委托给原始的列表适配器进行解析
return listAdapterDelegate.fromJsonTree(jsonArray);
} else {
// 如果当前令牌不是JSON对象（预期是BEGIN_ARRAY，即数组）
// 则直接委托给原始的列表适配器进行解析
return listAdapterDelegate.read(in);
}
}
};
}
} 应用自定义适配器
创建了SingleObjectOrListAdapterFactory之后，我们需要将其应用到POJO中对应的字段上。这可以通过@JsonAdapter注解实现。
假设我们的POJO结构如下：
import lombok.Data;
import com.google.gson.annotations.JsonAdapter;
import java.util.ArrayList;
@Data
public class RadarReport {
private String abc;
private String name;
private String id;
private String ownerId;
}
@Data
public class Radarreports {
private int size;
// 使用 @JsonAdapter 注解指定自定义的 TypeAdapterFactory
@JsonAdapter(SingleObjectOrListAdapterFactory.class)
private ArrayList RadarReport; // 注意这里是ArrayList
// 如果存在 RadarReportSet 字段，也需要根据实际情况处理
// private ArrayList RadarReportSet;
private String executionTime; // 添加缺失的字段
}
@Data
public class ReportsResponse {
private Radarreports RadarReports;
} 请注意，RadarReport字段的类型被定义为ArrayList
完整示例与注意事项
以下是如何使用Gson进行反序列化的完整示例：
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
public class JsonParsingExample {
public static void main(String[] args) {
// 模拟两种JSON输入
String jsonSingleObject = "{\"RadarReports\": {\"executionTime\": \"135\",\"RadarReport\": {\"abc\": \"1116591\",\"name\": \"abc\",\"id\": \"2019050311582056119\",\"ownerId\": \"xyz\"},\"size\" :\"1\"}}";
String jsonArrayObjects = "{\"RadarReports\": {\"executionTime\": \"113\",\"RadarReport\": [{\"abc\": \"1116591\",\"name\": \"abc\",\"id\": \"2019050311582056119\",\"ownerId\": \"xyz\"},{\"abc\": \"1116591\",\"name\": \"abc\",\"id\": \"2019050311582056119\",\"ownerId\": \"xyz\"}],\"size\" : \"2\"}}";
Gson gson = new GsonBuilder().create();
try {
// 解析单个对象的情况
System.out.println("--- Parsing Single Object JSON ---");
ReportsResponse responseSingle = gson.fromJson(jsonSingleObject, ReportsResponse.class);
System.out.println("Execution Time: " + responseSingle.getRadarReports().getExecutionTime());
System.out.println("Size: " + responseSingle.getRadarReports().getSize());
System.out.println("RadarReport Count: " + responseSingle.getRadarReports().getRadarReport().size());
if (!responseSingle.getRadarReports().getRadarReport().isEmpty()) {
System.out.println("First RadarReport ID: " + responseSingle.getRadarReports().getRadarReport().get(0).getId());
}
System.out.println("\n--- Parsing Array of Objects JSON ---");
// 解析数组对象的情况
ReportsResponse responseArray = gson.fromJson(jsonArrayObjects, ReportsResponse.class);
System.out.println("Execution Time: " + responseArray.getRadarReports().getExecutionTime());
System.out.println("Size: " + responseArray.getRadarReports().getSize());
System.out.println("RadarReport Count: " + responseArray.getRadarReports().getRadarReport().size());
if (!responseArray.getRadarReports().getRadarReport().isEmpty()) {
System.out.println("First RadarReport ID: " + responseArray.getRadarReports().getRadarReport().get(0).getId());
}
// 如果是从URL读取，可以这样：
// URL url = new URL(queryUrl);
// BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));
// ReportsResponse radarReports = gson.fromJson(br, ReportsResponse.class);
// br.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}注意事项：
- 适用场景： 这种方法特别适用于JSON中某个字段类型不确定，但在Java中希望统一表示为列表的情况。
- 性能考虑： 对于极大规模的JSON数据，频繁地进行peek()、创建JsonObject和JsonArray可能会带来轻微的性能开销。但对于大多数应用场景，这种开销是可接受的。
- 错误处理： 自定义适配器增强了健壮性，但如果JSON结构完全不符合预期（例如，RadarReport字段既不是对象也不是数组，而是字符串或数字），仍可能抛出IOException或其他Gson解析异常，需要进行适当的异常捕获和处理。
- Gson版本： 确保使用的Gson版本支持TypeAdapterFactory和@JsonAdapter注解。本文示例基于较新的Gson版本。
- 字段名一致性： 确保POJO中的字段名与JSON中的键名保持一致，或者使用@SerializedName注解进行映射。
通过自定义TypeAdapterFactory，我们能够灵活地处理Gson默认解析器无法直接应对的复杂或动态变化的JSON结构，极大地增强了JSON反序列化的健壮性和适应性。这种模式在处理第三方API数据时尤为有用，能够有效避免因数据格式不一致而导致的解析失败。
