Datumsformat Zuordnung zu JSON Jackson

Ich habe ein Datumsformat von der API wie folgt:

"start_time": "2015-10-1 3:00 PM GMT+1:00"

Welches ist JJJJ-TT-MM HH: MM am / pm GMT Zeitstempel. Ich ordne diesen Wert einer Datumsvariablen in POJO zu. Offensichtlich zeigt es Konvertierungsfehler.

Ich möchte 2 Dinge wissen:

1. Welche Formatierung muss ich verwenden, um die Konvertierung mit Jackson durchzuführen? Ist Datum ein guter Feldtyp dafür?
2. Gibt es im Allgemeinen eine Möglichkeit, die Variablen zu verarbeiten, bevor sie von Jackson Objektmitgliedern zugeordnet werden? So etwas wie das Ändern des Formats, der Berechnungen usw.

Welche Formatierung muss ich verwenden, um die Konvertierung mit Jackson durchzuführen? Ist Datum ein guter Feldtyp dafür?

Dateist ein feiner Feldtyp dafür. Sie können die JSON-Analyse ziemlich einfach machen, indem Sie Folgendes verwenden ObjectMapper.setDateFormat:

DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm a z");
myObjectMapper.setDateFormat(df);

Gibt es im Allgemeinen eine Möglichkeit, die Variablen zu verarbeiten, bevor sie von Jackson Objektmitgliedern zugeordnet werden? So etwas wie das Ändern des Formats, der Berechnungen usw.

Ja. Sie haben einige Optionen, einschließlich der Implementierung einer benutzerdefinierten Option JsonDeserializer, z JsonDeserializer<Date>. B. Erweiterung . Dies ist ein guter Anfang.

Seit Jackson v2.0 können Sie die Annotation @JsonFormat direkt für Objektmitglieder verwenden.

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm a z")
private Date date;

Natürlich gibt es eine automatisierte Methode namens Serialisierung und Deserialisierung, die Sie mit bestimmten Anmerkungen ( @JsonSerialize , @JsonDeserialize ) definieren können, wie auch von pb2q erwähnt.

Sie können sowohl java.util.Date als auch java.util.Calendar ... und wahrscheinlich auch JodaTime verwenden.

Die @ JsonFormat-Annotationen funktionierten bei mir nicht wie gewünscht ( die Zeitzone wurde auf einen anderen Wert eingestellt) während der Deserialisierung (die Serialisierung funktionierte perfekt):

