Format JSON Java 8 LocalDateTime dans Spring Boot

J'ai un petit problème avec le formatage d'un Java 8 LocalDateTime dans mon application Spring Boot. Avec les dates `` normales '', je n'ai aucun problème, mais les champs LocalDateTime sont convertis comme suit:

"startDate" : {
    "year" : 2010,
    "month" : "JANUARY",
    "dayOfMonth" : 1,
    "dayOfWeek" : "FRIDAY",
    "dayOfYear" : 1,
    "monthValue" : 1,
    "hour" : 2,
    "minute" : 2,
    "second" : 0,
    "nano" : 0,
    "chronology" : {
      "id" : "ISO",
      "calendarType" : "iso8601"
    }
  }

Alors que je voudrais le convertir en quelque chose comme:

"startDate": "2015-01-01"

Mon code ressemble à ceci:

@JsonFormat(pattern="yyyy-MM-dd")
@DateTimeFormat(iso = DateTimeFormat.ISO.TIME)
public LocalDateTime getStartDate() {
    return startDate;
}

Mais l'une ou l'autre des annotations ci-dessus ne fonctionne pas, la date continue à être formatée comme ci-dessus. Suggestions bienvenues!

mise à jour : Spring Boot 2.x ne nécessite plus cette configuration. J'ai écrit une réponse plus à jour ici .

(C'est la façon de le faire avant Spring Boot 2.x, cela pourrait être utile pour les personnes travaillant sur une ancienne version de Spring Boot)

J'ai enfin trouvé ici comment faire. Pour y remédier, j'avais besoin d'une autre dépendance:

compile("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.4.0")

En incluant cette dépendance, Spring enregistrera automatiquement un convertisseur pour celle-ci, comme décrit ici . Après cela, vous devez ajouter les éléments suivants à application.properties:

spring.jackson.serialization.write_dates_as_timestamps=false

Cela garantira qu'un convertisseur correct est utilisé et les dates seront imprimées au format 2016-03-16T13:56:39.492

Les annotations ne sont nécessaires que si vous souhaitez modifier le format de la date.

J'ai ajouté la com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.6.1dépendance et j'ai commencé à obtenir la date au format suivant:

"birthDate": [
    2016,
    1,
    25,
    21,
    34,
    55
  ]

ce n'est pas ce que je voulais mais je me rapprochais. J'ai ensuite ajouté ce qui suit

spring.jackson.serialization.write_dates_as_timestamps=false

au fichier application.properties qui m'a donné le format correct dont j'avais besoin.

"birthDate": "2016-01-25T21:34:55"

Le voici dans maven, avec la propriété pour que vous puissiez survivre entre les mises à niveau de démarrage de printemps

<dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jsr310</artifactId>
        <version>${jackson.version}</version>
</dependency>

1) Dépendance

 compile group: 'com.fasterxml.jackson.datatype', name: 'jackson-datatype-jsr310', version: '2.8.8' 

2) Annotation au format date-heure.

public class RestObject {

    private LocalDateTime timestamp;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    public LocalDateTime getTimestamp() {
        return timestamp;
    }
}

3) Spring Config.

@Configuration
public class JacksonConfig {

    @Bean
    @Primary
    public ObjectMapper objectMapper(Jackson2ObjectMapperBuilder builder) {
        System.out.println("Config is starting.");
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        return objectMapper;
    }
}

J'ai trouvé une autre solution que vous pouvez convertir dans le format de votre choix et appliquer à tous les types de données LocalDateTime et vous n'avez pas à spécifier @JsonFormat au-dessus de chaque type de données LocalDateTime. ajoutez d'abord la dépendance:

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

Ajoutez le haricot suivant:

@Configuration
public class Java8DateTimeConfiguration {
    /**
     * Customizing
     * http://docs.spring.io/spring-boot/docs/current/reference/html/howto-spring-mvc.html
     *
     * Defining a @Bean of type Jackson2ObjectMapperBuilder will allow you to customize both default ObjectMapper and XmlMapper (used in MappingJackson2HttpMessageConverter and MappingJackson2XmlHttpMessageConverter respectively).
     */
    @Bean
    public Module jsonMapperJava8DateTimeModule() {
        val bean = new SimpleModule();

        bean.addDeserializer (ZonedDateTime.class, new JsonDeserializer<ZonedDateTime>() {
            @Override
            public ZonedDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
                return ZonedDateTime.parse(jsonParser.getValueAsString(), DateTimeFormatter.ISO_ZONED_DATE_TIME);
            }
        });

        bean.addDeserializer(LocalDateTime.class, new JsonDeserializer<LocalDateTime>() {
            @Override
            public LocalDateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
                return LocalDateTime.parse(jsonParser.getValueAsString(), DateTimeFormatter.ISO_LOCAL_DATE_TIME);
            }
        });

        bean.addSerializer(ZonedDateTime.class, new JsonSerializer<ZonedDateTime>() {
            @Override
            public void serialize(
                    ZonedDateTime zonedDateTime, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
                    throws IOException {
                jsonGenerator.writeString(DateTimeFormatter.ISO_ZONED_DATE_TIME.format(zonedDateTime));
            }
        });

        bean.addSerializer(LocalDateTime.class, new JsonSerializer<LocalDateTime>() {
            @Override
            public void serialize(
                    LocalDateTime localDateTime, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
                    throws IOException {
                jsonGenerator.writeString(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(localDateTime));
            }
        });

        return bean;
    }
}

