Jackson - Learn Java by Examples

How do I use JSON libraries like Jackson or Gson in modern Java?

By I Wayan Saryada in HttpClient Last modified: January 3, 2026 0 Comment

In modern Java, using JSON libraries like Jackson or Gson is the standard way to handle data exchange, as the Java Standard Library does not include a built-in JSON parser.

With Java 25, you can take advantage of Records for clean data models and Text Blocks for readable JSON strings in your code.

1. Using Jackson (Industry Standard)

Jackson is highly recommended for modern applications, especially within the Spring and Jakarta EE ecosystems.

Maven Dependency:

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

Code Example:

import com.fasterxml.jackson.databind.ObjectMapper;

// 1. Define a Record (Modern Java way)
public record User(Long id, String name) {}

public class JacksonDemo {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        // Serialization (Object to JSON)
        User user = new User(1L, "Duke");
        String json = mapper.writeValueAsString(user);
        System.out.println("JSON: " + json);

        // Deserialization (JSON to Object)
        String inputJson = """
                {
                    "id": 2,
                    "name": "Java"
                }
                """;
        User decodedUser = mapper.readValue(inputJson, User.class);
        System.out.println("User Name: " + decodedUser.name());
    }
}

2. Using Gson (Google’s Library)

Gson is known for its simplicity and ease of use for smaller projects or quick utilities.

Maven Dependency:

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

Code Example:

import com.google.code.gson.Gson;
import com.google.code.gson.GsonBuilder;

public class GsonDemo {
    public static void main(String[] args) {
        // Use GsonBuilder for custom configurations like Pretty Printing
        Gson gson = new GsonBuilder().setPrettyPrinting().create();

        // Serialization
        User user = new User(10L, "Modern Java");
        String json = gson.toJson(user);
        System.out.println(json);

        // Deserialization
        User fromJson = gson.fromJson(json, User.class);
        System.out.println("ID from JSON: " + fromJson.id());
    }
}

Key Comparisons & Tips

Records Support: Both Jackson (2.12+) and Gson (2.10+) support Java Records natively. This is the preferred way to create POJOs for data mapping.
Immutability: Since Records are immutable, these libraries use reflection or canonical constructors to populate the data, which is much safer than traditional setter-based beans.
Performance: Jackson is generally faster and offers more features for complex mapping (like @JsonProperty for renaming fields).
Integration: If you are using Spring Boot, Jackson is already included and configured for you.

Integrating with HttpClient

When fetching data from an API using the java.net.http.HttpClient, you typically receive a String which you then pass to these libraries:

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
User user = mapper.readValue(response.body(), User.class);

For more advanced use cases, you can even write a custom BodyHandler that uses Jackson to parse the stream directly, saving memory on large JSON payloads.

How do I Parse JSON Responses from Java 11 HttpClient Easily?

By I Wayan Saryada in HttpClient, Java 11 Last modified: May 25, 2025 0 Comment

To parse JSON responses easily using Java 11’s HttpClient, you can use libraries like Jackson or Gson that help in converting a JSON string to Java objects (POJOs) without hassle.

Here’s a step-by-step guide:

Step 1: Create a Java 11 `HttpClient` request

Use Java’s HttpClient to make an HTTP request and get the JSON response as a string.
Use HttpRequest or HttpResponse as part of the Java 11 HttpClient API.

Step 2: Add Jackson or Gson to Parse JSON

Jackson: Add the dependency to your pom.xml (for Maven):

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

Gson: Add this dependency:

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

Step 3: Example Using Jackson

package org.kodejava.net.http;

import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class HttpClientJacksonExample {

    public static void main(String[] args) throws Exception {
        // 1. Create an HttpClient
        HttpClient client = HttpClient.newHttpClient();

        // 2. Create an HttpRequest
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI("https://jsonplaceholder.typicode.com/posts/1")) // Example URL
                .GET()
                .build();

        // 3. Send the HttpRequest and get an HttpResponse
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        // 4. Parse JSON String Response to a Java Object using Jackson
        ObjectMapper mapper = new ObjectMapper();
        Post post = mapper.readValue(response.body(), Post.class);

        // 5. Use the parsed object
        System.out.println("Post Title: " + post.getTitle());
    }

    // Sample POJO to match the JSON structure
    public static class Post {
        private int userId;
        private int id;
        private String title;
        private String body;

        // Getters and Setters
        public int getUserId() {
            return userId;
        }

        public void setUserId(int userId) {
            this.userId = userId;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        public String getBody() {
            return body;
        }

        public void setBody(String body) {
            this.body = body;
        }
    }
}

