Java JSON指南

1. Overview

Working with JSON data in Java can be easy, but – like most anything in Java – there are a lot of options and libraries we can chose from.

This guide should make that choice easier and should give you a solid understanding of the ecosystem right now. We’ll discuss the most common JSON processing libraries in Java:

• Jackson
• Gson
• json-io
• Genson

We’re following a simple structure for each library – first some useful resources to get started (both here on Baeldung as well as external). Then we’re going to go over a basic code example, just to see how working with the library actually looks like.

2. Popularity and Basic Stats

First, let’s start with some statistics as a proxy for the popularity of each library:

2.1. Jackson

• Maven Usage: data-bind (2362), core (1377)
• Github Stars: 1457
• Github Forks: 585

2.2. Gson

• Maven Usage: 1588
• Github Stars: 2079
• Github Forks: 471

2.3. json-io

• Maven Usage: 11
• Github Stars: 129
• Github Forks: 40

2.4. Genson

• Maven Usage: 8
• Github Stars: 67
• Github Forks: 15

2.5. JSON-P

• Github Stars: 119
• Github Forks: 54

3. Jackson

Next, let’s have a look at the most popular of these – Jackson. Jackson is a multi-purpose Java library for processing JSON data.

3.1. Useful Resources

Here are some official resources for the library:

• Official Jackson wiki
• Jackson on Github

On Baeldung:

• Jackson tutorial
• Jackson Date
• Jackson JSON Views
• A Guide to Jackson Annotations
• Jackson Exceptions – Problems and Solutions
• Jackson – Decide What Fields Get Serialized/Deserialized
• Jackson – Bidirectional Relationships
• Jackson – Custom Serializer
• Jackson – Custom Deserializer

Other Interesting Writeups:

• Jackson JSON Processing API in Java Example Tutorial
• Jackson – ObjectMapper
• Jackson 2 – Convert Java Object to / from JSON

3.2. Maven Dependency

To use the library – here’s the Maven dependency to add into your pom.xml:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.version}</version>
</dependency>

Note that the latest version of Jackson right now is 2.13.

3.3. Simple Example with Jackson

Now, let’s see how to use Jackson in a simple example:

@Test
public void whenSerializeAndDeserializeUsingJackson_thenCorrect() 
  throws IOException{
    Foo foo = new Foo(1,"first");
    ObjectMapper mapper = new ObjectMapper();

    String jsonStr = mapper.writeValueAsString(foo);
    Foo result = mapper.readValue(jsonStr, Foo.class);
    assertEquals(foo.getId(),result.getId());
}

Note that:

• ObjectMapper.writeValueAsString() is used to serialize Object to JSON string.
• ObjectMapper.readValue() is used to deserialize JSON string to Java Object.
• Sample JSON output:

{
    "id":1,
    "name":"first"
}

4. Gson

Gson is the next Java JSON library that we’re going to be looking at.

4.1. Useful Resources

Here are some official resources for the library:

• Gson on Github
• Gson User Guide

On Baeldung:

• Gson serialization cookbook
• Gson deserialization cookbook

Other Interesting Writeups:

• Gson Exclusion Strategy
• Gson Custom Serializer/Deserializer
• Java Gson + JSON Tutorial with Examples

4.2. Maven Dependency

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>${gson.version}</version>
</dependency>

Note that the latest version of Gson right now is 2.8.8.

4.3. Simple Example with Gson

Here is a simple example clarify how to use Gson to serialize/desrialize JSON:

@Test
public void whenSerializeAndDeserializeUsingGson_thenCorrect(){
    Gson gson = new Gson();
    Foo foo = new Foo(1,"first");

    String jsonStr = gson.toJson(foo);
    Foo result = gson.fromJson(jsonStr, Foo.class);
    assertEquals(foo.getId(),result.getId());
}

Note that:

• Gson.toJson() is used to serialize Object to JSON
• Gson.fromJson() is used to desrialize JSON to Java Object

