How to serialize Joda DateTime with Jackson JSON processor?

Question

How do I get Jackson to serialize my Joda DateTime object according to a simple pattern (like "dd-MM-yyyy")?

I've tried:

@JsonSerialize(using=DateTimeSerializer.class)
private final DateTime date;

I've also tried:

ObjectMapper mapper = new ObjectMapper()
    .getSerializationConfig()
    .setDateFormat(df);

Thanks!

Both of above should actually also work (@JsonSerialize should imply that field is to be serialized; and date format should also ideally apply to Joda), so you might want to file a Jira bug at http://jira.codehaus.org/browse/JACKSON. — StaxMan, Sep 02 '10 at 18:49
I realize this question is from a while back, but for future reference, objectMapper.getSerializationConfig().setDateFormat(df) is now deprecated. objectMapper.setDateFormat(df) is now suggested. — Patrick, Sep 07 '12 at 14:54
See also https://stackoverflow.com/questions/27952472/serialize-deserialize-java-8-java-time-with-jackson-json-mapper — Raedwald, Mar 01 '19 at 15:54

score 158 · Answer 1 · edited Nov 15 '13 at 20:37

158

This has become very easy with Jackson 2.0 and the Joda module.

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JodaModule());

Maven dependency:

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

Code and documentation: https://github.com/FasterXML/jackson-datatype-joda

Binaries: http://repo1.maven.org/maven2/com/fasterxml/jackson/datatype/jackson-datatype-joda/

edited Nov 15 '13 at 20:37

quietmint

13,885
6
48
73

answered Mar 24 '13 at 23:28

Kimble

7,295
4
54
77

17

Could you expand on this please? Where does this code go and how is the ObjectMapper instance used? – Paul Jul 29 '13 at 23:17
You should ask specific questions regarding the use of Jackson's api and Maven. Where the code goes depends on whether you use any frameworks / how you bootstrap your application. – Kimble Sep 29 '13 at 17:17
4

when I add that I get the compile error "incompatible types: JodaModule cannot be converted to Module" - the method expects a org.codehaus.jackson.map.Module but JodaModule does not have this in its heirarchy so how could this work? – Martin Charlesworth Nov 20 '13 at 23:12
Martin: Perhaps you have different versions of Jackson and the Jackson Joda Module on your classpath? – Kimble Jun 18 '14 at 18:49
5

Promising but currently almost useless as we cannot specify the date format to parse :( – Vincent Mimoun-Prat Jul 15 '14 at 17:36
@MarvinLabs my answer shows how to implement custom formatting for `DateTime` with Jackson 2 – oggmonster Sep 16 '14 at 09:18
10

You need to disable serialization as timestamps objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); – MarekM Oct 02 '14 at 11:01
Is it still working for the newest version ? Like `2.8.8` ? – Weedoze Jun 20 '17 at 14:11
1

Doesn't even need to add Module. It works just by adding the dependency. – coretechie Sep 07 '17 at 10:36

score 77 · Answer 2 · answered Jul 17 '10 at 16:10

77

In the object you're mapping:

@JsonSerialize(using = CustomDateSerializer.class)
public DateTime getDate() { ... }

In CustomDateSerializer:

public class CustomDateSerializer extends JsonSerializer<DateTime> {

    private static DateTimeFormatter formatter = 
        DateTimeFormat.forPattern("dd-MM-yyyy");

    @Override
    public void serialize(DateTime value, JsonGenerator gen, 
                          SerializerProvider arg2)
        throws IOException, JsonProcessingException {

        gen.writeString(formatter.print(value));
    }
}

answered Jul 17 '10 at 16:10

Rusty Kuntz

771
4
2

4

How to register CustomDateSerializer in spring mvc 3? – digz6666 Mar 21 '11 at 06:26
1

I don't know about Spring MVC3, but you can add a custom serializer to the Jackson mapper object. See [this entry in Jackson](http://wiki.fasterxml.com/SimpleModule) You need to create a simple module for that SimpleModule isoDateTimeModule = new SimpleModule("ISODateTimeModule", new Version(1, 0, 0, null)); isoDateTimeModule.addSerializer(new JsonISODateTimeFormatSerializer()); mapper.registerModule(isoDateTimeModule); – Guillaume Belrose Feb 29 '12 at 17:02
1

