Gson解析动态JSON：对象数组统一处理方法

还在为Gson解析动态JSON中，字段类型不确定（对象或数组）而烦恼吗？本文针对这一常见问题，提供了一种高效、通用的解决方案。通过自定义Gson的TypeAdapterFactory，巧妙地处理单对象和对象数组的统一解析。该方案的核心在于，反序列化时动态判断JSON令牌类型，将单个对象自动包装成数组，从而保证数据模型的一致性，避免解析错误。本文提供详细代码示例，包括自定义TypeAdapterFactory的实现和在POJO中的应用，助你轻松应对第三方API返回的复杂JSON数据，提升Android或Java开发的效率和数据处理的健壮性。立即学习，告别Gson解析难题！

针对JSON数据中某个字段可能为单个对象或对象数组的动态结构，本文提供了一种基于Gson库的通用解析策略。通过实现自定义的TypeAdapterFactory，在反序列化时智能判断JSON令牌类型，并将单对象自动包装成数组，从而确保数据模型能够统一处理这两种情况，避免解析错误。

在实际开发中，我们经常会遇到第三方API返回的JSON数据结构不一致的情况。例如，某个表示“报告列表”的字段，在只有一条报告时可能直接返回一个JSON对象，而在有多条报告时则返回一个JSON数组。这给传统的Java对象映射（POJO）带来了挑战，因为POJO的字段类型通常是固定的（如List或RadarReport）。直接使用Gson进行反序列化时，如果JSON结构与POJO定义不符，就会导致解析失败。

以下是两种常见的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 <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        // 获取处理列表类型（如ArrayList<RadarReport>）的默认适配器
        // 注意：此处不能直接使用 gson.getDelegateAdapter(this, type)
        // 因为可能导致无限递归或与Gson的内部机制冲突（参考GitHub issue 1028）
        TypeAdapter<T> listAdapterDelegate = gson.getAdapter(type);

        // 获取处理JsonObject的适配器，用于读取单个JSON对象
        TypeAdapter<JsonObject> jsonObjectAdapter = gson.getAdapter(JsonObject.class);

        return new TypeAdapter<T>() {
            @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> RadarReport; // 注意这里是ArrayList
    // 如果存在 RadarReportSet 字段，也需要根据实际情况处理
    // private ArrayList<RadarreportSet> RadarReportSet; 
    private String executionTime; // 添加缺失的字段
}

@Data
public class ReportsResponse {
    private Radarreports RadarReports;
}

请注意，RadarReport字段的类型被定义为ArrayList，并且通过@JsonAdapter注解引用了我们自定义的SingleObjectOrListAdapterFactory。这样，无论JSON中RadarReport是单个对象还是数组，Gson都会通过我们自定义的逻辑进行处理，最终将其解析为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();
        }
    }
}

注意事项：

1. 适用场景： 这种方法特别适用于JSON中某个字段类型不确定，但在Java中希望统一表示为列表的情况。
2. 性能考虑： 对于极大规模的JSON数据，频繁地进行peek()、创建JsonObject和JsonArray可能会带来轻微的性能开销。但对于大多数应用场景，这种开销是可接受的。
3. 错误处理： 自定义适配器增强了健壮性，但如果JSON结构完全不符合预期（例如，RadarReport字段既不是对象也不是数组，而是字符串或数字），仍可能抛出IOException或其他Gson解析异常，需要进行适当的异常捕获和处理。
4. Gson版本： 确保使用的Gson版本支持TypeAdapterFactory和@JsonAdapter注解。本文示例基于较新的Gson版本。
5. 字段名一致性： 确保POJO中的字段名与JSON中的键名保持一致，或者使用@SerializedName注解进行映射。

通过自定义TypeAdapterFactory，我们能够灵活地处理Gson默认解析器无法直接应对的复杂或动态变化的JSON结构，极大地增强了JSON反序列化的健壮性和适应性。这种模式在处理第三方API数据时尤为有用，能够有效避免因数据格式不一致而导致的解析失败。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。