@JsonFormat(locale = "hu", shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm", timezone = "CET")

@JsonFormat(locale = "hu", shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm", timezone = "Europe/Budapest")

Sie müssen einen benutzerdefinierten Serializer und einen benutzerdefinierten Deserializer anstelle der Annotation @JsonFormat verwenden, wenn Sie ein vorhergesagtes Ergebnis wünschen. Ich habe hier ein wirklich gutes Tutorial und eine Lösung gefunden http://www.baeldung.com/jackson-serialize-dates

Es gibt Beispiele für Datum Felder aber ich brauchte für Kalender Felder so hier ist meine Umsetzung :

Die Serializer- Klasse:

public class CustomCalendarSerializer extends JsonSerializer<Calendar> {

    public static final SimpleDateFormat FORMATTER = new SimpleDateFormat("yyyy-MM-dd HH:mm");
    public static final Locale LOCALE_HUNGARIAN = new Locale("hu", "HU");
    public static final TimeZone LOCAL_TIME_ZONE = TimeZone.getTimeZone("Europe/Budapest");

    @Override
    public void serialize(Calendar value, JsonGenerator gen, SerializerProvider arg2)
            throws IOException, JsonProcessingException {
        if (value == null) {
            gen.writeNull();
        } else {
            gen.writeString(FORMATTER.format(value.getTime()));
        }
    }
}

Die Deserializer- Klasse:

public class CustomCalendarDeserializer extends JsonDeserializer<Calendar> {

    @Override
    public Calendar deserialize(JsonParser jsonparser, DeserializationContext context)
            throws IOException, JsonProcessingException {
        String dateAsString = jsonparser.getText();
        try {
            Date date = CustomCalendarSerializer.FORMATTER.parse(dateAsString);
            Calendar calendar = Calendar.getInstance(
                CustomCalendarSerializer.LOCAL_TIME_ZONE, 
                CustomCalendarSerializer.LOCALE_HUNGARIAN
            );
            calendar.setTime(date);
            return calendar;
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

und die Verwendung der oben genannten Klassen:

public class CalendarEntry {

    @JsonSerialize(using = CustomCalendarSerializer.class)
    @JsonDeserialize(using = CustomCalendarDeserializer.class)
    private Calendar calendar;

    // ... additional things ...
}

Unter Verwendung dieser Implementierung ergibt die Ausführung des Serialisierungs- und Deserialisierungsprozesses nacheinander den Ursprungswert.

Nur mit der Annotation @JsonFormat liefert die Deserialisierung ein anderes Ergebnis. Ich denke, aufgrund der Standardeinstellung für die interne Zeitzone der Bibliothek können Sie diese mit den Annotationsparametern nicht ändern (das war auch meine Erfahrung mit den Versionen Jackson Library 2.5.3 und 2.6.3).

Nur ein vollständiges Beispiel für eine Spring-Boot- Anwendung im RFC3339Datetime-Format

package bj.demo;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;

import java.text.SimpleDateFormat;

/**
 * Created by BaiJiFeiLong@gmail.com at 2018/5/4 10:22
 */
@SpringBootApplication
public class BarApp implements ApplicationListener<ApplicationReadyEvent> {

    public static void main(String[] args) {
        SpringApplication.run(BarApp.class, args);
    }

    @Autowired
    private ObjectMapper objectMapper;

    @Override
    public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX"));
    }
}

Hinzufügen von Zeichen wie T und Z zu Ihrem Datum

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss'Z'")
private Date currentTime;

Ausgabe

{
    "currentTime": "2019-12-11T11:40:49Z"
}

Ich arbeite für mich. SpringBoot.

 import com.alibaba.fastjson.annotation.JSONField;

 @JSONField(format = "yyyy-MM-dd HH:mm:ss")  
 private Date createTime;

Ausgabe:

{ 
   "createTime": "2019-06-14 13:07:21"
}

Aufbauend auf der sehr hilfreichen Antwort von @ miklov-kriven hoffe ich, dass sich diese beiden zusätzlichen Überlegungen für jemanden als hilfreich erweisen:

(1) Ich finde es eine gute Idee, Serializer und De-Serializer als statische innere Klassen in dieselbe Klasse aufzunehmen. Hinweis: Verwenden von ThreadLocal für die Thread-Sicherheit von SimpleDateFormat.

public class DateConverter {

    private static final ThreadLocal<SimpleDateFormat> sdf = 
        ThreadLocal.<SimpleDateFormat>withInitial(
                () -> {return new SimpleDateFormat("yyyy-MM-dd HH:mm a z");});

    public static class Serialize extends JsonSerializer<Date> {
        @Override
        public void serialize(Date value, JsonGenerator jgen SerializerProvider provider) throws Exception {
            if (value == null) {
                jgen.writeNull();
            }
            else {
                jgen.writeString(sdf.get().format(value));
            }
        }
    }

    public static class Deserialize extends JsonDeserializer<Date> {
        @Overrride
        public Date deserialize(JsonParser jp, DeserializationContext ctxt) throws Exception {
            String dateAsString = jp.getText();
            try {
                if (Strings.isNullOrEmpty(dateAsString)) {
                    return null;
                }
                else {
                    return new Date(sdf.get().parse(dateAsString).getTime());
                }
            }
            catch (ParseException pe) {
                throw new RuntimeException(pe);
            }
        }
    }
}

(2) Alternativ zur Verwendung von Annotationen @JsonSerialize und @JsonDeserialize für jedes einzelne Klassenmitglied können Sie auch die Standard-Serialisierung von Jackson überschreiben, indem Sie die benutzerdefinierte Serialisierung auf Anwendungsebene anwenden. Dies bedeutet, dass alle Klassenmitglieder vom Typ Datum von Jackson serialisiert werden Verwenden dieser benutzerdefinierten Serialisierung ohne explizite Anmerkung für jedes Feld. Wenn Sie beispielsweise Spring Boot verwenden, haben Sie folgende Möglichkeiten:

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public Module customModule() {
        SimpleModule module = new SimpleModule();
        module.addSerializer(Date.class, new DateConverter.Serialize());
        module.addDeserializer(Date.class, new Dateconverter.Deserialize());
        return module;
    }
}

Wenn jemand Probleme mit der Verwendung eines benutzerdefinierten Datumsformats für java.sql.Date hat, ist dies die einfachste Lösung:

ObjectMapper mapper = new ObjectMapper();
SimpleModule module = new SimpleModule();
module.addSerializer(java.sql.Date.class, new DateSerializer());
mapper.registerModule(module);

(Diese SO-Antwort hat mir viel Ärger erspart: https://stackoverflow.com/a/35212795/3149048 )

Jackson verwendet den SqlDateSerializer standardmäßig für java.sql.Date. Derzeit berücksichtigt dieser Serializer jedoch nicht das Datumsformat. Weitere Informationen finden Sie in diesem Problem: https://github.com/FasterXML/jackson-databind/issues/1407 . Die Problemumgehung besteht darin, einen anderen Serializer für java.sql.Date zu registrieren, wie im Codebeispiel gezeigt.

Ich möchte darauf hinweisen, dass das Setzen eines SimpleDateFormatähnlichen wie in der anderen Antwort beschriebenen nur für ein funktioniert, von java.util.Datedem ich annehme, dass es in der Frage gemeint ist. Aber für java.sql.Dateden Formatierer funktioniert das nicht. In meinem Fall war es nicht sehr offensichtlich, warum der Formatierer nicht funktionierte, da in dem Modell, das serialisiert werden sollte, das Feld tatsächlich a war java.utl.Date, das eigentliche Objekt jedoch a java.sql.Date. Dies ist möglich, weil

public class java.sql extends java.util.Date

Das ist also tatsächlich gültig

java.util.Date date = new java.sql.Date(1542381115815L);

Wenn Sie sich also fragen, warum Ihr Datumsfeld nicht richtig formatiert ist, stellen Sie sicher, dass das Objekt wirklich ein Objekt ist java.util.Date .

Hier wird auch erwähnt, warum die Handhabung java.sql.Datenicht hinzugefügt wird.

Dies würde dann die Veränderung brechen, und ich denke nicht, dass dies gerechtfertigt ist. Wenn wir von vorne anfangen würden, würde ich der Änderung zustimmen, aber da die Dinge nicht so sehr sind.