JAVA：常见 JSON 库的技术详解

1、简述

在现代应用开发中，JSON（JavaScript Object Notation）已成为数据交换的标准格式。Java 提供了多种方式将对象转换为 JSON 或从 JSON 转换为对象，常见的库包括 Jackson、Gson 和 org.json。本文将介绍几种常用的 JSON 处理方式，并通过简单示例展示其应用。

在这里插入图片描述

2、什么是 JSON？

JSON 是一种轻量级的数据交换格式，使用键值对来表示数据。它易于人阅读和编写，同时也易于机器解析和生成。常见的 JSON 数据结构如下：

{
  "name": "John",
  "age": 30,
  "address": {
    "city": "New York",
    "zip": "10001"
  }
}

3、常见的JSON 库

3.1 使用 Jackson 进行 JSON 转换

Jackson 是 Java 中最流行的 JSON 解析库之一。它提供了强大的数据绑定功能，支持将 Java 对象与 JSON 之间进行转换。要使用 Jackson，请在 pom.xml 中添加以下依赖：

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

示例代码：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {

    public static void main(String[] args) throws JsonProcessingException {
        // 创建 Person 对象
        Person person = new Person("John", 30, new Address("New York", "10001"));

        // 序列化：将对象转换为 JSON
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonString = objectMapper.writeValueAsString(person);
        System.out.println("Serialized JSON: " + jsonString);

        // 反序列化：将 JSON 转换为对象
        Person deserializedPerson = objectMapper.readValue(jsonString, Person.class);
        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

class Person {
    private String name;
    private int age;
    private Address address;

    // 构造函数、getters、setters、toString 省略
}

class Address {
    private String city;
    private String zip;

    // 构造函数、getters、setters、toString 省略
}

3.2 使用 Gson 进行 JSON 转换

Gson 是 Google 提供的轻量级 JSON 处理库，它可以将 Java 对象与 JSON 字符串相互转换。要使用 Gson，请在 pom.xml 中添加以下依赖：

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

示例代码：

import com.google.gson.Gson;

public class GsonExample {

    public static void main(String[] args) {
        // 创建 Person 对象
        Person person = new Person("John", 30, new Address("New York", "10001"));

        // 序列化：将对象转换为 JSON
        Gson gson = new Gson();
        String jsonString = gson.toJson(person);
        System.out.println("Serialized JSON: " + jsonString);

        // 反序列化：将 JSON 转换为对象
        Person deserializedPerson = gson.fromJson(jsonString, Person.class);
        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

class Person {
    private String name;
    private int age;
    private Address address;

    // 构造函数、getters、setters、toString 省略
}

class Address {
    private String city;
    private String zip;

    // 构造函数、getters、setters、toString 省略
}

3.3 使用 org.json 进行 JSON 处理

org.json 是 Java 原生的 JSON 处理库，适用于处理简单的 JSON 数据。要使用 org.json，请在 pom.xml 中添加以下依赖：

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

示例代码：

import org.json.JSONObject;

public class OrgJsonExample {

    public static void main(String[] args) {
        // 创建 Person 对象的 JSON 字符串
        String jsonString = "{ \"name\": \"John\", \"age\": 30, \"address\": { \"city\": \"New York\", \"zip\": \"10001\" } }";

        // 解析 JSON 字符串
        JSONObject jsonObject = new JSONObject(jsonString);
        System.out.println("Name: " + jsonObject.getString("name"));
        System.out.println("Age: " + jsonObject.getInt("age"));
        JSONObject address = jsonObject.getJSONObject("address");
        System.out.println("City: " + address.getString("city"));
        System.out.println("Zip: " + address.getString("zip"));

        // 创建 JSON 对象
        JSONObject newPerson = new JSONObject();
        newPerson.put("name", "Jane");
        newPerson.put("age", 28);
        JSONObject newAddress = new JSONObject();
        newAddress.put("city", "Los Angeles");
        newAddress.put("zip", "90001");
        newPerson.put("address", newAddress);

        System.out.println("Created JSON: " + newPerson.toString());
    }
}

3.4 使用 JSON-B 进行 JSON 转换

JSON-B 是 Jakarta EE 提供的标准 JSON 绑定库，专为 Java 开发的 JSON 序列化和反序列化标准。要使用 JSON-B，请在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>javax.json.bind</groupId>
    <artifactId>javax.json.bind-api</artifactId>
    <version>1.0</version>
</dependency>

示例代码：

import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;

public class JsonBExample {

    public static void main(String[] args) {
        // 创建 Person 对象
        Person person = new Person("John", 30, new Address("New York", "10001"));

        // 序列化：将对象转换为 JSON
        Jsonb jsonb = JsonbBuilder.create();
        String jsonString = jsonb.toJson(person);
        System.out.println("Serialized JSON: " + jsonString);

        // 反序列化：将 JSON 转换为对象
        Person deserializedPerson = jsonb.fromJson(jsonString, Person.class);
        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

class Person {
    private String name;
    private int age;
    private Address address;

    // 构造函数、getters、setters、toString 省略
}

class Address {
    private String city;
    private String zip;

    // 构造函数、getters、setters、toString 省略
}

3.5 Moshi

Moshi 是 Square 公司提供的一款轻量级 JSON 库，专注于简单性和性能。它与 Gson 类似，但它在设计上更加严谨，并且更容易扩展。

import com.squareup.moshi.JsonAdapter;
import com.squareup.moshi.Moshi;

public class MoshiExample {
    public static void main(String[] args) throws Exception {
        // 创建 Moshi 实例
        Moshi moshi = new Moshi.Builder().build();
        JsonAdapter<Person> jsonAdapter = moshi.adapter(Person.class);

        // 序列化
        Person person = new Person("John", 30, new Address("New York", "10001"));
        String jsonString = jsonAdapter.toJson(person);
        System.out.println("Serialized JSON: " + jsonString);

        // 反序列化
        Person deserializedPerson = jsonAdapter.fromJson(jsonString);
        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

Moshi 强调简洁，同时支持 Kotlin 更加无缝的集成。

3.6 Flexjson

Flexjson 是一个快速和轻量的 JSON 库，专注于 Java 对象到 JSON 的序列化以及 JSON 到 Java 对象的反序列化。它允许你对序列化的字段进行高度控制，适合需要进行部分序列化或者处理复杂嵌套数据结构的场景。

import flexjson.JSONDeserializer;
import flexjson.JSONSerializer;

public class FlexjsonExample {
    public static void main(String[] args) {
        // 创建 Person 对象
        Person person = new Person("John", 30, new Address("New York", "10001"));

        // 序列化
        JSONSerializer serializer = new JSONSerializer();
        String jsonString = serializer.serialize(person);
        System.out.println("Serialized JSON: " + jsonString);

        // 反序列化
        JSONDeserializer<Person> deserializer = new JSONDeserializer<>();
        Person deserializedPerson = deserializer.deserialize(jsonString, Person.class);
        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

Flexjson 在复杂序列化需求时非常有用，比如需要不同的视图或包含/排除字段的序列化操作。

3.7 Json-simple

Json-simple 是一个简单、轻量级的 JSON 库，适合处理基本的 JSON 操作。虽然它的功能较为基础，但它的 API 非常简单，适合处理小型或快速开发场景。

import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;

public class JsonSimpleExample {
    public static void main(String[] args) throws Exception {
        // 创建 JSON 对象
        JSONObject person = new JSONObject();
        person.put("name", "John");
        person.put("age", 30);

        JSONObject address = new JSONObject();
        address.put("city", "New York");
        address.put("zip", "10001");
        person.put("address", address);

        // 序列化
        System.out.println("Serialized JSON: " + person.toJSONString());

        // 反序列化
        JSONParser parser = new JSONParser();
        JSONObject deserializedPerson = (JSONObject) parser.parse(person.toJSONString());
        System.out.println("Deserialized JSON: " + deserializedPerson);
    }
}

Json-simple 适合做简单的 JSON 解析，API 设计简洁但功能有限，适合小规模应用。

3.8 Jsoniter (Json-iterator)

Jsoniter 是一个性能优异的 JSON 库，其解析和序列化性能比 Jackson 还要快。它的优势在于处理大规模数据时速度非常快，适合高性能需求的场景。

import com.jsoniter.JsonIterator;
import com.jsoniter.output.JsonStream;

public class JsoniterExample {
    public static void main(String[] args) {
        // 序列化
        Person person = new Person("John", 30, new Address("New York", "10001"));
        String jsonString = JsonStream.serialize(person);
        System.out.println("Serialized JSON: " + jsonString);

        // 反序列化
        Person deserializedPerson = JsonIterator.deserialize(jsonString, Person.class);
        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

Jsoniter 非常注重性能，适用于对速度和内存使用要求非常高的场景。

3.9 Jettison

Jettison 是一个基于 StAX 的库，用于将 XML 转换为 JSON 或将 JSON 转换为 XML。它主要用于与 JSON 和 XML 之间相互转换的数据交换场景。

import org.codehaus.jettison.json.JSONObject;

public class JettisonExample {
    public static void main(String[] args) throws Exception {
        // 创建 JSON 对象
        JSONObject person = new JSONObject();
        person.put("name", "John");
        person.put("age", 30);
        
        JSONObject address = new JSONObject();
        address.put("city", "New York");
        address.put("zip", "10001");
        person.put("address", address);

        // 序列化输出
        System.out.println("Serialized JSON: " + person.toString());
    }
}

Jettison 主要用于解决与 XML 兼容的问题，适合需要同时处理这两种格式的数据应用。

3.10 Boon

Boon 是一个快速的 JSON 库，专注于速度和易用性。它支持简单的 API 来处理 JSON 数据，并且以其高速性能为特点。

import org.boon.Boon;

public class BoonExample {
    public static void main(String[] args) {
        // 序列化
        Person person = new Person("John", 30, new Address("New York", "10001"));
        String jsonString = Boon.toJson(person);
        System.out.println("Serialized JSON: " + jsonString);

        // 反序列化
        Person deserializedPerson = Boon.fromJson(jsonString, Person.class);
        System.out.println("Deserialized Person: " + deserializedPerson);
    }
}

Boon 提供了非常快速的 JSON 处理能力，适合需要高性能和易用性的场景。

4、总结

Java 提供了多种方式来处理 JSON 数据，每种库都有其独特的优势，除了常见的 Jackson 和 Gson，还有一些轻量级的 JSON 库如 Moshi、Flexjson 和 Json-simple，适合特定的场景。例如，Moshi 在与 Kotlin 集成时非常流畅，Jsoniter 在性能上非常出色，而 Flexjson 则在需要灵活控制序列化时表现优异。根据项目的需求选择合适的 JSON 处理库，可以帮助更高效地进行开发。