如何解析包含两个不同对象数组的JSON响应？

嘿，我懂你现在的处境——单个对象数组的解析已经玩得转，但碰到根对象里塞了两个不同类型的对象数组就有点摸不着头脑了对吧？其实本质上和单个数组的解析逻辑是一致的，只是多了一步“分别提取”的操作而已。

先给你补一个更完整的示例JSON（在你提供的shifts数组基础上，我加了一个staff数组来模拟双数组场景）：

{
  "shifts": [
    {
      "id": 4,
      "region": "Eastern",
      "city": "Khobar",
      "nationality": "1",
      "id_service": 2,
      "shift_date": "2018-04-05",
      "shift_type": "night",
      "weekday": "sunday",
      "quantity_staff": 8,
      "lead_hours": 2,
      "created_at": "2018-04-23 11:46:20",
      "updated_at": "2018-04-24 08:46:14",
      "deleted_at": null
    }
  ],
  "staff": [
    {
      "id": 12,
      "name": "Ahmed",
      "shift_id": 4,
      "role": "lead",
      "hours_worked": 10
    },
    {
      "id": 13,
      "name": "Sara",
      "shift_id": 4,
      "role": "staff",
      "hours_worked": 8
    }
  ]
}

下面我用两种主流语言来演示具体的解析方法：

1. Python 解析方案 #

Python处理JSON非常灵活，直接用内置的json模块就能搞定，不需要额外定义类：

import json

# 假设这是你获取到的JSON响应字符串
json_str = '''
{
  "shifts": [
    {
      "id": 4,
      "region": "Eastern",
      "city": "Khobar",
      "nationality": "1",
      "id_service": 2,
      "shift_date": "2018-04-05",
      "shift_type": "night",
      "weekday": "sunday",
      "quantity_staff": 8,
      "lead_hours": 2,
      "created_at": "2018-04-23 11:46:20",
      "updated_at": "2018-04-24 08:46:14",
      "deleted_at": null
    }
  ],
  "staff": [
    {
      "id": 12,
      "name": "Ahmed",
      "shift_id": 4,
      "role": "lead",
      "hours_worked": 10
    },
    {
      "id": 13,
      "name": "Sara",
      "shift_id": 4,
      "role": "staff",
      "hours_worked": 8
    }
  ]
}
'''

# 第一步：解析整个JSON根对象
data = json.loads(json_str)

# 第二步：分别提取两个数组
shifts_list = data["shifts"]
staff_list = data["staff"]

# 第三步：遍历处理每个数组里的对象
print("=== 处理shifts数组 ===")
for shift in shifts_list:
    print(f"班次ID: {shift['id']}, 城市: {shift['city']}, 类型: {shift['shift_type']}")

print("\n=== 处理staff数组 ===")
for staff in staff_list:
    print(f"员工姓名: {staff['name']}, 角色: {staff['role']}, 工时: {staff['hours_worked']}")

2. Java + Gson 解析方案 #

Java是强类型语言，需要先为每个数组的对象定义实体类，再用一个根类来包裹两个数组：

第一步：创建实体类 #

// Shift.java - 对应shifts数组里的对象
public class Shift {
    private int id;
    private String region;
    private String city;
    private String nationality;
    private int id_service;
    private String shift_date;
    private String shift_type;
    private String weekday;
    private int quantity_staff;
    private int lead_hours;
    private String created_at;
    private String updated_at;
    private String deleted_at;

    // 自动生成getter和setter方法（IDE里右键就能生成）
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }
    // 其他属性的getter/setter同理
}

// Staff.java - 对应staff数组里的对象
public class Staff {
    private int id;
    private String name;
    private int shift_id;
    private String role;
    private int hours_worked;

    // 同样生成getter和setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getRole() { return role; }
    public void setRole(String role) { this.role = role; }
    // 其他属性的getter/setter同理
}

第二步：创建根响应类 #

// ShiftStaffResponse.java - 包裹两个数组的根对象
public class ShiftStaffResponse {
    private List<Shift> shifts;
    private List<Staff> staff;

    // 生成getter方法
    public List<Shift> getShifts() { return shifts; }
    public List<Staff> getStaff() { return staff; }
}

第三步：解析JSON #

import com.google.gson.Gson;
import java.util.List;

public class JsonParserDemo {
    public static void main(String[] args) {
        String jsonStr = "你的JSON响应字符串";
        Gson gson = new Gson();
        
        // 解析整个根对象
        ShiftStaffResponse response = gson.fromJson(jsonStr, ShiftStaffResponse.class);
        
        // 提取并处理shifts数组
        List<Shift> shifts = response.getShifts();
        for (Shift shift : shifts) {
            System.out.println("班次ID: " + shift.getId() + ", 城市: " + shift.getCity());
        }
        
        // 提取并处理staff数组
        List<Staff> staffList = response.getStaff();
        for (Staff staff : staffList) {
            System.out.println("员工姓名: " + staff.getName() + ", 角色: " + staff.getRole());
        }
    }
}

核心总结 #

不管用哪种语言，核心逻辑都是：

1. 先解析整个JSON根对象，拿到顶层的键值对
2. 根据数组的键名（比如shifts、staff）分别提取对应的数组
3. 按照单个对象数组的解析方式处理每个数组里的元素

强类型语言需要提前定义对应的数据类，弱类型语言可以直接操作字典/对象，灵活度更高。

内容的提问来源于stack exchange，提问作者lamatat