How to configure serialization in springboot in Dongba District

Use SpringBoot default configuration

SpringBoot uses UTC time by default. If we need to use East Eighth District time, we can use the following configuration:

spring:
  jackson:
    time-zone: GMT+8

This method is the simplest method. Any additional dependencies and code are required, but it should be noted that this configuration is globally effective and may affect other places that need to use UTC time, and this needs to be checked again every time a new dependency is added, the SpringBoot version is upgraded, etc. Is the configuration correct?

Custom configuration class

Another way is to customize the configuration class, use the @Configuration annotation to create a configuration class, and then configure the Jackson2ObjectMapperBuilderCustomizer in the class, specifying the time zone as the East Eighth District.

@Configuration
public class JacksonConfiguration {

    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
        return builder -> builder.timeZone(TimeZone.getTimeZone("GMT+8"));
    }
}

This method requires custom code, but it can more flexibly control the range of East Eighth District time, and will not affect other places that need to use UTC time. It should be noted that every time you add a new dependency or upgrade the SpringBoot version, you must re-confirm whether the configuration is correct.

Customized ObjectMapper

You can also use the East Eighth District time by customizing Jackson's ObjectMapper.

The specific implementation method is to set a custom JavaTimeModule on the ObjectMapper, and then set the time zone on the module to Dongba District.

The sample code is as follows:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

public class CustomObjectMapper extends ObjectMapper {
    public CustomObjectMapper() {
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        this.registerModule(javaTimeModule);
        this.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
    }
}

In the above example, we created a CustomObjectMapper that inherits from ObjectMapper and registered a custom JavaTimeModule on the object. The sequence of the module LocalDateTimeSerializer and LocalDateTimeDeserializer are used in the deserialization and deserialization methods respectively, and the time zone is set to Asia/Shanghai. You can also add other time serialization and deserialization methods as needed.

Use the custom CustomObjectMapper object in the code for serialization and deserialization to use the East Eighth District time. For example:

CustomObjectMapper objectMapper = new CustomObjectMapper();
String jsonString = objectMapper.writeValueAsString(yourObject);
YourObject deserializedObject = objectMapper.readValue(jsonString, YourObject.class);

It is worth noting that if you need to use a custom ObjectMapper in Spring Boot, you need to make relevant configurations in the configuration class:

@Configuration
public class JacksonConfig {

    @Bean
    public ObjectMapper objectMapper() {
        return new CustomObjectMapper();
    }
}

After this configuration, in the code Use @Autowired to inject the ObjectMapper object

Custom serializer

One way to customize the serializer is to convert the time to East Eighth District time and serialize use it during the process. Implement the JsonSerializer interface to specify the serializer in the @JsonSerialize annotation. The specific code is as follows:

public class ChinaZoneDateTimeSerializer extends JsonSerializer<ZonedDateTime> {

    @Override
    public void serialize(ZonedDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeString(value.withZoneSameInstant(ZoneId.of("GMT+8")).format(DateTimeFormatter.ISO_OFFSET_DATE_TIME));
    }
}

Then use the @JsonSerialize annotation on the time field of the object that needs to be serialized to specify the serializer.

@JsonSerialize(using = ChinaZoneDateTimeSerializer.class)
private ZonedDateTime createTime;

This method can control the time format and conversion logic more flexibly, but it requires custom code, and the @JsonSerialize annotation needs to be added to each time field that needs to be converted, which has a certain degree of code intrusion. .

The above is the detailed content of How to configure serialization in springboot in Dongba District. For more information, please follow other related articles on the PHP Chinese website!