@digz6666 see my answer here for Spring MVC 3: http://stackoverflow.com/questions/7854030/configurating-objectmapper-in-spring/12617890#12617890 – Aram Kocharyan Sep 27 '12 at 09:12
Note - make sure to use the above classes from `org.codehaus.jackson` rather than `com.fasterxml.jackson.core`. Using the second package didn't work for me. In fact, my Jersey app didn't even respect the `@JsonSerialized` annotation. – Kevin Meredith May 13 '14 at 17:08
The answer did work for me. But it would require this annotation on all the fields. Is there some global configuration for this which works with Jackson? – Taher Jun 12 '15 at 02:36
Is there a way to do this for ALL datetime objects as I do not want to alter all my mapped objects? – Lars Juel Jensen Jun 03 '16 at 18:06

score 28 · Answer 3 · answered Sep 16 '14 at 09:17

As @Kimble has said, with Jackson 2, using the default formatting is very easy; simply register JodaModule on your ObjectMapper.

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JodaModule());

For custom serialization/de-serialization of DateTime, you need to implement your own StdScalarSerializer and StdScalarDeserializer; it's pretty convoluted, but anyway.

For example, here's a DateTime serializer that uses the ISODateFormat with the UTC time zone:

public class DateTimeSerializer extends StdScalarSerializer<DateTime> {

    public DateTimeSerializer() {
        super(DateTime.class);
    }

    @Override
    public void serialize(DateTime dateTime,
                          JsonGenerator jsonGenerator,
                          SerializerProvider provider) throws IOException, JsonGenerationException {
        String dateTimeAsString = ISODateTimeFormat.withZoneUTC().print(dateTime);
        jsonGenerator.writeString(dateTimeAsString);
    }
}

And the corresponding de-serializer:

public class DateTimeDesrializer extends StdScalarDeserializer<DateTime> {

    public DateTimeDesrializer() {
        super(DateTime.class);
    }

    @Override
    public DateTime deserialize(JsonParser jsonParser,
                                DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        try {
            JsonToken currentToken = jsonParser.getCurrentToken();
            if (currentToken == JsonToken.VALUE_STRING) {
                String dateTimeAsString = jsonParser.getText().trim();
                return ISODateTimeFormat.withZoneUTC().parseDateTime(dateTimeAsString);
            }
        } finally {
            throw deserializationContext.mappingException(getValueClass());
        }
    }

Then tie these together with a module:

public class DateTimeModule extends SimpleModule {

    public DateTimeModule() {
        super();
        addSerializer(DateTime.class, new DateTimeSerializer());
        addDeserializer(DateTime.class, new DateTimeDeserializer());
    }
}

Then register the module on your ObjectMapper:

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new DateTimeModule());

the deserilazed DatatIme object is in UTC timezone or else browsers timezone please help me — user3354457, Sep 08 '15 at 12:06

score 20 · Answer 4 · edited Apr 27 '19 at 12:44

The easy solution

I have encountered similar problem and my solution is much clear than above.

I simply used the pattern in @JsonFormat annotation

Basically my class has a DateTime field, so I put an annotation around the getter:

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
public DateTime getDate() {
    return date;
}

I serialize the class with ObjectMapper

    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(new JodaModule());
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    ObjectWriter ow = mapper.writer();
    try {
        String logStr = ow.writeValueAsString(log);
        outLogger.info(logStr);
    } catch (IOException e) {
        logger.warn("JSON mapping exception", e);
    }

We use Jackson 2.5.4

score 16 · Answer 5 · edited May 23 '17 at 11:33

https://stackoverflow.com/a/10835114/1113510

Although you can put an annotation for each date field, is better to do a global configuration for your object mapper. If you use jackson you can configure your spring as follow:

<bean id="jacksonObjectMapper" class="com.company.CustomObjectMapper" />

<bean id="jacksonSerializationConfig" class="org.codehaus.jackson.map.SerializationConfig"
    factory-bean="jacksonObjectMapper" factory-method="getSerializationConfig" >
</bean>

For CustomObjectMapper:

