java怎么获取json下的json

Java如何获取嵌套JSON中的JSON数据

在Java开发中，处理JSON数据是一项常见任务，尤其是当JSON结构存在嵌套时，如何准确获取内层JSON对象或数组是开发者需要的技能，本文将介绍几种主流方法，帮助你在Java中高效获取嵌套JSON中的JSON数据。

使用Gson库获取嵌套JSON

Gson是Google提供的开源JSON处理库，支持将JSON字符串转换为Java对象（反序列化）以及将Java对象转换为JSON字符串（序列化），对于嵌套JSON，可以通过定义对应的Java类层级结构来直接获取内层JSON对象。

添加依赖

在项目中添加Gson依赖（Maven示例）：

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

定义嵌套Java类

假设有以下嵌套JSON字符串：

{
  "name": "张三",
  "age": 25,
  "address": {
    "city": "北京",
    "district": "朝阳区",
    "street": "建国路88号"
  },
  "contacts": [
    {"type": "phone", "value": "13812345678"},
    {"type": "email", "value": "zhangsan@example.com"}
  ]
}

可以定义对应的Java类：

public class Person {
    private String name;
    private int age;
    private Address address;  // 内层JSON对象
    private List<Contact> contacts;  // 内层JSON数组
    // getters和setters
}
public class Address {
    private String city;
    private String district;
    private String street;
    // getters和setters
}
public class Contact {
    private String type;
    private String value;
    // getters和setters
}

解析并获取嵌套JSON

import com.google.gson.Gson;
public class GsonExample {
    public static void main(String[] args) {
        String jsonStr = "{\"name\":\"张三\",\"age\":25,\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\",\"street\":\"建国路88号\"},\"contacts\":[{\"type\":\"phone\",\"value\":\"13812345678\"},{\"type\":\"email\",\"value\":\"zhangsan@example.com\"}]}";
        Gson gson = new Gson();
        Person person = gson.fromJson(jsonStr, Person.class);
        // 获取内层address对象（JSON）
        Address address = person.getAddress();
        System.out.println("城市: " + address.getCity());  // 输出: 城市: 北京
        // 获取内层contacts数组中的JSON对象
        List<Contact> contacts = person.getContacts();
        Contact firstContact = contacts.get(0);
        System.out.println("联系方式: " + firstContact.getType() + " - " + firstContact.getValue());  // 输出: 联系方式: phone - 13812345678
    }
}

通过这种方式，Gson会自动将嵌套JSON映射到对应的Java对象，直接通过对象属性即可获取内层数据。

使用Jackson库获取嵌套JSON

Jackson是另一个流行的JSON处理库，功能强大且性能优越，尤其适合处理复杂的JSON结构，其使用方式与Gson类似，但API略有不同。

添加依赖

Maven依赖：

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

解析并获取嵌套JSON

同样以上面的嵌套JSON为例，使用Jackson解析：

import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
    public static void main(String[] args) throws Exception {
        String jsonStr = "{\"name\":\"张三\",\"age\":25,\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\",\"street\":\"建国路88号\"},\"contacts\":[{\"type\":\"phone\",\"value\":\"13812345678\"},{\"type\":\"email\",\"value\":\"zhangsan@example.com\"}]}";
        ObjectMapper objectMapper = new ObjectMapper();
        Person person = objectMapper.readValue(jsonStr, Person.class);
        // 获取内层address对象
        Address address = person.getAddress();
        System.out.println("区域: " + address.getDistrict());  // 输出: 区域: 朝阳区
        // 获取contacts数组
        List<Contact> contacts = person.getContacts();
        Contact secondContact = contacts.get(1);
        System.out.println("邮箱: " + secondContact.getValue());  // 输出: 邮箱: zhangsan@example.com
    }
}

Jackson还支持直接解析为JsonNode（树模型），无需提前定义Java类，适合处理动态或结构不固定的JSON：

import com.fasterxml.jackson.databind.JsonNode;
public class JacksonJsonNodeExample {
    public static void main(String[] args) throws Exception {
        String jsonStr = "{\"name\":\"张三\",\"address\":{\"city\":\"北京\"}}";
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode rootNode = objectMapper.readTree(jsonStr);
        // 获取内层address节点（JsonNode对象，即JSON）
        JsonNode addressNode = rootNode.get("address");
        System.out.println("address JSON: " + addressNode.toString());  // 输出: {"city":"北京"}
        // 从addressNode中获取具体字段
        String city = addressNode.get("city").asText();
        System.out.println("城市: " + city);  // 输出: 城市: 北京
    }
}

使用org.json库获取嵌套JSON

org.json是轻量级JSON处理库，适合简单场景，无需定义复杂的Java类。

添加依赖

Maven依赖：

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

解析并获取嵌套JSON

import org.json.JSONObject;
public class OrgJsonExample {
    public static void main(String[] args) {
        String jsonStr = "{\"name\":\"张三\",\"address\":{\"city\":\"北京\",\"street\":\"建国路\"}}";
        JSONObject jsonObject = new JSONObject(jsonStr);
        // 获取内层address对象（JSONObject）
        JSONObject addressObj = jsonObject.getJSONObject("address");
        System.out.println("街道: " + addressObj.getString("street"));  // 输出: 街道: 建国路
        // 如果内层是数组
        String jsonArrayStr = "{\"hobbies\":[\"篮球\",\"阅读\"]}";
        JSONObject json = new JSONObject(jsonArrayStr);
        // 获取数组并遍历
        for (Object hobby : json.getJSONArray("hobbies")) {
            System.out.println("爱好: " + hobby);  // 输出: 爱好: 篮球; 爱好: 阅读
        }
    }
}

总结与选择

方案	优点	缺点	适用场景
Gson	简单易用，自动映射嵌套对象	需提前定义Java类	结构固定、需要强类型的JSON解析
Jackson	性能高，支持树模型（JsonNode）	API相对复杂	复杂JSON、动态结构、高性能需求
org.json	轻量级，无需定义Java类	功能较弱，不支持复杂映射	简单JSON、快速处理