Serialize Date by using Jackson

In Java, Date is one of the most important data types. When we work with REST API, we need to serialize Date. In this section, we will understand how we can serialize Date by using Jackson. We will understand how we can serialize the following types of dates:

util.Date
Joda-Time
Java 8 DateTime

Let’s understand each one of them one by one:

Serialize Date to Timestamp

In order to serialize the “java.util.Date“, we take the help of the Event class. We first create a date by using SimpleDateFormat class. After that, we create an instance of an Event by using the date field. Now, we serialize the Event instance by using the ObjectMapper class.

Let’s implement the code for the above theory:

SerializeDateToTimestamp.java

  // import required classes and package if any  import java.text.ParseException;  import java.text.SimpleDateFormat;  import java.util.Date;  import java.util.Scanner;  import java.util.TimeZone;  import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;    // create class SerializeDateToTimestamp to serialize Date to Timestamp  public class SerializeDateToTimestamp {  // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {  String dateStr;  // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);  System.out.println(“Enter Date in dd-MM-yyyy hh:mm:ss format:”);  dateStr = sc.nextLine();  // create an instance of SimpleDateFormat class  SimpleDateFormat sdf = new SimpleDateFormat(“dd-MM-yyyy hh:mm:ss”);  // set time zone by using setTimeZone() method of SimpleDateFormat class  sdf.setTimeZone(TimeZone.getTimeZone(“UTC”));  // parse dateStr by using parse() method of SimpleDateFormat  Date date = sdf.parse(dateStr);  // create an instance of Event by using data  Event evt = new Event(“New Date”, date);  // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();  // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);      //print jsonString      System.out.println(jsonString);      // close Scanner class object      sc.close();  }  }   // create Event class  class Event{  public String name;  public Date data;    // parameterized constructor  Event(String name, Date data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Serialize Date to ISO-86o1

Just like Date to Timestamp serialization, we can also serialize Date to ISO-86o1 by using the ObjectMapper class. We use the setDateFormat() method of the ObjectMapper class to serialize Date to ISO-86o1.

Let’s take an example to understand how serialization is done by using ObjectMapper class:

SerializeDateToISO.java

  //import required classes and package if any  import java.text.ParseException;  import java.text.SimpleDateFormat;  import java.util.Date;  import java.util.Scanner;  import java.util.TimeZone;    import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;  import com.fasterxml.jackson.databind.SerializationFeature;  import com.fasterxml.jackson.databind.util.StdDateFormat;    //create class SerializeDateToISO to serialize Date to ISO  public class SerializeDateToISO {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {  String dateStr;  // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);  System.out.println(“Enter Date in dd-MM-yyyy hh:mm:ss format:”);  dateStr = sc.nextLine();    // create an instance of SimpleDateFormat class  SimpleDateFormat sdf = new SimpleDateFormat(“dd-MM-yyyy hh:mm:ss”);  // set time zone by using setTimeZone() method of SimpleDateFormat class  sdf.setTimeZone(TimeZone.getTimeZone(“UTC”));    // parse dateStr by using parse() method of SimpleDateFormat  Date date = sdf.parse(dateStr);    // create an instance of Event by using data  Event evt = new Event(“New Date”, date);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    //disable WRITE_DATES_AS_TIMESTAMPS feature  mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);        // set StdDateFormat by using setDateFormat() method      mapper.setDateFormat(new StdDateFormat().withColonInTimeZone(true));    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();    }  }  // create Event class  class Event{  public String name;  public Date data;    // parameterized constructor  Event(String name, Date data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Configure ObjectMapper DateFormat

All the previous ways of Date serialization still lack the full flexibility of choosing the exact format for representing the java.util.Date instance. Now, we perform some configurations which allow us to set our formats for representing dates.

Let’s take an example to configure the ObjectMapper for allowing us to set Date format.

SerializeDateWithConfiguration.java

  //import required classes and package if any  import java.text.ParseException;  import java.text.SimpleDateFormat;  import java.util.Date;  import java.util.Scanner;    import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;    //create class SerializeDateWithConfiguration to serialize Date with configuration  public class SerializeDateWithConfiguration {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {    String dateStr;    // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);    System.out.println(“Enter Date in dd-MM-yyyy hh:mm:ss format:”);  dateStr = sc.nextLine();    // create an instance of SimpleDateFormat class  SimpleDateFormat sdf = new SimpleDateFormat(“dd-MM-yyyy hh:mm:ss”);    // parse dateStr by using parse() method of SimpleDateFormat  Date date = sdf.parse(dateStr);    // create an instance of Event by using data  Event evt = new Event(“New Date”, date);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    //configure ObjectMapper class by using setDateFormat() method  mapper.setDateFormat(sdf);    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();    }  }  //create Event class  class Event{  public String name;  public Date data;    // parameterized constructor  Event(String name, Date data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Serialize Date with @JsonFormat