public class CustomObjectMapper extends ObjectMapper {

    public CustomObjectMapper() {
        super();
        configure(Feature.WRITE_DATES_AS_TIMESTAMPS, false);
        setDateFormat(new SimpleDateFormat("EEE MMM dd yyyy HH:mm:ss 'GMT'ZZZ (z)"));
    }
}

Of course, SimpleDateFormat can use any format you need.

`setDateFormat(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssz"));` did the trick for me, thx — Konsumierer, Oct 15 '12 at 07:58

score 11 · Answer 6 · answered Mar 28 '17 at 06:09

Meanwhile Jackson registers the Joda module automatically when the JodaModule is in classpath. I just added jackson-datatype-joda to Maven and it worked instantly.

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

JSON output:

{"created" : "2017-03-28T05:59:27.258Z"}

jgeerts · Answer 7 · 2016-11-18T22:37:24.907

7

For those with Spring Boot you have to add the module to your context and it will be added to your configuration like this.

@Bean
public Module jodaTimeModule() {
    return new JodaModule();
}

And if you want to use the new java8 time module jsr-310.

@Bean
public Module jodaTimeModule() {
    return new JavaTimeModule();
}

edited Nov 18 '16 at 22:37

answered Nov 18 '16 at 21:39

jgeerts

641
8
17

score 4 · Answer 8 · edited Dec 19 '19 at 14:37

4

I'm using Java 8 and this worked for me.

Add the dependency on pom.xml

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

and add JodaModule on your ObjectMapper

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JodaModule());

edited Dec 19 '19 at 14:37

djm.im

3,295
4
30
45

answered Dec 14 '16 at 18:41

Luciana Campello

101
4

ydrozhdzhal · Answer 9 · 2013-04-08T12:28:26.740

It seems that for Jackson 1.9.12 there is no such possibility by default, because of:

public final static class DateTimeSerializer
    extends JodaSerializer<DateTime>
{
    public DateTimeSerializer() { super(DateTime.class); }

    @Override
    public void serialize(DateTime value, JsonGenerator jgen, SerializerProvider provider)
        throws IOException, JsonGenerationException
    {
        if (provider.isEnabled(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS)) {
            jgen.writeNumber(value.getMillis());
        } else {
            jgen.writeString(value.toString());
        }
    }

    @Override
    public JsonNode getSchema(SerializerProvider provider, java.lang.reflect.Type typeHint)
    {
        return createSchemaNode(provider.isEnabled(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS)
                ? "number" : "string", true);
    }
}

This class serializes data using toString() method of Joda DateTime.

Approach proposed by Rusty Kuntz works perfect for my case.

You can still register custom serializer and deserializer, and those will have precedence over default implementation. — StaxMan, Aug 06 '13 at 00:04

score 0 · Answer 10 · answered Aug 26 '22 at 23:18

Use Built-in Joda Serializer/Deserializer for easy config

If you want custom formatting, there's no need to write a custom Serializer or Deserializer. jackson-datatype-joda 2.x provides a DateTimeSerializer and DateTimeDeserializer on which you can set a DateTimeFormatter to use, providing you custom formatting. You then add the configured Serializer and/or Deserializer to the JodaModule when you add the module.

An advantage of using the provided Serializer/Deserializer (over custom ones) is that you can annotated any DateTime properties with @JsonFormat(pattern = ". . .") to override the format you configure. The custom Serializers/Deserializers shown in most of the other answers (from the Jackson 1.x days) will not honor @JsonFormat annotations. So if you have that one odd ball DateTime value that needs a a different format, it is easily handled, as shown in the below examples.

In addition to the DateTimeSerializer and DateTimeDeserializer, there are others such as LocalDateSerializer/LocalDateDeserializer, PeriodSerializer/PeriodDeserializer, etc.

Examples

Below is a Java and a Kotlin example. You will need to add the following to your dependencies:

com.fasterxml.jackson.datatype:jackson-datatype-joda:{version}

The examples show setting a default custom format, and overriding that format on a per property basis via the @JsonFormat annotation.

