Wie setzen format-string für java.Zeit.Instant mit objectMapper?

Habe ich eine Entität mit java.time.Instant für erstellte Datenfeld:

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

Ich bin mit com.fasterxml.jackson.databind.ObjectMapper zu sparen Element Elasticsearch als JSON:

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

ObjectMapper serialisiert dieses Feld als Objekt:

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

Ich habe versucht die Anmerkungen @JsonFormat(shape = JsonFormat.Shape.STRING) aber es funktioniert nicht für mich.

Meine Frage ist wie könnte ich dies serialisieren Feld als 2010-05-30 22:15:52 string?

github.com/FasterXML/jackson-modules-java8/tree/master/datetime
Danke für die Antwort, ich habe objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); und objectMapper.findAndRegisterModules() Es funktioniert nicht für mich.
Haben Sie das Modul jar Datei in den classpath?
Sicher, compile group: 'com.fasterxml.jackson.module', name: 'jackson-modules-java8', version: '2.9.0', ext: 'pom' diese eine

InformationsquelleAutor Uladzislau Kaminski | 2017-08-13

23

Eine Lösung ist die Verwendung jackson-Module-java8. Dann können Sie fügen Sie ein JavaTimeModule um Ihr Objekt-mapper:
```
ObjectMapper objectMapper = new ObjectMapper();

JavaTimeModule module = new JavaTimeModule();
objectMapper.registerModule(module);
```
Standardmäßig die Instant serialisiert wird als epoch-Wert (Sekunden und Nanosekunden in eine einzelne Zahl):
```
{"createdDate":1502713067.720000000}
```
Können Sie ändern, indem Sie die Einstellung in der Objekt-mapper:
```
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
```
Dies erzeugt die Ausgabe:
```
{"createdDate":"2017-08-14T12:17:47.720Z"}
```
Beiden oben genannten Formaten sind deserialisiert ohne zusätzliche Konfiguration.

Ändern die Serialisierungs-format, fügen Sie einfach eine JsonFormat Anmerkung zum Feld:
```
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "UTC")
private Instant createdDate;
```
Müssen Sie die Zeitzone setzen, da sonst die Instant können nicht serialisiert werden, richtig (es gibt eine Ausnahme). Der Ausgang wird sein:
```
{"createdDate":"2017-08-14 12:17:47"}
```
Andere alternative, wenn Sie nicht wollen (oder können nicht) verwenden java8-Module, ist erstellen Sie eine benutzerdefinierte serializer und deserializer, mit einem 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()));
    }
}
```
Dann Sie versehen Sie das Feld mit benutzerdefinierten Klassen:
```
@JsonDeserialize(using = MyCustomDeserializer.class)
@JsonSerialize(using = MyCustomSerializer.class)
private Instant createdDate;
```
Ist die Ausgabe:
```
{"createdDate":"2017-08-14 12:17:47"}
```
Ein detail ist, dass in der serialisierten Zeichenfolge, die Sie sind, verwirft den Bruchteil der Sekunde (alles nach dem Komma). Also, wenn Deserialisieren, diese Informationen können nicht wiederhergestellt werden (es werden auf null gesetzt).

In das Beispiel oben wurde das ursprüngliche Instant ist 2017-08-14T12:17:47.720Z, aber die serialisierte Zeichenfolge ist 2017-08-14 12:17:47 (ohne den Bruchteil von Sekunden), so dass, wenn deserialisiert die daraus resultierenden Instant ist 2017-08-14T12:17:47Z (die .720 Millisekunden verloren).

Was format-string würde ich im Fall zu verwenden, ich möchte zu halten Bruchteil von Sekunden? Thx.
Einfach und auf den Punkt. Jeder Fall abgedeckt.

InformationsquelleAutor

Müssen Sie unten Abhängigkeit

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

Und dann registrieren Sie die Module wie folgt :

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

Danke, ich'found diese Lösung. Aber diese Lösung scheint veraltet
schau mal hier: baeldung.com/jackson-serialize-dates

InformationsquelleAutor dassum

Für diejenigen, die zum analysieren von Java-8-Zeitstempel. Sie benötigen eine aktuelle version von jackson-datatype-jsr310 in Ihre POM und habe Folgendes Modul eingetragen:

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

Diesen code zu testen

@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);
}

InformationsquelleAutor UltimaWeapon

Hier einige Kotlin-code zu formatieren Instant, so enthält es keine Millisekunden verwenden, können Sie benutzerdefinierte Datums-formatter

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())

InformationsquelleAutor ZZ 5

In meinem Fall war es genug, um zu registrieren, JavaTimeModule:

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

  messageObject = objectMapper.writeValueAsString(event);

In das event-Objekt habe ich ein Feld vom Typ Instant.

In der Deserialisierung müssen Sie auch, um registrieren Sie die java-Zeit Modul:

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

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

InformationsquelleAutor Laura Liparulo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.