Step 4: Example Using Gson

package org.kodejava.net.http;

import com.google.gson.Gson;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class HttpClientGsonExample {

    public static void main(String[] args) throws Exception {
        // 1. Create HttpClient
        HttpClient client = HttpClient.newHttpClient();

        // 2. Create HttpRequest
        HttpRequest request = HttpRequest.newBuilder()
                .uri(new URI("https://jsonplaceholder.typicode.com/posts/1")) // Example URL
                .GET()
                .build();

        // 3. Send HttpRequest and get HttpResponse
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        // 4. Parse JSON String response to Java Object using Gson
        Gson gson = new Gson();
        Post post = gson.fromJson(response.body(), Post.class);

        // 5. Use the parsed object
        System.out.println("Post Title: " + post.getTitle());
    }

    // Sample POJO class to match the JSON structure
    public static class Post {
        private int userId;
        private int id;
        private String title;
        private String body;

        // Getters and Setters
        public int getUserId() {
            return userId;
        }

        public void setUserId(int userId) {
            this.userId = userId;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        public String getBody() {
            return body;
        }

        public void setBody(String body) {
            this.body = body;
        }
    }
}

Key Points:

Serialization and Deserialization: POJO structure must match your JSON’s keys.
Why Jackson or Gson?
They are robust and simplify working with JSON (and even converting nested structures).

How do I convert Map to JSON and vice versa using Jackson?

By I Wayan Saryada in Jackson Last modified: June 1, 2024 0 Comment

In the following code snippet we will convert java.util.Map object into JSON string and convert back the JSON string into Java Map object. In this example we will be using the Jackson library.

To convert from Map to JSON string the steps are:

Create a map of string keys and values.
Create an instance of Jackson ObjectMapper.
To convert map to JSON string we call the writeValueAsString() method and pass the map as argument.

// Converting Map to JSON
String json = null;
try {
    json = mapper.writeValueAsString(colours);
    System.out.println("json = " + json);
} catch (JsonProcessingException e) {
    e.printStackTrace();
}

Now, to convert from JSON string back to map we can do it in the following steps:

Create a JSON string, in this case we use the one converted from the colours map.
Create an instance of Jackson ObjectMapper.
Call the mapper’s readValue() method with JSON string and an empty instance of TypeReference as arguments.

// Converting JSON to MAP
try {
    Map<String, String> newColours =
            mapper.readValue(json, new TypeReference<>() {});
} catch (JsonProcessingException e) {
    e.printStackTrace();
}

And here is the complete code snippet.

package org.kodejava.jackson;

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

import java.util.HashMap;
import java.util.Map;

public class MapToJson {
    public static void main(String[] args) {
        Map<String, String> colours = new HashMap<>();
        colours.put("BLACK", "#000000");
        colours.put("RED", "#FF0000");
        colours.put("GREEN", "#008000");
        colours.put("BLUE", "#0000FF");
        colours.put("YELLOW", "#FFFF00");
        colours.put("WHITE", "#FFFFFF");

        ObjectMapper mapper = new ObjectMapper();

        // Converting Map to JSON
        String json = null;
        try {
            json = mapper.writeValueAsString(colours);
            System.out.println("json = " + json);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        // Converting JSON to MAP
        try {
            Map<String, String> newColours =
                    mapper.readValue(json, new TypeReference<>() {});
            System.out.println("Map:");
            for (var entry : newColours.entrySet()) {
                System.out.println(entry.getKey() + " = " + entry.getValue());
            }
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

Running the code snippet above will print the following output:

json = {"RED":"#FF0000","WHITE":"#FFFFFF","BLUE":"#0000FF","BLACK":"#000000","YELLOW":"#FFFF00","GREEN":"#008000"}
Map:
RED = #FF0000
WHITE = #FFFFFF
BLUE = #0000FF
BLACK = #000000
YELLOW = #FFFF00
GREEN = #008000

Maven Dependencies

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

Jackson for Java. Is it more than JSON?

By Leon Collier in General, Jackson Last modified: June 1, 2024 0 Comment

JSON has been a popular data-interchange format for quite some time now. It is not just simple, but also lightweight, and most programmers find it easy to use. However, JSON can be cumbersome to work with when you need more complex functionality.

That’s where Jackson for Java comes in. Jackson is a powerful JSON library that provides a wide range of features that make working with JSON much easier. In this blog post, we will discuss what Jackson for Java is, how it differs from regular JSON, and how you can use it in your own projects. We will also take a look at the pros and cons of using Jackson for Java so that you can decide if it is the right library for you.

What is Jackson for Java, and what are its Features?

Jackson is a Java library that provides a number of features that make working with JSON much easier. Some of the most notable features of Jackson for Java include:

The ability to annotate fields so that they are mapped to specific JSON keys: With Jackson, you can annotate fields in your Java objects so that they are mapped to specific keys in the JSON document. This makes it much easier to work with complex JSON documents. For example, if you have a field in your Java object that is mapped to a “name” key in the JSON document, you can access that field using the @JsonProperty("name") annotation.
Support for POJOs (Plain Old Java Objects) and JAXB beans (Java Architecture for XML Binding): Jackson supports both POJOs and JAXB beans. This means that you can serialize and deserialize objects without writing any boilerplate code.
A wide range of modules that provide additional functionality: Jackson comes with a number of modules that provide additional functionality. These modules include support for XML, YAML, and CSV formats.

In addition to these features, Jackson also has excellent performance thanks to its use of streaming data processing. This means that it can handle large amounts of data with ease.

JSON vs. Jackson for Java – what’s the difference?

The main difference between JSON and Jackson for Java is that Jackson is a library that provides additional functionality on top of JSON. This includes features such as the ability to annotate fields, support for POJOs and JAXB beans, and the ability to serialize and deserialize objects without writing any boilerplate code.

So, if you need additional functionality beyond what JSON provides, then Jackson is the library for you. However, if you only need the basic functionality that JSON provides, then JSON is a better choice.

How to use Jackson for Java in your Project?

If you want to use Jackson for Java in your project, the first step is to add the library to your project dependencies.

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

The easiest way to do this is using a dependency management tool such as Maven or Gradle. Once you have added the Jackson library to your project, you can start using it in your code. For example, if you have a field in your Java object that is mapped to a “name” key in the JSON document, you can access that field using the @JsonProperty("name") annotation. Here is an example of how you can convert List object to JSON. Here, we’ll be using the ObjectMapper.writeValueAsString() method.

package net.javaguides.jackson;

import java.util.ArrayList;
import java.util.List;

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

/**
* Using Jackson API for list serialization and deserialization
* @author ramesh fadatare
*
*/
public class JacksonListToJson {
    public static void main(String[] args) throws JsonProcessingException {

        // Create ObjectMapper object.
        ObjectMapper mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT);

        List < String > progLangs = new ArrayList < > ();
        progLangs.add("C");
        progLangs.add("C++");
        progLangs.add("Java");
        progLangs.add("Java EE");
        progLangs.add("Python");
        progLangs.add("Scala");
        progLangs.add("JavaScript");
        // Serialize Object to JSON.
        String json = mapper.writeValueAsString(progLangs);

        // Print json
        System.out.println(json);
    }
}

You can also use Jackson to serialize and deserialize objects without writing any boilerplate code. This is because Jackson automatically generates the necessary code for you. To do this, you simply need to add the @JsonSerialize and @JsonDeserialize annotations to your Java objects.

If you have some experience on Jackson for Java, you may want to include it in your resume. Now, a resume for a programmer should list programming languages, software, and tools the individual is proficient in. Additionally, project experience and technical skills should be highlighted. A résumé is essentially your career booster so you will need to ensure that it also showcases all your skills and experience. Take time to include every essential detail.

Pros and Cons of Using Jackson for Java

Jackson is a very powerful library that can make working with JSON much easier. There are pros and cons to using Jackson for Java. The main pro is that it’s a very fast and lightweight library, which makes it ideal for large-scale projects. It can also serialize and deserialize Java objects quickly.

However, one potential con is that it can be difficult to reverse certain operations performed by the library, such as converting back from JSON to Java. For example, if you have a Java object with a list of Cat objects, and you want to convert it back to JSON, reversing the process might not be as straightforward as you’d like. In cases like this, you may need to use a different library or write your own code to handle the conversion.

Another potential downside of using Jackson is that because it’s so popular, there may be less flexibility in how you use it. For example, if you want to use Jackson for XML parsing, you may need to use a third-party library such as JAXB.

Overall, Jackson is a very powerful library that can make working with JSON much easier. It has a few potential downsides, but its pros far outweigh its cons.

Comparison of Other Popular JSON Libraries

There are many different JSON libraries available for Java. Some of the most popular include Gson, org.json, and FastJSON. Gson is a library that can be used for converting between Java objects and JSON documents. It can also be used for serializing and deserializing objects. Gson has excellent performance thanks to its use of streaming data processing.

Org.json is a library that provides JSON parsing and generation in Java. It’s simple and easy to use, but it doesn’t provide as much functionality as some other libraries on this list. Here is an example of how to parse JSON string in Java with org.json library.

import org.json.*;

String jsonString = ... ; //assign your JSON String here
JSONObject obj = new JSONObject(jsonString);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts"); // notice that `"posts": [...]`
for (int i = 0; i < arr.length(); i++) {
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

See more examples on this page. FastJSON is a high-performance JSON library for Java. It’s simple to use and provides a wide range of features.

Wrapping Up

Overall, Jackson is the best choice for working with JSON in Java, thanks to its excellent performance and wide range of features. However, there are other great options available, so be sure to choose the library that’s right for your project.

How do I convert CSV to JSON string using Jackson?

By I Wayan Saryada in Jackson Last modified: June 1, 2024 3 Comments

In the following code snippet we will convert CSV into JSON string using Jackson JSON library. A comma-separated values is a delimited text, it uses comma to separate values. It starts with header on the first line, that will be the JSON key. Each subsequence lines is the data of the csv, which also contains several values separated by comma.

Let’s see the code how to do this in Jackson.

package org.kodejava.jackson;

import com.fasterxml.jackson.databind.MappingIterator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.csv.CsvMapper;
import com.fasterxml.jackson.dataformat.csv.CsvSchema;

import java.io.IOException;
import java.util.List;
import java.util.Map;

public class CsvToJson {
    public static void main(String[] args) {
        // Comma delimited text created using text blocks
        String countries = """
                ISO, CODE, NAME\s
                CZE, CZ, Czech Republic\s
                DNK, DK, Denmark\s
                DJI, DJ, Djibouti\s
                DMA, DM, Dominica\s
                ECU, EC, Ecuador
                """;

        CsvSchema csvSchema = CsvSchema.emptySchema().withHeader();
        CsvMapper csvMapper = new CsvMapper();

        try {
            List<Map<?, ?>> list;
            try (MappingIterator<Map<?, ?>> mappingIterator = csvMapper.reader()
                    .forType(Map.class)
                    .with(csvSchema)
                    .readValues(countries)) {
                list = mappingIterator.readAll();
            }

            ObjectMapper objectMapper = new ObjectMapper();
            String jsonPretty = objectMapper.writerWithDefaultPrettyPrinter()
                    .writeValueAsString(list);
            System.out.println(jsonPretty);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Here are the explanation of the code above:

Define a csv string, in this case we have a list of countries.
Create an empty schema of CsvSchema to process csv with header line.
Create an instance of CsvMapper, a specialized type of ObjectMapper.
Read and parse csv values into List<Map<?, ?>>.
We use the ObjectMapper create a pretty-printed JSON from the list object.

Running the code produces the following output:

[ {
  "ISO" : "CZE",
  "CODE" : " CZ",
  "NAME" : " Czech Republic "
}, {
  "ISO" : "DNK",
  "CODE" : " DK",
  "NAME" : " Denmark "
}, {
  "ISO" : "DJI",
  "CODE" : " DJ",
  "NAME" : " Djibouti "
}, {
  "ISO" : "DMA",
  "CODE" : " DM",
  "NAME" : " Dominica "
}, {
  "ISO" : "ECU",
  "CODE" : " EC",
  "NAME" : " Ecuador"
} ]