Comment définir le format de la chaîne de java.temps.Instantanée à l'aide de objectMapper?

J'ai une entité avec java.time.Instant pour créé champ de données:

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
public class Item {
    private String id;
    private String url;
    private Instant createdDate;
}

Je suis en utilisant com.fasterxml.jackson.databind.ObjectMapper pour enregistrer l'élément à Elasticsearch comme JSON:

bulkRequestBody.append(objectMapper.writeValueAsString(item));

ObjectMapper sérialise ce domaine comme un objet:

"createdDate": {
    "epochSecond": 1502643595,
    "nano": 466000000
}

J'ai essayé de l'annotation @JsonFormat(shape = JsonFormat.Shape.STRING) mais il ne fonctionne pas pour moi.

Ma question est comment je peut sérialiser ce domaine 2010-05-30 22:15:52 chaîne?

github.com/FasterXML/jackson-modules-java8/tree/master/datetime
Merci pour la réponse, j'ai ajouté objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); et objectMapper.findAndRegisterModules() Il ne fonctionne pas pour moi.
Avez-vous ajouté le module fichier jar au classpath?
Bien sûr, compile group: 'com.fasterxml.jackson.module', name: 'jackson-modules-java8', version: '2.9.0', ext: 'pom' ce un

OriginalL'auteur Uladzislau Kaminski | 2017-08-13

23

Une solution consiste à utiliser jackson-modules-java8. Vous pouvez ensuite ajouter un JavaTimeModule à votre objet mappeur:
```
ObjectMapper objectMapper = new ObjectMapper();

JavaTimeModule module = new JavaTimeModule();
objectMapper.registerModule(module);
```
Par défaut, le Instant est sérialisé comme à l'époque de valeur (en secondes et nanosecondes dans un nombre simple):
```
{"createdDate":1502713067.720000000}
```
Vous pouvez changer cela en définissant dans l'objet du mappeur:
```
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
```
Ce produit le résultat:
```
{"createdDate":"2017-08-14T12:17:47.720Z"}
```
Les deux formats ci-dessus sont désérialisé sans aucune configuration supplémentaire.

Pour changer le format de sérialisation, il suffit d'ajouter un JsonFormat annotation pour le domaine:
```
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "UTC")
private Instant createdDate;
```
Vous avez besoin de régler le fuseau horaire, sinon le Instant ne peut pas être sérialisé correctement (elle lève une exception). La sortie sera:
```
{"createdDate":"2017-08-14 12:17:47"}
```
Une autre alternative, si vous ne voulez pas (ou ne pouvez pas) utiliser java8 modules, est de créer un personnalisé sérialiseur et deserializer, à l'aide d'un java.time.format.DateTimeFormatter:
```
public class MyCustomSerializer extends JsonSerializer<Instant> {

    private DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").withZone(ZoneOffset.UTC);

    @Override
    public void serialize(Instant value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
        String str = fmt.format(value);

        gen.writeString(str);
    }
}

public class MyCustomDeserializer extends JsonDeserializer<Instant> {

    private DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").withZone(ZoneOffset.UTC);

    @Override
    public Instant deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        return Instant.from(fmt.parse(p.getText()));
    }
}
```
Alors vous annoter le terrain avec ceux des classes personnalisées:
```
@JsonDeserialize(using = MyCustomDeserializer.class)
@JsonSerialize(using = MyCustomSerializer.class)
private Instant createdDate;
```
La sortie sera:
```
{"createdDate":"2017-08-14 12:17:47"}
```
Un détail, c'est que dans la chaîne sérialisée par un rejet de la fraction de seconde (tout ce qui est après la virgule). Ainsi, lors de la désérialisation, cette information ne peut pas être récupéré (il va être mis à zéro).

Dans l'exemple ci-dessus, l'original Instant est 2017-08-14T12:17:47.720Z, mais la chaîne sérialisée est 2017-08-14 12:17:47 (sans la fraction de secondes), donc quand désérialisé l'résultant Instant est 2017-08-14T12:17:47Z (le .720 millisecondes sont perdus).

Quel est le format de la chaîne aurais-je à utiliser dans le cas où je voudrais garder fraction de secondes? Thx.
Simple et au point. Tous les cas couverts.

OriginalL'auteur

Vous devez ajouter en dessous de la dépendance

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

Puis d'enregistrer les modules comme ci-dessous :

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.findAndRegisterModules();

Merci, je'found cette solution. Mais cette solution semble être obsolète
jetez un oeil ici: baeldung.com/jackson-serialize-dates

OriginalL'auteur dassum

Pour ceux qui cherchent à analyser Java 8 horodateurs. Vous avez besoin d'une version récente de jackson-datatype-jsr310 dans votre POM et ont le module suivant inscrit:

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.registerModule(new JavaTimeModule());
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

Pour tester ce code

@Test
void testSeliarization() throws IOException {
    String expectedJson = "{\"parseDate\":\"2018-12-04T18:47:38.927Z\"}";
    MyPojo pojo = new MyPojo(ZonedDateTime.parse("2018-12-04T18:47:38.927Z"));

    //serialization
    assertThat(objectMapper.writeValueAsString(pojo)).isEqualTo(expectedJson);

    //deserialization
    assertThat(objectMapper.readValue(expectedJson, MyPojo.class)).isEqualTo(pojo);
}

OriginalL'auteur UltimaWeapon

Voici quelques Kotlin code de mise en forme Instant, de sorte qu'il ne contient pas de millisecondes, vous pouvez utiliser de date personnalisé formateurs

ObjectMapper().apply {
        val javaTimeModule = JavaTimeModule()
        javaTimeModule.addSerializer(Instant::class.java, Iso8601WithoutMillisInstantSerializer())
        registerModule(javaTimeModule)
        disable(WRITE_DATES_AS_TIMESTAMPS)
    }

private class Iso8601WithoutMillisInstantSerializer
        : InstantSerializer(InstantSerializer.INSTANCE, false, DateTimeFormatterBuilder().appendInstant(0).toFormatter())

OriginalL'auteur ZZ 5

Dans mon cas, c'était assez pour inscrire le JavaTimeModule:

  ObjectMapper objectMapper = new ObjectMapper();
  JavaTimeModule module = new JavaTimeModule();
  objectMapper.registerModule(module);

  messageObject = objectMapper.writeValueAsString(event);

De l'Objet d'événement, j'ai un champ de type Instantané.

Dans la désérialisation vous devez également enregistrer le java module:

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

Event event = objectMapper.readValue(record.value(), Event.class);

OriginalL'auteur Laura Liparulo

Vous devez vous connecter pour publier un commentaire.