Quelles sont les manières de gérer les dates dans SpringBoot ?

Dans Spring Boot, nous utilisons généralement Jackson pour sérialiser et désérialiser les objets Java en JSON. Lors de la sérialisation de la date, nous devons spécifier le format de la date, sinon Jackson utilisera le format par défaut, ce qui n'est peut-être pas ce que nous souhaitons. Pour spécifier le format de la date, il existe deux manières :

S'il n'y a pas de traitement, le résultat par défaut sera celui indiqué ci-dessous : Nous devons donc utiliser un moyen pour traiter la date. Voici deux manières. pour le résoudre. #🎜 🎜#

Méthode 1 : Utiliser des annotations (non recommandée)

Nous pouvons ajouter @JsonFormat() sur le attribut de date de classe d'entité et utilisez le modèle de paramètre pour formater notre exemple de format souhaité comme suit :

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

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

À ce moment, le frontal s'affichera selon le format que nous avons défini

#🎜🎜 #

#🎜 🎜#

Pour la méthode ci-dessus, nous devons ajouter l'annotation @JSONFormat à chaque date affichée sur le front-end, c'est donc très gênant, il existe donc la méthode 2. Via une exception globale manipulation.

Méthode 2 Convertisseur de messages personnalisés

Introduisez d'abord l'ObjectMapper dans le package Jackson

ObjectMapper est une classe de la bibliothèque Jackson. Les fonctions principales sont :

Sérialiser les objets Java en JSON/XML et autres formats ; Les données sont désérialisées en objets Java.

• C'est donc la clé pour réaliser la conversion entre les objets et JSON/XML.
• Ensuite, nous pouvons faire un peu de bruit dans cette classe,
  (1) Personnaliser le format de conversion de date dans le constructeur ----Cela équivaut à changer l'initialisation. valeur de ses propriétés.

(2) Grâce à la configuration, SpringMVC n'appelle plus l'ObjectMapper personnalisé de Jackson lors de l'appel et utilise notre format personnalisé

ci-dessous Nous y parvenons grâce à ces deux étapes. .

La première étape :

Hériter d'ObjectMapper, remplacer le constructeur et personnaliser la méthode de sérialisation

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

Deuxième étape : # 🎜🎜# Laissons Spring utiliser notre convertisseur de messages personnalisé

Ici, nous devons réfléchir, comment devons-nous le gérer Où le configurer Classe de configuration ? Tout d'abord, nous pouvons considérer l'intercepteur comme un élément indispensable du système, et l'intercepteur a-t-il une classe de configuration pour configurer les règles d'interception ? Alors pouvons-nous le configurer ici ?#🎜 🎜#

binggo, juste ici ? . Lorsque nous configurons la classe de configuration de l'intercepteur, nous constaterons que la classe WebMvcConfigurationSupport a de nombreuses méthodes,

Il existe notre protected void addInterceptors (registre InterceptorRegistry) { ... } Configurer les règles d'interception

public void addResourceHandlers(ResourceHandlerRegistry Registry) {... } Configurer le traitement des ressources

Il existe de nombreuses méthodes de configuration . Et notre Message Converter en fait également partie

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

En configurant les informations pertinentes dans cette méthode, vous pouvez modifier la valeur par défaut de Spring Spécifiez les règles et utilisez nos propres règles définies (. composants)

Le code est le suivant :

@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

Création d'un MappingJackson2HttpMessageConverter, qui est Spring MVC intègre le convertisseur de messages de Jackson, qui peut sérialiser/ désérialiser les objets Java en JSON.

#🎜🎜##🎜🎜##🎜🎜#Spécifiez l'utilisation de notre JacksonObjectMapper pour le convertisseur de messages, qui est utilisé pour sérialiser/désérialiser des objets Java en JSON. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Ajoutez l'objet MappingJackson2HttpMessageConverter que vous venez de créer à la liste des convertisseurs de messages, et ajoutez-le en première position en lui donnant la priorité #🎜🎜##🎜🎜 ##🎜 🎜##🎜🎜#Depuis que nous avons remplacé la méthode extendMessageConverters(), Spring MVC appellera cette méthode et utilisera le convertisseur de messages que nous avons ajouté. Par conséquent, le MappingJackson2HttpMessageConverter que nous avons ajouté prendra effet et utilisera notre JacksonObjectMapper() personnalisé pour gérer la sérialisation et la désérialisation entre les objets et JSON. #🎜🎜##🎜🎜#Parce que notre convertisseur de messages est le premier convertisseur de messages, si le client demande de renvoyer des données JSON, Spring MVC choisira notre convertisseur de messages pour la sérialisation des objets. #🎜🎜##🎜🎜#Ainsi, toutes les dates du système sont sérialisées selon le format dont nous avons besoin #🎜🎜##🎜🎜#À l'heure actuelle, les données frontales sont le format que nous avons défini. plus le format par défaut de Jackson .#🎜🎜##🎜🎜#Depuis que la date est mentionnée, il existe également un traitement similaire des informations sensibles : #🎜🎜##🎜🎜#Lorsque nous renvoyons les données frontales, nous pouvons Vous avez des problèmes en raison de la conception de la classe d'entité. Ou si vous ne voulez pas que le front-end puisse voir les données, vous devez utiliser un moyen pour traiter les données, ou deux méthodes. 🎜##🎜🎜##🎜🎜# Avant de renvoyer Remplacez la valeur, appelez la méthode set pour la définir sur informations de spam, par exemple, setPassword("******")#🎜 🎜##🎜🎜##🎜🎜##🎜🎜# est dans l'entité. Cela peut également être résolu en utilisant l'annotation @JsonIgnore fournie par Jackson dans la classe, qui consiste à ignorer la sérialisation et désérialisation des champs. #🎜🎜##🎜🎜##🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!