Skip to main content

How to parse JSON with date field in Java - Jackson @JsonDeserialize Annotation Example

How to Parse JSON with Date Field in Java - Jackson `@JsonDeserialize` Annotation Example

Parsing JSON in Java is a common task, but dealing with date fields requires a little extra attention. JSON treats everything as a string, but Java has strong typing, meaning dates need to be handled differently.

In this post, we will see how to parse a JSON with a date field using Jackson, focusing on the `@JsonDeserialize` annotation.

Example Scenario

Let’s assume we have a simple JSON that includes a date field:

```

{

  "name": "John Doe",

  "birthDate": "2024-09-05"

}

```


In Java, we might want to map this to a class with a `LocalDate` for `birthDate`. This is where Jackson's `@JsonDeserialize` annotation comes into play.

Step-by-Step Example

Step 1: Add Jackson Dependency

First, make sure you have the Jackson dependency in your `pom.xml` if you’re using Maven:

```

<dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-databind</artifactId>

    <version>2.13.0</version>

</dependency>

```

Step 2: Create the POJO

Let’s create a class `Person` that maps to the JSON structure:

```

import com.fasterxml.jackson.annotation.JsonFormat;

import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

import java.time.LocalDate;

public class Person {

    private String name;

    @JsonDeserialize(using = LocalDateDeserializer.class)

    @JsonFormat(pattern = "yyyy-MM-dd")  // This defines the format in which date is expected

    private LocalDate birthDate;

    // Getters and Setters

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public LocalDate getBirthDate() {

        return birthDate;

    }

    public void setBirthDate(LocalDate birthDate) {

        this.birthDate = birthDate;

    }

}

```

Step 3: Create a Custom Deserializer

We need to create a custom deserializer for `LocalDate`. Jackson will use this to convert the date string into a `LocalDate` object.

```
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 java.io.IOException;

import java.time.LocalDate;

import java.time.format.DateTimeFormatter;

public class LocalDateDeserializer extends JsonDeserializer<LocalDate> {

    @Override

    public LocalDate deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)

            throws IOException, JsonProcessingException {

        String date = jsonParser.getText();

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        return LocalDate.parse(date, formatter);

    }

}

```

Step 4: Parse the JSON


Finally, you can use Jackson to parse the JSON into your `Person` object:

```
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonParserExample {

    public static void main(String[] args) {

        String json = "{ \"name\": \"John Doe\", \"birthDate\": \"2024-09-05\" }";

                ObjectMapper objectMapper = new ObjectMapper();

                try {

            Person person = objectMapper.readValue(json, Person.class);

            System.out.println("Name: " + person.getName());

            System.out.println("Birth Date: " + person.getBirthDate());

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

```
Output:

```

Name: John Doe

Birth Date: 2024-09-05

```

Summary


In this example, we used Jackson’s `@JsonDeserialize` to handle the date field. This technique is especially useful when dealing with date formats in JSON that need to be mapped to Java’s `LocalDate` or `Date` objects.

By using a custom deserializer and `@JsonFormat`, you can easily control how dates are handled and parsed in your Java application.


Labels:

Comments

Post a Comment

Popular posts from this blog

Ace Your Java Interview: Top 50 Java Interview Questions & Answers (2025)

  Introduction Java continues to be a top programming language in 2025 , widely used in enterprise applications, microservices, cloud computing, and AI-based systems . If you're preparing for a Java developer interview , you must be well-versed in Core Java, Java 8-21 features, Spring Boot, Microservices, and Cloud technologies . This guide covers the top 50 Java interview questions for freshers and experienced professionals , ensuring you are ready for your next interview! Table of Contents Core Java Interview Questions Java 8, Java 11, and Java 21 Features OOP and Design Patterns Multithreading and Concurrency JVM, Garbage Collection & Memory Management Collections Framework Spring Boot & Microservices Cloud Technologies (AWS, Azure, GCP) Real-World Java Interview Scenarios 1. Core Java Interview Questions Q1: What are the key features of Java? Answer: Platform Independence – Java runs on JVM , making it OS-independent. Object-Oriented – Java follows...
Post a Comment
Read more

Dealing with Passwords in Java Applications: 5 Best Practices You Should Follow

 In modern Java applications—whether core Java applications or enterprise-level web applications—working with passwords is inevitable. Passwords are sensitive pieces of information, just like Social Security Numbers (SSNs), and if you’re handling real human data in systems such as online banking or healthcare portals, it’s critical to implement best practices for dealing with passwords securely. Below, I’ll share five essential best practices that I’ve learned and recommend for managing passwords, particularly when you are handling authentication and authorization. While these tips are a good starting point, be sure to tailor them to your application’s requirements and security policies. 1) Use SSL/TLS to Transfer Username and Password When users send passwords over the network, it is crucial to use SSL/TLS to encrypt the communication. This ensures that sensitive information is protected from eavesdroppers. Tools like LDAP and Active Directory are commonly used for storing usern...
Post a Comment
Read more

Fail Fast and Fail Safe Iterator in Java

  The concepts of "fail-safe" and "fail-fast" are often discussed in the context of data structures and algorithms, particularly in Java programming. Let's understand what each concept means: Fail-Safe: Fail-safe refers to the property of a system or data structure that guarantees it will not fail, crash, or produce incorrect results, even when it encounters unexpected inputs or concurrent modifications. In the context of Java collections, a fail-safe iterator is an iterator that does not throw a ConcurrentModificationException if the collection is modified while it's being iterated. Instead, it operates on a copy of the original collection or uses some mechanism to handle concurrent modifications safely. For example, the Iterator returned by HashMap or ConcurrentHashMap in Java is fail-safe. If a collection is modified while an iterator is traversing it, the iterator will continue to operate on the original elements that were present when the iteration ...
Post a Comment
Read more