Gson处理动态JSON结构：单对象与数组的统一解析策略

{"RadarReports": {
    "executionTime": "135",
    "RadarReport": {
        "abc": "1116591",
        "name": "abc",
        "id": "2019050311582056119",
        "ownerId": "xyz"
    },
    "size" :"1"
}}

{"RadarReports": {
    "executionTime": "113",
    "RadarReport": [
        {
            "abc": "1116591",
            "name": "abc",
            "id": "2019050311582056119",
            "ownerId": "xyz"
        },
        {
            "abc": "1116591",
            "name": "abc",
            "id": "2019050311582056119",
            "ownerId": "xyz"
        }
    ],
    "size" : "2"
}}

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);
                }
            }
        };
    }
}

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;
}

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();
        }
    }
}