java中如何接收嵌套json

Java中如何接收嵌套JSON：从基础到实践的完整指南

在当今的软件开发中，JSON已成为数据交换的主流格式之一，而在Java中处理嵌套JSON数据是一项常见且重要的技能，本文将详细介绍在Java中如何接收、解析和处理嵌套JSON数据，从基础概念到实际应用,帮助开发者这一关键技术。

理解嵌套JSON的结构

嵌套JSON是指JSON数据中包含其他JSON对象或数组作为其值的情况。

{
  "name": "张三",
  "age": 30,
  "address": {
    "city": "北京",
    "district": "朝阳区"
  },
  "contacts": [
    {
      "type": "手机",
      "number": "13812345678"
    },
    {
      "type": "邮箱",
      "number": "zhangsan@example.com"
    }
  ]
}

这个例子中，address是一个嵌套的JSON对象，而contacts是一个包含JSON对象的数组。

使用Java原生方式处理嵌套JSON

使用org.json库

添加依赖（Maven）：

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20231013</version>
</dependency>

然后解析嵌套JSON：

import org.json.JSONObject;
import org.json.JSONArray;
public class NestedJsonExample {
    public static void main(String[] args) {
        String jsonStr = "{\"name\":\"张三\",\"age\":30,\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\"},\"contacts\":[{\"type\":\"手机\",\"number\":\"13812345678\"},{\"type\":\"邮箱\",\"number\":\"zhangsan@example.com\"}]}";
        JSONObject jsonObject = new JSONObject(jsonStr);
        // 获取简单字段
        String name = jsonObject.getString("name");
        int age = jsonObject.getInt("age");
        // 获取嵌套JSON对象
        JSONObject address = jsonObject.getJSONObject("address");
        String city = address.getString("city");
        String district = address.getString("district");
        // 获取嵌套JSON数组
        JSONArray contacts = jsonObject.getJSONArray("contacts");
        for (int i = 0; i < contacts.length(); i++) {
            JSONObject contact = contacts.getJSONObject(i);
            String type = contact.getString("type");
            String number = contact.getString("number");
            System.out.println("联系方式类型: " + type + ", 号码: " + number);
        }
    }
}

使用Gson库

添加依赖（Maven）：

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

定义对应的Java类：

public class Person {
    private String name;
    private int age;
    private Address address;
    private List<Contact> contacts;
    // getters and setters
}
public class Address {
    private String city;
    private String district;
    // getters and setters
}
public class Contact {
    private String type;
    private String number;
    // getters and setters
}

解析JSON：

import com.google.gson.Gson;
public class GsonNestedJsonExample {
    public static void main(String[] args) {
        String jsonStr = "{\"name\":\"张三\",\"age\":30,\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\"},\"contacts\":[{\"type\":\"手机\",\"number\":\"13812345678\"},{\"type\":\"邮箱\",\"number\":\"zhangsan@example.com\"}]}";
        Gson gson = new Gson();
        Person person = gson.fromJson(jsonStr, Person.class);
        System.out.println("姓名: " + person.getName());
        System.out.println("城市: " + person.getAddress().getCity());
        for (Contact contact : person.getContacts()) {
            System.out.println("联系方式类型: " + contact.getType() + ", 号码: " + contact.getNumber());
        }
    }
}

使用Jackson库处理嵌套JSON

Jackson是Java中最流行的JSON处理库之一,首先添加依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

基本解析

import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonNestedJsonExample {
    public static void main(String[] args) throws Exception {
        String jsonStr = "{\"name\":\"张三\",\"age\":30,\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\"},\"contacts\":[{\"type\":\"手机\",\"number\":\"13812345678\"},{\"type\":\"邮箱\",\"number\":\"zhangsan@example.com\"}]}";
        ObjectMapper objectMapper = new ObjectMapper();
        Person person = objectMapper.readValue(jsonStr, Person.class);
        System.out.println("姓名: " + person.getName());
        System.out.println("城市: " + person.getAddress().getCity());
        for (Contact contact : person.getContacts()) {
            System.out.println("联系方式类型: " + contact.getType() + ", 号码: " + contact.getNumber());
        }
    }
}

处理复杂嵌套情况

对于更复杂的嵌套JSON，可以使用@JsonCreator和@JsonProperty注解：

public class ComplexNestedObject {
    private String id;
    private Map<String, NestedItem> items;
    @JsonCreator
    public ComplexNestedObject(
        @JsonProperty("id") String id,
        @JsonProperty("items") Map<String, NestedItem> items) {
        this.id = id;
        this.items = items;
    }
    // getters and setters
}
public class NestedItem {
    private String name;
    private List<SubItem> subItems;
    // constructor, getters and setters
}

处理动态嵌套JSON

有时我们无法预先定义所有可能的嵌套结构，这时可以使用Map和List的组合来处理：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Map;
import java.util.List;
public class DynamicJsonExample {
    public static void main(String[] args) throws Exception {
        String jsonStr = "{\"name\":\"张三\",\"metadata\":{\"age\":30,\"tags\":[\"developer\",\"java\"]}}";
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, Object> data = objectMapper.readValue(jsonStr, Map.class);
        System.out.println("姓名: " + data.get("name"));
        Map<String, Object> metadata = (Map<String, Object>) data.get("metadata");
        System.out.println("年龄: " + metadata.get("age"));
        List<String> tags = (List<String>) metadata.get("tags");
        System.out.println("标签: " + tags);
    }
}