226

For java.util.Date when I do

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd/MM/yyyy")  
  private Date dateOfBirth;

then in JSON request when I send

{ {"dateOfBirth":"01/01/2000"} }  

it works.

How should I do this for Java 8's LocalDate field??

I tried having

@JsonDeserialize(using = LocalDateDeserializer.class)  
@JsonSerialize(using = LocalDateSerializer.class)  
private LocalDate dateOfBirth;  

It didn't work.

Can someone please let me know what's the right way to do this..

Below are dependencies

<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>jaxrs-api</artifactId>
     <version>3.0.9.Final</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.jaxrs</groupId>
    <artifactId>jackson-jaxrs-json-provider</artifactId>
    <version>2.4.2</version>
</dependency>
<dependency>
    <groupId>com.wordnik</groupId>
    <artifactId>swagger-annotations</artifactId>
    <version>1.3.10</version>
</dependency>
Naman
  • 27,789
  • 26
  • 218
  • 353
JAB
  • 3,546
  • 9
  • 36
  • 39

17 Answers17

159

I was never able to get this to work simple using annotations. To get it to work, I created a ContextResolver for ObjectMapper, then I added the JSR310Module (update: now it is JavaTimeModule instead), along with one more caveat, which was the need to set write-date-as-timestamp to false. See more at the documentation for the JSR310 module. Here's an example of what I used.

Dependency

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

Note: One problem I faced with this is that the jackson-annotation version pulled in by another dependency, used version 2.3.2, which cancelled out the 2.4 required by the jsr310. What happened was I got a NoClassDefFound for ObjectIdResolver, which is a 2.4 class. So I just needed to line up the included dependency versions

ContextResolver

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JSR310Module;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;

@Provider
public class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {  
    private final ObjectMapper MAPPER;

    public ObjectMapperContextResolver() {
        MAPPER = new ObjectMapper();
        // Now you should use JavaTimeModule instead
        MAPPER.registerModule(new JSR310Module());
        MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    }

    @Override
    public ObjectMapper getContext(Class<?> type) {
        return MAPPER;
    }  
}

Resource class

@Path("person")
public class LocalDateResource {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Response getPerson() {
        Person person = new Person();
        person.birthDate = LocalDate.now();
        return Response.ok(person).build();
    }

    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    public Response createPerson(Person person) {
        return Response.ok(
                DateTimeFormatter.ISO_DATE.format(person.birthDate)).build();
    }

    public static class Person {
        public LocalDate birthDate;
    }
}

Test

curl -v http://localhost:8080/api/person
Result: {"birthDate":"2015-03-01"}

curl -v -POST -H "Content-Type:application/json" -d "{\"birthDate\":\"2015-03-01\"}" http://localhost:8080/api/person
Result: 2015-03-01


See also here for JAXB solution.

UPDATE

The JSR310Module is deprecated as of version 2.7 of Jackson. Instead, you should register the module JavaTimeModule. It is still the same dependency.