We can also serialize the Date by using the @JsonFormat annotation. We use annotation for controlling the Date format on individual classes. So, we use annotation when we don’t want to control the date format globally.

Let’s take an example to understand how we can use annotation for controlling Date format.

SerializeDateWithJsonFormat.java

  //import required classes and package if any  import java.text.ParseException;  import java.text.SimpleDateFormat;  import java.util.Date;  import java.util.Scanner;    import com.fasterxml.jackson.annotation.JsonFormat;  import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;    //create class SerializeDateWithJsonFormat to serialize Date with @JsonFormat annotation  public class SerializeDateWithJsonFormat {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {    String dateStr;    // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);    System.out.println(“Enter Date in dd-MM-yyyy hh:mm:ss format:”);  dateStr = sc.nextLine();    // create an instance of SimpleDateFormat class  SimpleDateFormat sdf = new SimpleDateFormat(“dd-MM-yyyy hh:mm:ss”);    // parse dateStr by using parse() method of SimpleDateFormat  Date date = sdf.parse(dateStr);    // create an instance of Event by using data  Event evt = new Event(“New Date”, date);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();    }  }  //create Event class  class Event{  public String name;    //declare date by using @JsonFormat  @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = “dd-MM-yyyy hh:mm:ss”)  public Date data;    // parameterized constructor  Event(String name, Date data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Serialize Date with Custom Date Serializer

It is another way of serializing the Date field. We define the custom date serializer, and then we use it with the @JsonSerialize.

Let’s first define the Date serializer, and then we take an example in which we use our custom date serializer.

CustomDateSerializer.java

  // import required classes and package, if any  import java.io.IOException;  import java.text.SimpleDateFormat;  import java.util.Date;    import com.fasterxml.jackson.core.JsonGenerator;  import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.SerializerProvider;  import com.fasterxml.jackson.databind.ser.std.StdSerializer;    // create class CustomDateSerializer by extending StdSerializer  public class CustomDateSerializer extends StdSerializer {    // create an instance of SimpleDateFormat to form date in dd-MM-yyyy hh:mm:ss  private SimpleDateFormat sdf = new SimpleDateFormat(“dd-MM-yyyy”);    // default constructor      public CustomDateSerializer() {          this(null);      }            // parameterized constructor      public CustomDateSerializer(Class t) {          super(t);      }            // override serialize() method      @Override      public void serialize (Date value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {      generator.writeString(sdf.format(value));      }  }  SerializeDateWithCustomSerializer.java  //import required classes and package if any  import java.text.ParseException;  import java.text.SimpleDateFormat;  import java.util.Date;  import java.util.Scanner;    import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;  import com.fasterxml.jackson.databind.annotation.JsonSerialize;    //create class SerializeDateWithCustomSerializer to serialize Date with Custom Date Serializer  public class SerializeDateWithCustomSerializer {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {    String dateStr;    // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);    System.out.println(“Enter Date in dd-MM-yyyy hh:mm:ss format:”);  dateStr = sc.nextLine();    // create an instance of SimpleDateFormat class  SimpleDateFormat sdf = new SimpleDateFormat(“dd-MM-yyyy hh:mm:ss”);    // parse dateStr by using parse() method of SimpleDateFormat  Date date = sdf.parse(dateStr);    // create an instance of Event by using data  Event evt = new Event(“New Date”, date);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();    }  }  //create Event class  class Event{  public String name;    //declare date by using @JsonFormat  @JsonSerialize(using = CustomDateSerializer.class)  public Date data;    // parameterized constructor  Event(String name, Date data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Serialize Joda-Time with Jackson

The “java.util.Date” is not the only class that provides a Date instance. Dates can be represented by other classes also, such as Joda-Time, etc. DateTime is one of the most common implementations from the Joda-Time library.

In order to use the Joda-Time, we add the following dependency in our POM.xml file:

  <dependency>  <groupId>com.fasterxml.jackson.datatype</groupId>  <artifactId>jackson-datatype-joda</artifactId>  <version>2.9.7</version>  </dependency>  

To serialize Joda-Time, we simply register the JodaModule to the ObjectMapper class:

SerializeJodaTimeExample.java

  //import required classes and package, if any  import java.text.ParseException;  import java.util.Scanner;    import org.joda.time.DateTime;  import org.joda.time.DateTimeZone;    import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;  import com.fasterxml.jackson.databind.SerializationFeature;  import com.fasterxml.jackson.datatype.joda.JodaModule;    //create class SerializeJodaTimeExample to serialize Joda-Time  public class SerializeJodaTimeExample {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {    String day, month, year, hour, min, sec;    // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);    System.out.println(“Enter Day:”);  day = sc.nextLine();    System.out.println(“Enter Month:”);  month = sc.nextLine();    System.out.println(“Enter Year:”);  year = sc.nextLine();    System.out.println(“Enter Hours:”);  hour = sc.nextLine();    System.out.println(“Enter Minutes:”);  min = sc.nextLine();    System.out.println(“Enter Seconds:”);  sec = sc.nextLine();    // form Joda-DateTime  DateTime data = new DateTime(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec), DateTimeZone.forID(“Europe/London”));    // create an instance of Event by using data  Event evt = new Event(“New Date”, data);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    // register JodaModule and disable SerializationFeature  mapper.registerModule(new JodaModule()).disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();  }  }  //create Event class  class Event{  public String name;  public DateTime data;    // parameterized constructor  Event(String name, DateTime data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Serialize Joda-Time with Custom Serializer

Just like “java.util.Date“, we can also serialize the Joda-Time by using the DateTime serializer. Let’s first create Custom DateTime Serializer, and then we will use it to serialize Joda-DateTime.

CustomDateTimeSerializer.java

  //import required classes and package, if any  package TutorAspire .Jackson;    import java.io.IOException;  import java.text.SimpleDateFormat;    import org.joda.time.DateTime;  import org.joda.time.format.DateTimeFormat;  import org.joda.time.format.DateTimeFormatter;    import com.fasterxml.jackson.core.JsonGenerator;  import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.SerializerProvider;  import com.fasterxml.jackson.databind.ser.std.StdSerializer;    //create class CustomDateTimeSerializer by extending StdSerializer  public class CustomDateTimeSerializer extends StdSerializer<DateTime> {    // create an instance of DateTimeFormatter  private static DateTimeFormatter dtf = DateTimeFormat.forPattern(“yyyy-MM-dd HH:mm:ss”);    // default constructor  public CustomDateTimeSerializer() {  this(null);  }     // parameterized constructor  public CustomDateTimeSerializer(Class<DateTime> t) {  super(t);  }     // override serialize() method  @Override  public void serialize (DateTime value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {  generator.writeString(dtf.print(value));  }  }  

SerializeJodaTimeWithSerializer.java

  //import required classes and package if any  import java.text.ParseException;  import java.util.Scanner;    import org.joda.time.DateTime;  import org.joda.time.DateTimeZone;    import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;  import com.fasterxml.jackson.databind.SerializationFeature;  import com.fasterxml.jackson.databind.annotation.JsonSerialize;  import com.fasterxml.jackson.datatype.joda.JodaModule;    //create class SerializeJodaTimeWithSerializer to serialize Joda-Time with custom date serializer  public class SerializeJodaTimeWithSerializer {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {    String day, month, year, hour, min, sec;    // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);    System.out.println(“Enter Day:”);  day = sc.nextLine();    System.out.println(“Enter Month:”);  month = sc.nextLine();    System.out.println(“Enter Year:”);  year = sc.nextLine();    System.out.println(“Enter Hours:”);  hour = sc.nextLine();    System.out.println(“Enter Minutes:”);  min = sc.nextLine();    System.out.println(“Enter Seconds:”);  sec = sc.nextLine();    // form Joda-DateTime  DateTime data = new DateTime(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec), DateTimeZone.forID(“Europe/London”));    // create an instance of Event by using data  Event evt = new Event(“New Date”, data);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();    }  }  //create Event class  class Event{  public String name;    @JsonSerialize(using = CustomDateTimeSerializer.class)  public DateTime data;    // parameterized constructor  Event(String name, DateTime data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Serialize Java 8 Date with Jackson

Just like java.util.Date and Joda-DateTime, we can also serialize Java 8 Date by using Jackson. We will use LocalDateTime for serialization and for that we add the following dependency in our POM.xml file.

  <dependency>  <groupId>com.fasterxml.jackson.datatype</groupId>      <artifactId>jackson-datatype-jsr310</artifactId>      <version>2.9.7</version>  </dependency>  

In order to serialize Java 8 Date, we will register the JavaTimeModule to ObjectMapper class.

Let’s take an example to understand how the serialization of Java 8 Date is done by using Jackson.