Java Example

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.datatype.joda.JodaModule;
import com.fasterxml.jackson.datatype.joda.cfg.JacksonJodaDateFormat;
import com.fasterxml.jackson.datatype.joda.deser.DateTimeDeserializer;
import com.fasterxml.jackson.datatype.joda.ser.DateTimeSerializer;
import org.joda.time.DateTime;
import org.joda.time.ReadableInstant;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;



public class JacksonJodaTimeJavaExample
{
    private static final DateTimeFormatter DATE_TIME_FORMATTER =
        DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ssZZ");
    private static final JacksonJodaDateFormat JACKSON_JODA_DATE_FORMAT =
        new JacksonJodaDateFormat(DATE_TIME_FORMATTER);

    private static ObjectMapper mapper = createMapper();

    private static ObjectMapper createMapper()
    {
        return JsonMapper
            .builder()
            .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
            .addModule(new JodaModule()
                           // If you do not want to customize the formatting, you can remove the next two lines
                           .addSerializer(new DateTimeSerializer(JACKSON_JODA_DATE_FORMAT))
                           .addDeserializer(ReadableInstant.class, new DateTimeDeserializer(ReadableInstant.class, JACKSON_JODA_DATE_FORMAT))
            )
            // Enable pretty printing for our example
            .enable(SerializationFeature.INDENT_OUTPUT)
            .build();
    }

    record Event(
        DateTime startTime,
        DateTime endTime,
        @JsonFormat(pattern = "yyyy-MM-dd 'at' HH:mm:ss")
        DateTime dateTimeInAlternateFormat
    ) {}


    public static void main(String[] args) throws Exception
    {
        final DateTime now = DateTime.now();
        Event event = new Event(now, now.plusHours(1), now);

        String json = mapper.writeValueAsString(event);
        System.out.println(json);

        Event deserializedEvent = mapper.readValue(json, Event.class);
        System.out.println(deserializedEvent);
    }
}

Kotlin Example

import com.fasterxml.jackson.annotation.JsonFormat
import com.fasterxml.jackson.databind.SerializationFeature
import com.fasterxml.jackson.databind.json.JsonMapper
import com.fasterxml.jackson.datatype.joda.JodaModule
import com.fasterxml.jackson.datatype.joda.cfg.JacksonJodaDateFormat
import com.fasterxml.jackson.datatype.joda.deser.DateTimeDeserializer
import com.fasterxml.jackson.datatype.joda.ser.DateTimeSerializer
import org.joda.time.DateTime
import org.joda.time.ReadableInstant
import org.joda.time.format.DateTimeFormat

object JacksonJodaTimeKotlinExample
{
    private val DATE_TIME_FORMATTER = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ssZZ")
    private val JACKSON_JODA_DATE_FORMAT = JacksonJodaDateFormat(DATE_TIME_FORMATTER)
    private val mapper = createMapper()

    private fun createMapper() =
        JsonMapper
        .builder()
        .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
        .addModule(
            // If you do not want to customize the formatting, you can remove the "apply" block
            JodaModule().apply {
                addSerializer(DateTimeSerializer(JACKSON_JODA_DATE_FORMAT))
                addDeserializer(ReadableInstant::class.java, DateTimeDeserializer(ReadableInstant::class.java, JACKSON_JODA_DATE_FORMAT))
            })
        // Enable pretty printing for our example
        .enable(SerializationFeature.INDENT_OUTPUT)
        .build()

    data class Event(
        var startTime: DateTime? = null,
        var endTime: DateTime? = null,
        // If we want a DateTime in an alternate format, we can
        @JsonFormat(pattern = "yyyy-MM-dd 'at' HH:mm:ss")
        var dateTimeInAlternateFormat: DateTime? = null)

    fun runExample()
    {
        val now = DateTime.now()
        val event = Event(now, now.plusHours(1), now)
        val json = mapper.writeValueAsString(event)
        println(json)
        val deserializedEvent = mapper.readValue(json, Event::class.java)
        println(deserializedEvent)
    }
}

fun main()
{
    JacksonJodaTimeKotlinExample.runExample()
}

How to serialize Joda DateTime with Jackson JSON processor?

10 Answers10

The easy solution

Use Built-in Joda Serializer/Deserializer for easy config

Examples

Java Example

Kotlin Example

Linked

Related