Paul Samsotha
  • 205,037
  • 37
  • 486
  • 720
  • 2
    Hi Peeskillet , the field birthDate , is being generated as "birthDate ": { "year": 0, "month": "Month", "dayOfMonth": 0, "dayOfWeek": "DayOfWeek", "era": { "value": 0 }, "dayOfYear": 0, "leapYear": false, "monthValue": 0, "chronology": { "id": "", "calendarType": "" } } how can i make it just as "birthDate"??? – JAB Mar 02 '15 at 08:07
  • Check the ContextResolver is called. Add a print statement in the `getContext` method. If this method is called, I don't see a reason for this not to work. If it's not called, then it may be something that's needs to be fixed with the app configuration. For that I would need to see more than what you have provided. Like Resteasy version, dependencies, app config either web.xml or Application subclass. Basically enough to reproduce the problem – Paul Samsotha Mar 02 '15 at 08:18
  • ContextResolver is not being called Peeskillet . I am resgistering it in web.xml as resteasy.resources com.bac.ObjectMapperContextResolver updated question for dependencies i am using – JAB Mar 02 '15 at 09:08
  • Swagger seems to be the issue. I would say to disable it but seeing [from this question](http://stackoverflow.com/q/28431468/2587435) there is an issue which has been filed, with a conflict between Swagger's ObjectMapper and trying to use your own. You can try and disable theirs, and in the ContextResolver, set all the configurations to the `ObjectMapper` as swagger does (you can see a link in the question). I don't know as I don't work with swagger much. But I think swagger is the main problem, why the contextresolver is not being called. – Paul Samsotha Mar 02 '15 at 09:22
  • After further testing, The annotation _does_ work. Even if We _have_ to use Swagger ObjectMapper, then already configure the time stamps as false for us. So this should work. For better help, I strongly suggest you provide a [MCVE](http://stackoverflow.com/help/mcve) that demonstrates the problem. – Paul Samsotha Mar 02 '15 at 09:32
  • Look at is this way, If I told you to run my app, and all I gave you was what you have provided in your post, could you run it? I would create a new project with the minimal configurations, classes, dependencies needed to reproduce the problem, then provide us with all that information. – Paul Samsotha Mar 02 '15 at 09:34
  • Thanks a Lot Peeskillet , Like you said the annotations work @JsonDeserialize(using = LocalDateDeserializer.class) @JsonSerialize(using = LocalDateSerializer.class) ... Actually i was getting exception while Deserializing i.e. in LocalDateDeserializer , while debugging i found it . Exception was because of the above generated json mentioned in Comment 1 . And using ObjectMapperContextResolver ... this can be resolved .. – JAB Mar 18 '15 at 05:24
  • 1
    The class `com.fasterxml.jackson.datatype.jsr310.JSR310Module` is deprecated as of version 2.5, recommended is using the newer `com.fasterxml.jackson.datatype.jsr310.JavaTimeModule`. – DrunkenPope Nov 29 '16 at 15:50
  • FYI The `jackson-datatype-jsr310` dependency is already included if you use `spring-boot-starter-web`, but you do need to register the `JavaTimeModule` in the mapper before usage. – Paul Feb 14 '22 at 14:06
126
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
spongebob
  • 8,370
  • 15
  • 50
  • 83
欧阳世雄
  • 1,261
  • 1
  • 8
  • 2
  • 2
    `new com.fasterxml.jackson.datatype.jsr310.JSR310Module()` for version 2.5.4 of Jackson. JavaTimeModule class doesn't exist in this version. – user3774109 Feb 16 '17 at 13:42
  • 1
    This answer also works for `LocalDateTime` (jackson 2.9.5). 1 additional dependency required, so my build.sbt looks like: `"com.fasterxml.jackson.module" %% "jackson-module-scala" % "2.9.5", "com.fasterxml.jackson.datatype" % "jackson-datatype-jsr310" % "2.9.5"` – ruhong Jun 20 '18 at 13:34
  • 1
    This pointed me in the right direction, Thank you! I would add that in spring-boot all you need to do is add the following to application.properties: spring.jackson.serialization.write-dates-as-timestamps= false – Joost Lambregts Jun 18 '19 at 09:28
  • yes, ObjectMapper bean did the trick. Thanks! – Tom Silverman Aug 01 '21 at 11:51
117

@JsonSerialize and @JsonDeserialize worked fine for me. They eliminate the need to import the additional jsr310 module:

@JsonDeserialize(using = LocalDateDeserializer.class)  
@JsonSerialize(using = LocalDateSerializer.class)  
private LocalDate dateOfBirth;

Deserializer:

public class LocalDateDeserializer extends StdDeserializer<LocalDate> {

    private static final long serialVersionUID = 1L;

    protected LocalDateDeserializer() {
        super(LocalDate.class);
    }


    @Override
    public LocalDate deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {
        return LocalDate.parse(jp.readValueAs(String.class));
    }

}

Serializer:

public class LocalDateSerializer extends StdSerializer<LocalDate> {

    private static final long serialVersionUID = 1L;

    public LocalDateSerializer(){
        super(LocalDate.class);
    }

    @Override
    public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider sp) throws IOException, JsonProcessingException {
        gen.writeString(value.format(DateTimeFormatter.ISO_LOCAL_DATE));
    }
}
Alan
  • 7,066
  • 5
  • 30
  • 38
Christopher Yang
  • 3,769
  • 4
  • 30
  • 27
  • 15
    Those classes are included in `jackson-datatype-jsr310`. No need to manually define them in your project. – NeuroXc Jul 23 '17 at 17:57
  • 2
    This solution worked for me, using the serializers in `jackson-datatype-jsr310`. – dave Mar 17 '18 at 23:32
  • 4
    If you use serializers and deserializers in jackson-datatype-jsr310, better add @JsonFormat(shape = JsonFormat.Shape.STRING) to your field. Without this format, the value will be serialized as [year, month, day], although deserialization will work. – Jian Chen Jan 13 '19 at 02:20
  • this answer doesn't work for me Jackson version 2.9.0 – alex Jun 30 '21 at 20:38
71

In Spring Boot web app, with Jackson and JSR 310 version "2.8.5"

compile "com.fasterxml.jackson.core:jackson-databind:2.8.5"
runtime "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.8.5"

The @JsonFormat works:

import com.fasterxml.jackson.annotation.JsonFormat;

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
private LocalDate birthDate;
informatik01
  • 16,038
  • 10
  • 74
  • 104
Tsolak Barseghyan
  • 1,048
  • 11
  • 16
  • 2
    Does this work for deserialization? or only serialization? Not having success with deserialization – rewolf Mar 09 '17 at 06:25
  • 8
    I had to explicitly declare the deserializer `@JsonDeserialize(using= LocalDateDeserializer.class)` – rewolf Mar 12 '17 at 22:55
  • `@JsonFormat` just for changing output data format. https://stackoverflow.com/a/53251526/816759 works perfect with `@JsonFormat`, `@JsonDeserialize`, `@JsonSerialize` – Baha Dec 04 '19 at 20:33
  • 1
    In Spring Boot, once you add the JSR310 dependency, all you need to do is add `spring.jackson.serialization.write-dates-as-timestamps=false` to your `application.properties`, and it formats it in `yyyy-MM-dd` automatically. No need for `@JsonFormat` – esfandia Mar 29 '20 at 06:25
  • 1
    Simplest solution. – Abhijith Ravindran Dec 21 '20 at 19:25
53

The simplest solution (which supports deserialization and serialization as well) is

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd/MM/yyyy")
@JsonDeserialize(using = LocalDateDeserializer.class)
@JsonSerialize(using = LocalDateSerializer.class)
private LocalDate dateOfBirth;

While using the following dependencies in your project.

Maven

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

Gradle

compile "com.fasterxml.jackson.core:jackson-databind:2.9.7"
compile "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.7"

No additional implementation of a ContextResolver, Serializer or Deserializer is required.

Paul Wasilewski
  • 9,762
  • 5
  • 45
  • 49
  • Brilliant, far and away the easiest. FYI for anyone with lots of dependencies, I had to update some other libraries which incorporated jackson annotations. – brt Jan 28 '19 at 19:11
  • This answer is the closest i got to fix my problem. Serialization is working, but deserialization is failing because of the pattern I used with @JsonFormat i think (@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy_HH:mm:SS"). – fsakiyama Apr 24 '19 at 14:50
  • If you have a failed deserialization, most likely is your `ObjectMapper` doesn't have `JavaTimeModule` registered. If your ObjectMapper instance is provided from spring/MessageConverter framework. They did some magic to wire them up. In other case, should `registerModule` to enable `LocalDateDeserializer`by default for all "LocalDate" in POJO – Dennis C Jun 11 '20 at 09:33
  • 1
    After looking at so many solution, this worked for me. For me date was in "yyyyMMdd" format and it worked like charm. Thanks – vikas tiwari Jul 01 '21 at 14:34
  • @vikastiwari, happy to hear that. And it's easy as pie :) – Paul Wasilewski Jul 01 '21 at 16:43
  • This was the only thing that worked for me, I have ObjectMapper's sprinkled throughout my code base, and the error doesn't tell me which one to edit, and I think this doesn't required registering JavaTimeModule – user1689987 Apr 24 '23 at 18:01
44
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonDeserialize(using = LocalDateTimeDeserializer.class)
private LocalDateTime createdDate;
Miss Chanandler Bong
  • 4,081
  • 10
  • 26
  • 36
slisnychyi
  • 1,832
  • 3
  • 25
  • 32
23

Since LocalDateSerializer turns it into "[year,month,day]" (a json array) rather than "year-month-day" (a json string) by default, and since I don't want to require any special ObjectMapper setup (you can make LocalDateSerializer generate strings if you disable SerializationFeature.WRITE_DATES_AS_TIMESTAMPS but that requires additional setup to your ObjectMapper), I use the following:

imports:

import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;

code:

// generates "yyyy-MM-dd" output
@JsonSerialize(using = ToStringSerializer.class)
// handles "yyyy-MM-dd" input just fine (note: "yyyy-M-d" format will not work)
@JsonDeserialize(using = LocalDateDeserializer.class)
private LocalDate localDate;

And now I can just use new ObjectMapper() to read and write my objects without any special setup.

Shadow Man
  • 3,234
  • 1
  • 24
  • 35
  • 3
    One thing I'd like to add is to pass date as `"2018-12-07"` instead of `"2018-12-7"` else you'll get an error. – Kid101 Dec 06 '18 at 15:08
  • 1
    Correct, it works with `yyyy-MM-dd` (2 digit month and day) format, not `yyyy-M-d` (1 digit month or day) format. – Shadow Man Dec 10 '18 at 22:58
18

Simplest and shortest so far:

@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate localDate;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime localDateTime;

no dependency required with Spring boot >= 2.2+

Anil Bhaskar
  • 3,718
  • 4
  • 33
  • 51
13

The following annotation worked fine for me.

No extra dependencies needed.

    @JsonProperty("created_at")
    @JsonFormat(pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX")
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    private LocalDateTime createdAt;
KayV
  • 12,987
  • 11
  • 98
  • 148
11

Just an update of Christopher answer.

Since the version 2.6.0

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

Use the JavaTimeModule instead of JSR310Module (deprecated).

@Provider
public class ObjectMapperContextResolver implements ContextResolver<ObjectMapper> {  
    private final ObjectMapper MAPPER;

    public ObjectMapperContextResolver() {
        MAPPER = new ObjectMapper();
        MAPPER.registerModule(new JavaTimeModule());
        MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    }

    @Override
    public ObjectMapper getContext(Class<?> type) {
        return MAPPER;
    }  
}

According to the documentation, the new JavaTimeModule uses same standard settings to default to serialization that does NOT use Timezone Ids, and instead only uses ISO-8601 compliant Timezone offsets.

Behavior may be changed using SerializationFeature.WRITE_DATES_WITH_ZONE_ID

bdzzaid
  • 838
  • 8
  • 15
  • This helped me. In my case, I needed to add the `MAPPER.registerModule(new JavaTimeModule());` line. It let me format LocalDate objects as "2020-02-20" format. I didn't need the `MAPPER.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);` line, for what I was looking for – Cuga May 21 '20 at 14:55
11

https://stackoverflow.com/a/53251526/1282532 is the simplest way to serialize/deserialize property. I have two concerns regarding this approach - up to some point violation of DRY principle and high coupling between pojo and mapper.

public class Trade {
    @JsonFormat(pattern = "yyyyMMdd")
    @JsonDeserialize(using = LocalDateDeserializer.class)
    @JsonSerialize(using = LocalDateSerializer.class)
    private LocalDate tradeDate;
    @JsonFormat(pattern = "yyyyMMdd")
    @JsonDeserialize(using = LocalDateDeserializer.class)
    @JsonSerialize(using = LocalDateSerializer.class)
    private LocalDate maturityDate;
    @JsonFormat(pattern = "yyyyMMdd")
    @JsonDeserialize(using = LocalDateDeserializer.class)
    @JsonSerialize(using = LocalDateSerializer.class)
    private LocalDate entryDate;
}

In case you have POJO with multiple LocalDate fields it's better to configure mapper instead of POJO. It can be as simple as https://stackoverflow.com/a/35062824/1282532 if you are using ISO-8601 values ("2019-01-31")

In case you need to handle custom format the code will be like this:

ObjectMapper mapper = new ObjectMapper();
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyyMMdd")));
javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyyMMdd")));
mapper.registerModule(javaTimeModule);

The logic is written just once, it can be reused for multiple POJO

Pavel
  • 2,557
  • 1
  • 23
  • 19
8

As of 2020 and Jackson 2.10.1 there's no need for any special code, it's just a matter of telling Jackson what you want:

ObjectMapper objectMapper = new ObjectMapper();

// Register module that knows how to serialize java.time objects
// Provided by jackson-datatype-jsr310
objectMapper.registerModule(new JavaTimeModule());

// Ask Jackson to serialize dates as String (ISO-8601 by default)
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

This has already been mentioned in this answer, I'm adding a unit test verifying the functionality:

import com.fasterxml.jackson.annotation.JsonFormat;
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;
import lombok.Data;
import org.junit.jupiter.api.Test;

import java.time.LocalDate;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class LocalDateSerializationTest {

    @Data
    static class TestBean {
        // Accept default ISO-8601 format
        LocalDate birthDate;
        // Use custom format
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd/MM/yyyy")
        LocalDate birthDateWithCustomFormat;
    }

    @Test
    void serializeDeserializeTest() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();

        // Register module that knows how to serialize java.time objects
        objectMapper.registerModule(new JavaTimeModule());

        // Ask Jackson to serialize dates as String (ISO-8601 by default)
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        // The JSON string after serialization
        String json = "{\"birthDate\":\"2000-01-02\",\"birthDateWithCustomFormat\":\"03/02/2001\"}";

        // The object after deserialization
        TestBean object = new TestBean();
        object.setBirthDate(LocalDate.of(2000, 1, 2));
        object.setBirthDateWithCustomFormat(LocalDate.of(2001, 2, 3));

        // Assert serialization
        assertEquals(json, objectMapper.writeValueAsString(object));

        // Assert deserialization
        assertEquals(object, objectMapper.readValue(json, TestBean.class));
    }
}

TestBean uses Lombok to generate the boilerplate for the bean.

Bogdan Calmac
  • 7,993
  • 6
  • 51
  • 64
3

A bit easier For Spring :

///...

@Configuration
public class ApplicationCtxBeans {
//....
    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper MAPPER = new ObjectMapper(); 
        MAPPER.registerModule(new JavaTimeModule()); // to handle LocalDateTime etc
        return MAPPER;
    }
//...
}

Usage :

@Service
public class SomeService {
    
//...
    @Autowired
    ObjectMapper jsonMapper;
//...
  JsonNode node = jsonMapper.readTree(
    jsonMapper.writeValueAsString(instance_Of_Class_With_LocalDate_Fields)
  );
//...
}
user16547619
  • 199
  • 1
  • 4
2

With spring boot 2.3.9.RELEASE,I just registered java time module with no explicit annotation in POJO class having LocalDate field & it worked.

var objectMapper = new ObjectMapper();
objectMapper.registerModule(new JavaTimeModule());
user2800089
  • 2,015
  • 6
  • 26
  • 47
1

In configuration class define LocalDateSerializer and LocalDateDeserializer class and register them to ObjectMapper via JavaTimeModule like below:

@Configuration
public class AppConfig
{
@Bean
    public ObjectMapper objectMapper()
    {
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(Include.NON_EMPTY);
        //other mapper configs
        // Customize de-serialization


        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer());
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer());
        mapper.registerModule(javaTimeModule);

        return mapper;
    }

    public class LocalDateSerializer extends JsonSerializer<LocalDate> {
        @Override
        public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            gen.writeString(value.format(Constant.DATE_TIME_FORMATTER));
        }
    }

    public class LocalDateDeserializer extends JsonDeserializer<LocalDate> {

        @Override
        public LocalDate deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            return LocalDate.parse(p.getValueAsString(), Constant.DATE_TIME_FORMATTER);
        }
    }
}
nanosoft
  • 2,913
  • 4
  • 41
  • 61
0

If your request contains an object like this:

{
    "year": 1900,
    "month": 1,
    "day": 20
}

Then you can use:

data class DateObject(
    val day: Int,
    val month: Int,
    val year: Int
)
class LocalDateConverter : StdConverter<DateObject, LocalDate>() {
    override fun convert(value: DateObject): LocalDate {
        return value.run { LocalDate.of(year, month, day) }
    }
}

Above the field:

@JsonDeserialize(converter = LocalDateConverter::class)
val dateOfBirth: LocalDate

The code is in Kotlin but this would work for Java too of course.

mowwwalker
  • 16,634
  • 25
  • 104
  • 157
-1

annotation in Pojo without using additional dependencies

@DateTimeFormat (pattern = "yyyy/MM/dd", iso = DateTimeFormat.ISO.DATE)
private LocalDate enddate;
  • 3
    Are you sure about "no additional dependencies"? I have Jackson 2.12.4 and cannot locate this annotation. – sxc731 Jul 23 '21 at 14:39