Welche Möglichkeiten gibt es, mit Datumsangaben in SpringBoot umzugehen?

In Spring Boot verwenden wir normalerweise Jackson, um Java-Objekte in JSON zu serialisieren und zu deserialisieren. Bei der Datumsserialisierung müssen wir das Datumsformat angeben, andernfalls verwendet Jackson das Standardformat, das möglicherweise nicht unseren Wünschen entspricht. Um das Datumsformat anzugeben, gibt es zwei Möglichkeiten:

Wenn keine Verarbeitung erfolgt, sieht das Standardergebnis wie unten gezeigt aus: Wir müssen also einige Mittel verwenden, um das Datum zu verarbeiten. Hier sind zwei Möglichkeiten um es zu lösen. #🎜 🎜#

Methode 1: Annotationen verwenden (nicht empfohlen)

Wir können @JsonFormat() hinzufügen Entitätsklassen-Datumsattribut und verwenden Sie das Parametermuster, um unser gewünschtes Formatbeispiel wie folgt zu formatieren:

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createTime;

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime updateTime;

Zu diesem Zeitpunkt wird das Frontend entsprechend dem von uns festgelegten Format

#🎜🎜 angezeigt #

#🎜 🎜#

Für die obige Methode müssen wir die Annotation @JSONFormat zu jedem im Frontend angezeigten Datum hinzufügen, was sehr problematisch ist. Daher gibt es Methode 2. Durch globale Ausnahme Handhabung.

Methode 2 Benutzerdefinierter Nachrichtenkonverter

Führen Sie zunächst den ObjectMapper im Jackson-Paket ein.

ObjectMapper ist eine Klasse in der Jackson-Bibliothek Hauptfunktionen sind:

Serialisieren Sie Java-Objekte in JSON/XML und andere Formate. Die Daten werden in Java-Objekte deserialisiert.

• Es ist also der Schlüssel zur Umsetzung der Konvertierung zwischen Objekten und JSON/XML.
• Dann können wir in dieser Klasse ein wenig Aufhebens machen,
  (1) Passen Sie das Format der Datumskonvertierung im Konstruktor an ----Es entspricht dem Ändern

(2) Durch die Konfiguration ruft SpringMVC beim Aufruf nicht mehr Jacksons benutzerdefinierten ObjectMapper auf und verwendet unser benutzerdefiniertes Format

unten. Wir erreichen dies durch diese beiden Schritte.

Der erste Schritt:

ObjectMapper erben, den Konstruktor überschreiben und die Serialisierungsmethode anpassen

public class JacksonObjectMapper extends ObjectMapper {

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    //public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

        //反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

        SimpleModule simpleModule = new SimpleModule()
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));

        //注册功能模块 例如，可以添加自定义序列化器和反序列化器
        this.registerModule(simpleModule);
    }
}

Zweiter Schritt:

Lassen Sie Spring unseren benutzerdefinierten Nachrichtenkonverter verwenden

Hier müssen wir überlegen, wie wir damit umgehen sollen. Konfigurationsdatei? #🎜🎜 #Zuallererst können wir uns den Interceptor als einen unverzichtbaren Teil des Systems vorstellen. Verfügt der Interceptor über eine Konfigurationsklasse zum Konfigurieren von Abfangregeln?#🎜 🎜#

binggo, richtig Wenn wir die Konfigurationsklasse des Interceptors konfigurieren, werden wir feststellen, dass die WebMvcConfigurationSupport-Klasse viele Methoden hat:

Es gibt unsere häufig verwendeten protected void addInterceptors (InterceptorRegistry-Registrierung) { ... Abfangregeln konfigurieren

public void addResourceHandlers(ResourceHandlerRegistry Registry) {... Ressourcenverarbeitung konfigurieren

Es gibt viele Konfigurationen Und unser Message Converter gehört auch dazu

protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {...}

Durch die Konfiguration relevanter Informationen in dieser Methode können Sie die Spring-Standardregeln ändern und unsere eigenen definierten Regeln verwenden (Komponenten)

Der Code lautet wie folgt:

@Override
protected void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
    log.info("扩展消息转换器...");
    //创建一个消息转换器对象，注意不要导错包是Jackson2Http
    MappingJackson2HttpMessageConverter converter =  new MappingJackson2HttpMessageConverter();
    //需要为消息转换器设置一个对象转换器，对象转换器可以将Java对象序列化为json数据
    converter.setObjectMapper(new JacksonObjectMapper());
    //将自己的消息转化器加入容器中
    converters.add(0, converter);
}

protected void addInterceptors(InterceptorRegistry registry) { ... } 配置拦截规则

public void addResourceHandlers(ResourceHandlerRegistry registry) {... } 配置资源处理

等等有很多配置方法.而我们的消息转换器也在其中

rrreee

通过在这个方法中配置相关信息,即可改变Spring默认指定的规则,而使用我们自己定义的规则(组件)

代码如下:

rrreee

• 创建了一个MappingJackson2HttpMessageConverter,这是Spring MVC集成Jackson的消息转换器,可以将Java对象序列化/反序列化为JSON。

• 为消息转换器指定使用我们的JacksonObjectMapper, 用来将Java对象序列化/反序列化为JSON。

• 将刚才创建的MappingJackson2HttpMessageConverter对象加入到消息转换器列表converters中,并且加入到第一个位置,让其优先使用

由于我们重写了extendMessageConverters()方法,Spring MVC会调用这个方法并使用我们添加的消息转换器。所以,我们添加的MappingJackson2HttpMessageConverter会生效,并使用我们自定义的JacksonObjectMapper(),用来处理对象与JSON之间的序列化和反序列化。

因为我们的消息转换器是第一个消息转换器,如果客户端要求返回JSON数据Spring MVC会选择我们的这个消息转换器进行对象序列化。

从而实现了对系统所有的日期按照我们要求的格式进行序列化.

此时前端数据也就是我们设置的格式.不在是Jackson默认的格式.

既然提到了日期,与之类似的还有一个对敏感信息的处理:

我们在返回前端数据的时候可能会因为实体类的设计,或者不想让前端能够看到该数据,此时就需要通过一些手段对数据进行一些处理, 还是两种方式.

• 在返回之前对数据的值进行替换, 调用set方法设置为 垃圾信息, 比如 setPassword(“******”)

• 是在实体类中使用Jackson提供的 @JsonIgnore

Erstellt einen MappingJackson2HttpMessageConverter, bei dem Spring MVC Jacksons Nachrichtenkonverter integriert, der serialisieren kann /deserialisieren Sie Java-Objekte in JSON.

#🎜🎜##🎜🎜##🎜🎜#Geben Sie die Verwendung unseres JacksonObjectMapper für den Nachrichtenkonverter an, der zum Serialisieren/Deserialisieren von Java-Objekten in JSON verwendet wird. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Fügen Sie das soeben erstellte MappingJackson2HttpMessageConverter-Objekt zu den Nachrichtenkonverter-Listenkonvertern hinzu und fügen Sie es an der ersten Position hinzu, wobei Sie ihm Priorität geben #🎜🎜##🎜🎜 ##🎜 🎜##🎜🎜#Da wir die Methode „extendMessageConverters()“ überschrieben haben, ruft Spring MVC diese Methode auf und verwendet den von uns hinzugefügten Nachrichtenkonverter. Daher wird der von uns hinzugefügte MappingJackson2HttpMessageConverter wirksam und verwendet unseren benutzerdefinierten JacksonObjectMapper(), um die Serialisierung und Deserialisierung zwischen Objekten und JSON zu handhaben. #🎜🎜##🎜🎜#Da unser Nachrichtenkonverter der erste Nachrichtenkonverter ist, wählt Spring MVC unseren Nachrichtenkonverter für die Objektserialisierung aus, wenn der Client die Rückgabe von JSON-Daten anfordert. #🎜🎜##🎜🎜#Daher werden alle Daten im System entsprechend dem von uns benötigten Format serialisiert. #🎜🎜##🎜🎜#Zu diesem Zeitpunkt sind die Front-End-Daten das von uns festgelegte Format länger das Standardformat von Jackson .#🎜🎜##🎜🎜#Da das Datum erwähnt wird, gibt es auch eine ähnliche Verarbeitung sensibler Informationen: #🎜🎜##🎜🎜#Wenn wir die Front-End-Daten zurückgeben, können wir Probleme aufgrund des Designs der Entitätsklasse haben. Oder wenn Sie nicht möchten, dass das Frontend die Daten sehen kann, müssen Sie bestimmte Mittel oder zwei Methoden verwenden, um die Daten zu verarbeiten 🎜##🎜🎜##🎜🎜# Bevor Sie den Wert ersetzen, rufen Sie die Set-Methode auf, um ihn auf Spam-Informationen festzulegen, zum Beispiel setPassword("******")#🎜 🎜##🎜🎜##🎜🎜##🎜🎜# befindet sich in der Entität. Dies kann auch durch die Verwendung der von Jackson in der Klasse bereitgestellten Annotation @JsonIgnore gelöst werden, die darin besteht, die Serialisierung zu ignorieren und Deserialisierung von Feldern. #🎜🎜##🎜🎜##🎜🎜#

Das obige ist der detaillierte Inhalt vonWelche Möglichkeiten gibt es, mit Datumsangaben in SpringBoot umzugehen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!