5. Json-io

Json-io is a simple Java library to serialize/deserialize JSON.

5.1. Useful Resources

Here are some official resources for the library:

• json-io on Google Code
• json-io on Github

5.2. Maven Dependency

<dependency>
    <groupId>com.cedarsoftware</groupId>
    <artifactId>json-io</artifactId>
    <version>${json-io.version}</version>
</dependency>

Note that the latest version of json-io right now is 4.13.0.

5.3. Simple Example with json-io

Now, let’s take a look at a simple example of using json-io:

@Test
public void whenSerializeAndDeserializeUsingJsonio_thenCorrect(){
    Foo foo = new Foo(1,"first");

    String jsonStr = JsonWriter.objectToJson(foo);
    Foo result = (Foo) JsonReader.jsonToJava(jsonStr);
    assertEquals(foo.getId(),result.getId());
}

Note that:

• JsonWriter.objectToJson() is used to serialize Object to JSON.
• JsonReader.jsonToJava() is used to deserialize Json to Java Object.
• Sample JSON output:

{
    "@type":"org.baeldung.Foo",
    "id":1,
    "name":"first"
}

6. Genson

Genson is a Java and Scala to JSON conversion library, providing full databinding and streaming.

6.1. Useful Resources

Here are some official resources for the library:

• Genson Official website
• Genson on Github
• Genson User Guide
• Genson JSON format for byte arrays

6.2. Maven Dependency

<dependency>
    <groupId>com.owlike</groupId>
    <artifactId>genson</artifactId>
    <version>${genson.version}</version>
</dependency>

Note that the latest version of Genson right now is 1.6.

6.3. Simple Example with Genson

Here’s a simple example of working with the library:

@Test
public void whenSerializeAndDeserializeUsingGenson_thenCorrect(){
    Genson genson = new Genson();
    Foo foo = new Foo(1,"first");

    String jsonStr = genson.serialize(foo);
    Foo result = genson.deserialize(jsonStr, Foo.class);
    assertEquals(foo.getId(),result.getId());
}

Note that:

• Genson.serialize() is used to serialize Object to JSON
• Genson.desrialize() is used to deserialize JSON to Java Object

7. JSON-P

JSON-P is a Java API for parsing, building, transforming, and querying JSON messages. Java Specification Request (JSR) 353 proposed the API. JSR 353 aims to develop a Java API to process JSON. Most of the popular libraries, like Jackson, Gson, etc., don’t implement the specification directly.

7.1. Useful Resources

Here are some official resources for the library:

• JSON-P Official website
• JSON-P on GitHub

7.2. Maven Dependencies

<dependency>
    <groupId>jakarta.json</groupId>
    <artifactId>jakarta.json-api</artifactId>
    <version>${jsonp.version}</version>
</dependency>

Note that we need the API module and the default provider dependencies. The latest version is 2.1.1 and 2.0.1, respectively.

7.3. Simple Example With JSON-P

Let’s take a look at the simple use case of JSON-P:

@Test
public void whenTransformingAndParsingUsingJsonp_thenCorrect() {
    Foo foo = new Foo(1, "First");
    JsonObject json = Json.createObjectBuilder()
      .add("id", foo.getId())
      .add("name", foo.getName())
      .build();
    String result = json.toString();
        
    JsonParser parser = Json.createParser(new StringReader(result));
    while (parser.hasNext()) {
        Event event = parser.next();
        switch (event) {
            case VALUE_STRING:
                String value = parser.getString();
                assertEquals(foo.getName(), value);
                break;
        }
    }
    parser.close();
}

Note that:

• Json.createObjectBuilder() is used to transform an object to JSON.
• Json.createParser() is used to parse the JSON message.
• JSON-P API is low-level compared to other JSON processing libraries in Java.

8. Conclusion

In this quick overview article, we learned about the most common JSON processing libraries in Java.