Course – LS (cat=JSON/Jackson)

Get started with Spring and Spring Boot, through the Learn Spring course:

>> CHECK OUT THE COURSE

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:

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

2.2. Gson

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

2.3. json-io

2.4. Genson

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:

On Baeldung:

Other Interesting Writeups:

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:

On Baeldung:

Other Interesting Writeups:

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:

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:

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:

7.2. Maven Dependencies

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

<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>jakarta.json</artifactId>
    <version>${provider.version}</version>
    <classifier>module<classifier> 
</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.

Course – LS (cat=JSON/Jackson)

Get started with Spring and Spring Boot, through the Learn Spring course:

>> CHECK OUT THE COURSE
res – Jackson (eBook) (cat=Jackson)
Comments are closed on this article!