dans votre fichier de configuration, ajoutez ce qui suit:

@Import(Java8DateTimeConfiguration.class)

Cela sérialisera et dé-sérialisera toutes les propriétés LocalDateTime et ZonedDateTime tant que vous utilisez objectMapper créé par spring.

Le format que vous avez obtenu pour ZonedDateTime est: "2017-12-27T08: 55: 17.317 + 02: 00 [Asia / Jerusalem]" pour LocalDateTime est: "2017-12-27T09: 05: 30.523"

Ecrire cette réponse comme un rappel pour moi aussi.

J'ai combiné plusieurs réponses ici et à la fin la mienne a fonctionné avec quelque chose comme ça. (J'utilise SpringBoot 1.5.7 et Lombok 1.16.16)

@Data
public Class someClass {

   @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
   @JsonSerialize(using = LocalDateTimeSerializer.class)
   @JsonDeserialize(using = LocalDateTimeDeserializer.class)
   private LocalDateTime someDate;

}

Cela fonctionne bien:

Ajoutez la dépendance:

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jdk8</artifactId>
</dependency>

Ajoutez l'annotation:

@JsonFormat(pattern="yyyy-MM-dd")

Maintenant, vous devez obtenir le format correct.

Pour utiliser le mappeur d'objets, vous devez enregistrer le JavaTime

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

Comme déjà mentionné, spring-boot récupérera tout ce dont vous avez besoin (pour le démarrage web et webflux).

Mais ce qui est encore mieux: vous n'avez pas besoin d'enregistrer vous-même des modules. Jetez un œil ici . Depuis @SpringBootApplicationutilise @EnableAutoConfigurationsous le capot, cela signifie JacksonAutoConfigurationsera ajouté au contexte automatiquement. Maintenant, si vous regardez à l'intérieur JacksonAutoConfiguration, vous verrez:

    private void configureModules(Jackson2ObjectMapperBuilder builder) {
        Collection<Module> moduleBeans = getBeans(this.applicationContext,
                Module.class);
        builder.modulesToInstall(moduleBeans.toArray(new Module[0]));
    }

Ce type sera appelé dans le processus d'initialisation et récupérera tous les modules qu'il peut trouver dans le classpath. (J'utilise Spring Boot 2.1)

J'utilise Springboot 2.0.6 et pour une raison quelconque, les modifications yml de l'application n'ont pas fonctionné. Et aussi j'avais plus d'exigences.

J'ai essayé de créer ObjectMapper et de le marquer comme primaire, mais Spring Boot s'est plaint que j'avais déjà jacksonObjectMapper comme marqué Primary !!

Voilà donc ce que j'ai fait. J'ai apporté des modifications au mappeur interne.

Mon sérialiseur et mon désérialiseur sont spéciaux - ils traitent de «jj / MM / AAAA»; et lors de la désérialisation - il fait de son mieux pour utiliser le format populaire 3-4 pour s'assurer que j'ai du LocalDate.

@Autowired
ObjectMapper mapper;

@PostConstruct
public ObjectMapper configureMapper() {
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);

    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    mapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true);

    mapper.configure(MapperFeature.ALLOW_COERCION_OF_SCALARS, true);
    mapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true);

    SimpleModule module = new SimpleModule();
    module.addDeserializer(LocalDate.class, new LocalDateDeserializer());
    module.addSerializer(LocalDate.class, new LocalDateSerializer());
    mapper.registerModule(module);

    return mapper;
}

@JsonDeserialize(using= LocalDateDeserializer.class) ne fonctionne pas pour moi avec la dépendance ci-dessous.

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

J'ai utilisé le convertisseur de code ci-dessous pour désérialiser la date en un fichier java.sql.Date.

import javax.persistence.AttributeConverter;
import javax.persistence.Converter;


@SuppressWarnings("UnusedDeclaration")
@Converter(autoApply = true)
public class LocalDateConverter implements AttributeConverter<java.time.LocalDate, java.sql.Date> {


    @Override
    public java.sql.Date convertToDatabaseColumn(java.time.LocalDate attribute) {

        return attribute == null ? null : java.sql.Date.valueOf(attribute);
    }

    @Override
    public java.time.LocalDate convertToEntityAttribute(java.sql.Date dbData) {

        return dbData == null ? null : dbData.toLocalDate();
    }
}

utilisez simplement:

@JsonFormat(pattern="10/04/2019")

ou vous pouvez utiliser le modèle comme vous le souhaitez, par exemple: ('-' in place of '/')

J'utilise Spring Boot 2.1.8. J'ai importé

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-json</artifactId>
</dependency>

qui inclut le jackson-datatype-jsr310 .

Ensuite, j'ai dû ajouter ces annotations

@JsonSerialize(using = LocalDateTimeSerializer.class)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonProperty("date")
LocalDateTime getDate();

et il fonctionne. Le JSON ressemble à ceci:

"date": "2020-03-09 17:55:00"