Using Instant, LocalDateTime and ZonedDateTime with Spring Boot and ElasticSearch

Question

I'm using Spring Boot 2.1.4 and Spring Data Jest with ElasticSearch. I was initially using Java Date for some properties with the following annotation:

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern ="yyyy-MM-dd'T'HH:mm:ss.SSSZZ")

This is saved into ElasticSearch as follows:

"creationDate": "2019-04-10T14:49:05.672+0000"

Now, I am in the process of migrating from Date to LocalDateTime and ZonedDateTime. When the data is now saved to ElasticSearch, I get the following attribute saved:

"creationDate": {
    "dayOfYear": 123,
    "dayOfWeek": "FRIDAY",
    "month": "MAY",
    "dayOfMonth": 3,
    "year": 2019,
    "monthValue": 5,
    "hour": 11,
    "minute": 54,
    "second": 12,
    "nano": 238000000,
    "chronology": {
        "id": "ISO",
        "calendarType": "iso8601"
    }
},

What do I need to do to change it so I get the same ElasticSearch data format as before for LocalDateTime and ZonedDateTime?

I have tried the following:

1. Customising the object mapper as follows:

   public class CustomEntityMapper implements EntityMapper {
       private final ObjectMapper objectMapper;
   
       public CustomEntityMapper(ObjectMapper objectMapper) {  
           this.objectMapper = new ObjectMapper();
           objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
           objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
           objectMapper.registerModule(new CustomGeoModule());
           objectMapper.registerModule(new JavaTimeModule());
       }
   
       @Override
       public String mapToString(Object object) throws IOException {
           return objectMapper.writeValueAsString(object);
       }
   
       @Override
       public <T> T mapToObject(String source, Class<T> clazz) throws IOException {
           return objectMapper.readValue(source, clazz);
       }
   }
   

2. Adding the following to object mapper:

   objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
   

Any help or pointers where I'm going wrong would be appreciated.

Answer 1

Managed to get it to work with Spring Boot 2.1.4 and Spring Data Jest. Here is what I did:

1. Example domain object:

   @Document(indexName = "datetest")
   public class DateTest {
   
       @Id
       private String id;
   
       @Field(type = FieldType.Date, format = DateFormat.custom, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZZ")
       @JsonFormat(shape = JsonFormat.Shape.STRING, pattern ="yyyy-MM-dd'T'HH:mm:ss.SSSZZ", timezone = "UTC")
       private Instant instant = Instant.now();
   
       @Field(type = FieldType.Date, format = DateFormat.custom, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSSZZ")
       @JsonFormat(shape = JsonFormat.Shape.STRING, pattern ="yyyy-MM-dd'T'HH:mm:ss.SSSZZ")
       private ZonedDateTime zonedDateTime = ZonedDateTime.now();
   
       @Field(type = FieldType.Date, format = DateFormat.custom, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS")
       @JsonFormat(shape = JsonFormat.Shape.STRING, pattern ="yyyy-MM-dd'T'HH:mm:ss.SSS")
       private LocalDateTime localDateTime = LocalDateTime.now();
   
       // getters/setters
   }
   

2. The ElasticSearch/JEST config:

   @Configuration
   public class ESConfig {
   
       @Bean
       public EntityMapper getEntityMapper() {
           return new CustomEntityMapper();
       }
   
       @Bean
       @Primary
       public ElasticsearchOperations elasticsearchTemplate(final JestClient jestClient,
               final ElasticsearchConverter elasticsearchConverter,
               final SimpleElasticsearchMappingContext simpleElasticsearchMappingContext, EntityMapper mapper) {
           return new JestElasticsearchTemplate(jestClient, elasticsearchConverter,
                   new DefaultJestResultsMapper(simpleElasticsearchMappingContext, mapper));
       }
   
       public class CustomEntityMapper implements EntityMapper {
   
           private final ObjectMapper objectMapper;
   
           public CustomEntityMapper() {
               objectMapper = new ObjectMapper();
               objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
               objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
               objectMapper.registerModule(new CustomGeoModule());
               objectMapper.registerModule(new JavaTimeModule());
           }
   
           @Override
           public String mapToString(Object object) throws IOException {
               return objectMapper.writeValueAsString(object);
           }
   
           @Override
           public <T> T mapToObject(String source, Class<T> clazz) throws IOException {
               return objectMapper.readValue(source, clazz);
           }
   
       }
   }
   

3. The results in ElasticSearch:

   

Hope this helps.

Answer 2

That's because spring-data-jest uses DefaultEntityMapper (part of Spring Data), which creates its own ObjectMapper and doesn't use the one provided by Spring boot. This can be seen in this related question.

You're on the right track with your solution by defining your own EntityMapper, for example CustomEntityMapper. However, spring-data-jest wraps this mapper into a class called DefaultJestResultsMapper, which is then used by a bean called JestElasticsearchTemplate.

So, probably you should do something like this:

@Bean
public JestResultsMapper resultMapper(CustomEntityMapper entityMapper) {
    return new DefaultJestResultsMapper(entityMapper);
}

@Bean
public JestElasticSearchTemplate template(JestClient client, JestResultsMapper resultsMapper) {
    return new JestElasticSearchTemplate(client, resultsMapper);
}

This should inject your CustomEntityMapper into a JestResultsMapper, which is in turn injected into JestElasticSearchTemplate used by the framework.

Within CustomEntityMapper you can either autowire the default ObjectMapper (which will automatically add the JavaTimeModule) or you can configure one on your own.

Answer 3

According to this answer from version 2 of Spring Boot,it should work out of the box as you want in terms of producing string from java.time objects

If you have

com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.4.0

as dependency and below line in application.properties

spring.jackson.serialization.write_dates_as_timestamps=false

So only thing left would be to add timezone notation to default string which won't have it.

If standard formatters won't work for you may always write your own serialiser/deserialiser and attach it like explained here