SerializeJava8DateExample.java

  //import required classes and package, if any  import java.text.ParseException;  import java.time.LocalDateTime;  import java.util.Scanner;    import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;  import com.fasterxml.jackson.databind.SerializationFeature;  import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;    //create class SerializeJava8DateExample to serialize Java 8 Date  public class SerializeJava8DateExample {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {    String day, month, year, hour, min, sec;    // create an instance of Scanner class object  Scanner sc = new Scanner(System.in);    System.out.println(“Enter Day:”);  day = sc.nextLine();    System.out.println(“Enter Month:”);  month = sc.nextLine();    System.out.println(“Enter Year:”);  year = sc.nextLine();    System.out.println(“Enter Hours:”);  hour = sc.nextLine();    System.out.println(“Enter Minutes:”);  min = sc.nextLine();    System.out.println(“Enter Seconds:”);  sec = sc.nextLine();    // form LocalDateTime  LocalDateTime data = LocalDateTime.of(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec));    // create an instance of Event by using data  Event evt = new Event(“New Date”, data);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    // register JavaTimeModule and disable WRITE_DATES_AS_TIMESTAMPS  mapper.registerModule(new JavaTimeModule()).disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();    }  }  //create Event class  class Event{  public String name;  public LocalDateTime data;    // parameterized constructor  Event(String name, LocalDateTime data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Serialize Java 8 Date with Custom Serializer

We can also serialize Java 8 Date by using Custom LocalDateTime Serializer. Just like java.util.Date and Joda-DateTime, we create a custom serializer, and then we use it in our code to serialize LocalDateTime in Java.

CustomLocalDateTimeSerializer.java

  //import required classes and package if any  import java.io.IOException;  import java.time.LocalDateTime;  import java.time.format.DateTimeFormatter;    import com.fasterxml.jackson.core.JsonGenerator;  import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.SerializerProvider;  import com.fasterxml.jackson.databind.ser.std.StdSerializer;    //create class CustomLocalDateTimeSerializer by extending StdSerializer  public class CustomLocalDateTimeSerializer extends StdSerializer {    // create an instance of DateTimeFormatter  private static DateTimeFormatter dtf = DateTimeFormatter.ofPattern(“yyyy-MM-dd HH:mm:ss”);    // default constructor  public CustomLocalDateTimeSerializer() {  this(null);  }     // parameterized constructor  public CustomLocalDateTimeSerializer(Class t) {  super(t);  }     // override serialize() method  @Override  public void serialize (LocalDateTime value, JsonGenerator generator, SerializerProvider provider) throws IOException, JsonProcessingException {  generator.writeString(dtf.format(value));  }  }  

SerializeJava8DateWithCustomSerializer.java

  //import required classes and package, if any  package TutorAspire .Jackson;    import java.text.ParseException;  import java.time.LocalDateTime;  import java.util.Scanner;    import com.fasterxml.jackson.core.JsonProcessingException;  import com.fasterxml.jackson.databind.ObjectMapper;  import com.fasterxml.jackson.databind.annotation.JsonSerialize;    //create class SerializeJava8DateWithCustomSerializer to serialize Java 8 Date with custom serializer  public class SerializeJava8DateWithCustomSerializer {    // main() method start  public static void main(String args[]) throws ParseException, JsonProcessingException {    String day, month, year, hour, min, sec;    // create an instance of Scanner class object    Scanner sc = new Scanner(System.in);    System.out.println(“Enter Day:”);  day = sc.nextLine();    System.out.println(“Enter Month:”);  month = sc.nextLine();    System.out.println(“Enter Year:”);  year = sc.nextLine();    System.out.println(“Enter Hours:”);  hour = sc.nextLine();    System.out.println(“Enter Minutes:”);  min = sc.nextLine();    System.out.println(“Enter Seconds:”);  sec = sc.nextLine();    // form LocalDateTime  LocalDateTime data = LocalDateTime.of(Integer.valueOf(year), Integer.valueOf(month), Integer.valueOf(day), Integer.valueOf(hour), Integer.valueOf(min), Integer.valueOf(sec));    // create an instance of Event by using data  Event evt = new Event(“New Date”, data);    // create an instance of ObjectMapper class  ObjectMapper mapper = new ObjectMapper();    // serialize evt by using writeValueAsString() method      String jsonString = mapper.writeValueAsString(evt);            //print jsonString      System.out.println(jsonString);            // close Scanner class object      sc.close();    }  }  //create Event class  class Event{  public String name;    @JsonSerialize(using = CustomLocalDateTimeSerializer.class)  public LocalDateTime data;    // parameterized constructor  Event(String name, LocalDateTime data){  this.name = name;  this.data = data;  }  }  

Output:

Serialize Date by using Jackson

Next TopicJackson JSON Views

Serialize Date by using Jackson | Jackson Date

Serialize Date by using Jackson

Serialize Date to Timestamp

Serialize Date to ISO-86o1

Configure ObjectMapper DateFormat

Serialize Date with @JsonFormat

Serialize Date with Custom Date Serializer

Serialize Joda-Time with Jackson

Serialize Joda-Time with Custom Serializer

Serialize Java 8 Date with Jackson

Serialize Java 8 Date with Custom Serializer

Tag Content Extractor Problem in Java

Difference Between Access Specifiers and Modifiers

You may also like