Java JSON 反序列化标准 JSON 全解析

简介

在 Java 开发中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，广泛应用于前后端数据传输、配置文件等场景。JSON 反序列化是将 JSON 字符串转换为 Java 对象的过程，这在处理外部数据时非常常见。本文将详细介绍 Java 中 JSON 反序列化标准 JSON 的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用该技术。

目录

1. 基础概念
2. 使用方法
   • 使用 Gson 进行反序列化
   • 使用 Jackson 进行反序列化
3. 常见实践
   • 反序列化嵌套 JSON
   • 处理数组 JSON
4. 最佳实践
   • 处理缺失字段
   • 自定义反序列化器
5. 小结
6. 参考资料

基础概念

JSON 简介

JSON 是一种基于文本的数据交换格式，采用键值对的形式存储数据，具有简洁、易读的特点。例如：

{
    "name": "John",
    "age": 30,
    "isStudent": false
}

反序列化的定义

反序列化是将 JSON 字符串转换为 Java 对象的过程。在 Java 中，我们通常使用第三方库来完成这个任务，常见的库有 Gson 和 Jackson。

使用方法

使用 Gson 进行反序列化

Gson 是 Google 提供的一个用于处理 JSON 的 Java 库，使用简单方便。

步骤

1. 添加 Gson 依赖

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

1. 定义 Java 类

class Person {
    String name;
    int age;
    boolean isStudent;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isStudent() {
        return isStudent;
    }

    public void setStudent(boolean student) {
        isStudent = student;
    }
}

1. 进行反序列化

import com.google.gson.Gson;

public class GsonExample {
    public static void main(String[] args) {
        String json = "{\"name\": \"John\", \"age\": 30, \"isStudent\": false}";
        Gson gson = new Gson();
        Person person = gson.fromJson(json, Person.class);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Is Student: " + person.isStudent());
    }
}

使用 Jackson 进行反序列化

Jackson 是一个功能强大的 JSON 处理库，在 Spring 等框架中广泛使用。

步骤

1. 添加 Jackson 依赖

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

1. 定义 Java 类（同上）

2. 进行反序列化

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) throws Exception {
        String json = "{\"name\": \"John\", \"age\": 30, \"isStudent\": false}";
        ObjectMapper objectMapper = new ObjectMapper();
        Person person = objectMapper.readValue(json, Person.class);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Is Student: " + person.isStudent());
    }
}

常见实践

反序列化嵌套 JSON

当 JSON 数据存在嵌套结构时，我们需要定义相应的嵌套 Java 类。

JSON 示例

{
    "name": "John",
    "age": 30,
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

Java 类定义

class Address {
    String street;
    String city;

    // Getters and Setters
    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

class PersonWithAddress {
    String name;
    int age;
    Address address;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}

反序列化代码（以 Gson 为例）

import com.google.gson.Gson;

public class NestedJsonExample {
    public static void main(String[] args) {
        String json = "{\"name\": \"John\", \"age\": 30, \"address\": {\"street\": \"123 Main St\", \"city\": \"New York\"}}";
        Gson gson = new Gson();
        PersonWithAddress person = gson.fromJson(json, PersonWithAddress.class);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
        System.out.println("Street: " + person.getAddress().getStreet());
        System.out.println("City: " + person.getAddress().getCity());
    }
}

处理数组 JSON

当 JSON 数据是数组形式时，我们可以直接将其反序列化为 Java 数组或列表。

JSON 示例

[
    {
        "name": "John",
        "age": 30
    },
    {
        "name": "Jane",
        "age": 25
    }
]

反序列化代码（以 Jackson 为例）

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

public class ArrayJsonExample {
    public static void main(String[] args) throws Exception {
        String json = "[{\"name\": \"John\", \"age\": 30}, {\"name\": \"Jane\", \"age\": 25}]";
        ObjectMapper objectMapper = new ObjectMapper();
        List<Person> personList = objectMapper.readValue(json, objectMapper.getTypeFactory().constructCollectionType(List.class, Person.class));
        for (Person person : personList) {
            System.out.println("Name: " + person.getName());
            System.out.println("Age: " + person.getAge());
        }
    }
}

最佳实践

处理缺失字段

在实际应用中，JSON 数据可能会缺少某些字段。我们可以通过在 Java 类中设置默认值或使用注解来处理这种情况。

使用 Gson 处理缺失字段

import com.google.gson.Gson;

class PersonWithDefault {
    String name = "Unknown";
    int age = 0;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class MissingFieldExample {
    public static void main(String[] args) {
        String json = "{\"name\": \"John\"}";
        Gson gson = new Gson();
        PersonWithDefault person = gson.fromJson(json, PersonWithDefault.class);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

自定义反序列化器

当默认的反序列化规则无法满足需求时，我们可以自定义反序列化器。

自定义 Jackson 反序列化器示例

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;

class CustomPersonDeserializer extends JsonDeserializer<Person> {
    @Override
    public Person deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        ObjectMapper mapper = (ObjectMapper) p.getCodec();
        Person person = mapper.readValue(p, Person.class);
        if (person.getAge() < 0) {
            person.setAge(0);
        }
        return person;
    }
}

使用自定义反序列化器

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;

public class CustomDeserializerExample {
    public static void main(String[] args) throws Exception {
        String json = "{\"name\": \"John\", \"age\": -10}";
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addDeserializer(Person.class, new CustomPersonDeserializer());
        objectMapper.registerModule(module);
        Person person = objectMapper.readValue(json, Person.class);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

小结

本文详细介绍了 Java 中 JSON 反序列化标准 JSON 的相关知识，包括基础概念、使用 Gson 和 Jackson 进行反序列化的方法、常见的嵌套 JSON 和数组 JSON 处理实践，以及处理缺失字段和自定义反序列化器的最佳实践。通过掌握这些内容，读者可以在实际开发中更加高效地处理 JSON 数据。

参考资料

1. 《Effective Java》（第三版）