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

What is Amazon Web Services (AWS)?

 Amazon Web Services Amazon Web Services is a cloud computing platform provided by Amazon. The AWS offers all three service models such as Software as a Service (SaaS), Infrastructure as a Service (IAAS), and Platform as a Service (PaaS). There are more services which comprise the Amazon Web Services including Amazon Elastic Compute Cloud (EC2) which provides virtual servers, Amazon Simple Storage Service (S3) which provides scalable storage for backups, analytics. Then there are other services such as Amazon relational database management system, DynamoDB, AWS Migration hub, and more. AWS provides services in almost every category from mobile development to data analytics. Benefits of using Amazon Web Services: AWS gives access to organizations to use programming models , database and operating system. It provides a cost effective service in which you only have to pay for what you use. Applications can be deployed in multiple regions with just a few clicks. ...
3 comments
Read more

What does :: mean in Java?

The :: operator refers to a method reference.   A method reference is a simplified way of writing a lambda expression in order to call a method. Method references allow you to call a method by mentioning its name. The syntax for a method reference is as follows: COPY Object :: methodName There are  four  ways to use a method reference: A method reference to a static method. A method reference to an instance method of an object. A method reference to instance methods of an arbitrary object of a particular type. A method reference to a constructor. METHOD REFERENCE TO A STATIC METHOD Let's take a look at the code snippet below: COPY import java.util.function.BiFunction; class Maths { public static int printAddition( int x, int y){ return x + y; } } public class Main { public static void main( String [] args) { BiFunction< Integer , Integer , Integer > addition = Maths::printAddition; int result = addition.apply(...
1 comment
Read more

Mastering Java Streams: Best Practices and Common Pitfalls

  Introduction Java Streams, introduced in Java 8, have revolutionized the way developers handle collections and data processing in Java. However, mastering Streams requires understanding not just the syntax but also the best practices and common pitfalls that can arise. In this post, we'll explore advanced tips for working with Java Streams, helping you write more efficient, readable, and maintainable code. Table of Contents Introduction to Java Streams Best Practices for Using Streams Leverage Parallel Streams Wisely Avoid State Mutations in Stream Operations Use Method References for Cleaner Code Short-Circuiting Operations for Efficiency Common Pitfalls in Java Streams Overusing Parallel Streams Modifying Collections During Stream Operations Ignoring Lazy Evaluation Improper Use of Optional with Streams Advanced Stream Operations Grouping and Partitioning Collectors and Custom Collectors FlatMap for Complex Mappings Conclusion 1. Introduction to Java Streams Java Streams provid...
Post a Comment
Read more