jackson---SpringBoot2.x 3

阅读数:0次 2021-01-04

字数统计: 7.9k字 | 阅读时长≈ 37分

SpringMVC的HTTP序列化和反序列化核心是HttpMessageConverter，在SSM项目中，我们需要在xml配置文件中注入MappingJackson2HttpMessageConverter。告诉SpringMVC我们需要JSON格式的转换。

Jackson

一、[SpringBoot2.x]-Jackson在HttpMessageConverter（消息转换器）中的使用

1、简介

在SpringMVC中配置消息转换器和三方消息转换器如代码1所示：

1	代码1：SpringMVC中配置MappingJackson2HttpMessageConverter

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
  <property name="messageConverters">
   <list >
      <ref bean="mappingJacksonHttpMessageConverter" />
   </list>
  </property>
 </bean>
 <bean id="mappingJacksonHttpMessageConverter"
  class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
  <property name="supportedMediaTypes">
   <list>
    <value>text/html;charset=UTF-8</value>
   </list>
  </property>
 </bean>

我们使用的@RequestBody和@ResponseBody注解，他们的作用就是将报文反序列化/序列化POJO对象。在请求时SpringMVC会在请求头中寻找contentType参数，然后去匹配能够处理这种类型的消息转换器。而在返回数据时，SpringMVC根据请求头的Accept属性，再将对象转换成响应报文。

针对于JSON这个结构，Spring默认使用Jackson来进行序列化和反序列化。在SpringBoot中会将MappingJackson2HttpMessageConverter自动装载到IOC容器中。

1	源码：org.springframework.http.converter.json.MappingJackson2HttpMessageConverter

@Configuration
@ConditionalOnClass(ObjectMapper.class)
@ConditionalOnBean(ObjectMapper.class)
@ConditionalOnProperty(name = HttpMessageConvertersAutoConfiguration.PREFERRED_MAPPER_PROPERTY,
        havingValue = "jackson", matchIfMissing = true)
protected static class MappingJackson2HttpMessageConverterConfiguration {

    @Bean
    @ConditionalOnMissingBean(value = MappingJackson2HttpMessageConverter.class,
            ignoredType = { "org.springframework.hateoas.mvc.TypeConstrainedMappingJackson2HttpMessageConverter",
                    "org.springframework.data.rest.webmvc.alps.AlpsJsonHttpMessageConverter" })
    public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter(ObjectMapper objectMapper) {
        return new MappingJackson2HttpMessageConverter(objectMapper);
    }

}

而ObjectMapper参数是Spring容器中的bean，当我们使用默认的配置对/testDate进行http访问时。

测试代码

@RequestMapping("testDate")
@ResponseBody
public User getDateAndLocalDateTime(){
    User user=new User();
    user.setDate(new Date());
    user.setLocalDateTime(LocalDateTime.now());
    user.setUId("001");
    return user;
}
/**
 * 静态内部类，只在该类中使用
 */
@Data
static class User{

    private String uId;
    private Date date;
    private LocalDateTime localDateTime;
}

16013479-cd39ea24234bc901

正常配置.png

由上图所示，返回参数通过@ResponseBody注解进行了消息转换最终转化为了JSON串。实际上是借助了MappingJackson2HttpMessageConverter来完成的。

2. 自定义输出响应内容

MappingJackson2HttpMessageConverter借助的是Jackson来完成序列化，那么若是可以修改Jackson的配置，便可自定义输出响应内容。

对于Date或者LocalDateTime类型，我们希望按照yyyy-MM-dd HH:mm:ss格式输出。

借着我们对ObjectMapper进行功能加强(设置时间类序列化格式)。注意：该段代码并未覆盖SpringBoot自动装配的ObjectMapper对象，而是加强其配置。详情请参考——SpringBoot2.x下的ObjectMapper配置原理

@Bean
 public Jackson2ObjectMapperBuilderCustomizer customJackson() {
     return jacksonObjectMapperBuilder -> {
         //若POJO对象的属性值为null，序列化时不进行显示
         jacksonObjectMapperBuilder.serializationInclusion(JsonInclude.Include.NON_NULL);
         
         //针对于Date类型，文本格式化
         jacksonObjectMapperBuilder.simpleDateFormat("yyyy-MM-dd HH:mm:ss");

         //针对于JDK新时间类。序列化时带有T的问题，自定义格式化字符串
         JavaTimeModule javaTimeModule = new JavaTimeModule();
         javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
         javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
         jacksonObjectMapperBuilder.modules(javaTimeModule);

     };
 }

再次请求，可以看到，得到的结果如下图所示。我们已经改变@ResponseBody对返回对象序列化的格式输出。

16013479-a6f1561689e0a73a

@ResponseBody特定的序列化格式.png

二、Spring容器中ObjectMapper

上文说到，SpringBoot2.x会自动装载MappingJackson2HttpMessageConverter进行消息转换。而MappingJackson2HttpMessageConverter会获取Spring容器中的ObjectMapper配置，来进行Jackson的序列化和反序列化。

注意：在SpringBoot2.x环境下，不要将自定义的ObjectMapper对象放入Spring容器！这样会将原有的ObjectMapper配置覆盖。

ObjectMapper是JSON操作的核心，Jackson的JSON操作都是在ObjectMapper中实现的。

1. SpringBoot2.x中的ObjectMapper

SpringBoot2.x默认装载了ObjectMapper到Spring容器，在yml配置文件中使用spring.jackson为前缀的配置可以修改，也可以在代码中实现Jackson2ObjectMapperBuilderCustomizer接口去修改ObjectMapper配置。

@Configuration
//注解通俗的说就是Spring工程中引用了Jackson的包 才会构建这个bean
@ConditionalOnClass(ObjectMapper.class)
public class JacksonAutoConfiguration {
    //默认的feature配置
    private static final Map<?, Boolean> FEATURE_DEFAULTS;
    //SpringBoot2.x配置WRITE_DATES_AS_TIMESTAMPS=false，即Date日期不会转换为时间戳类型
    static {
        Map<Object, Boolean> featureDefaults = new HashMap<>();
        featureDefaults.put(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        FEATURE_DEFAULTS = Collections.unmodifiableMap(featureDefaults);
    }

    @Bean
    public JsonComponentModule jsonComponentModule() {
        return new JsonComponentModule();
    }

    @Configuration
    @ConditionalOnClass(Jackson2ObjectMapperBuilder.class)
    static class JacksonObjectMapperConfiguration {
        @Bean
        @Primary
        //若自定义ObjectMapper放入Spring容器中，该配置不会生效！
        @ConditionalOnMissingBean
        //获取Spring容器中的Jackson2ObjectMapperBuilder 。
        public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
            return builder.createXmlMapper(false).build();
        }
    }

    @Configuration
    @ConditionalOnClass(Jackson2ObjectMapperBuilder.class)
    static class JacksonObjectMapperBuilderConfiguration {

        private final ApplicationContext applicationContext;

        JacksonObjectMapperBuilderConfiguration(ApplicationContext applicationContext) {
            this.applicationContext = applicationContext;
        }

        @Bean
        //若自定义配置Jackson2ObjectMapperBuilder 对象，那么该配置不会生效
        @ConditionalOnMissingBean
        //List<Jackson2ObjectMapperBuilderCustomizer>会读取Spring容器中所有
        //Jackson2ObjectMapperBuilderCustomizer子类Bean，并按照order优先级进行排序。
        public Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder(
                List<Jackson2ObjectMapperBuilderCustomizer> customizers) {
            Jackson2ObjectMapperBuilder builder = new Jackson2ObjectMapperBuilder();
            builder.applicationContext(this.applicationContext);
            //按照order读取所有自定义的Jackson2ObjectMapperBuilderCustomizer 对象。
            customize(builder, customizers);
            return builder;
        }
        //调用子类实现customize方法定制Jackson2ObjectMapperBuilder 对象
        private void customize(Jackson2ObjectMapperBuilder builder,
                List<Jackson2ObjectMapperBuilderCustomizer> customizers) {
            for (Jackson2ObjectMapperBuilderCustomizer customizer : customizers) {
                customizer.customize(builder);
            }
        }

    }
    //SpringBoot2.x提供的修改ObjectMapper的配置类，可以在配置文件中修改配置。
    @Configuration
    @ConditionalOnClass(Jackson2ObjectMapperBuilder.class)
    //配置以`spring.jackson`作为前缀。
    @EnableConfigurationProperties(JacksonProperties.class)
    static class Jackson2ObjectMapperBuilderCustomizerConfiguration {

        @Bean
        public StandardJackson2ObjectMapperBuilderCustomizer standardJacksonObjectMapperBuilderCustomizer(
                ApplicationContext applicationContext,
                JacksonProperties jacksonProperties) {
            return new StandardJackson2ObjectMapperBuilderCustomizer(applicationContext,
                    jacksonProperties);
        }

        static final class StandardJackson2ObjectMapperBuilderCustomizer
                implements Jackson2ObjectMapperBuilderCustomizer, Ordered {

            private final ApplicationContext applicationContext;
            //配置文件中的属性
            private final JacksonProperties jacksonProperties;

            StandardJackson2ObjectMapperBuilderCustomizer(
                    ApplicationContext applicationContext,
                    JacksonProperties jacksonProperties) {
                this.applicationContext = applicationContext;
                this.jacksonProperties = jacksonProperties;
            }
            //优先级为0，若我们想自定义实现StandardJackson2ObjectMapperBuilderCustomizer类，那么order优先级要大于0
            @Override
            public int getOrder() {
                return 0;
            }
            //根据配置去定制builder对象
            @Override
            public void customize(Jackson2ObjectMapperBuilder builder) {

                if (this.jacksonProperties.getDefaultPropertyInclusion() != null) {
                    builder.serializationInclusion(
                            this.jacksonProperties.getDefaultPropertyInclusion());
                }
                if (this.jacksonProperties.getTimeZone() != null) {
                    builder.timeZone(this.jacksonProperties.getTimeZone());
                }
               //设置序列化和反序列化的特征
                configureFeatures(builder, FEATURE_DEFAULTS);
                configureVisibility(builder, this.jacksonProperties.getVisibility());
                configureFeatures(builder, this.jacksonProperties.getDeserialization());
                configureFeatures(builder, this.jacksonProperties.getSerialization());
                configureFeatures(builder, this.jacksonProperties.getMapper());
                configureFeatures(builder, this.jacksonProperties.getParser());
                configureFeatures(builder, this.jacksonProperties.getGenerator());
                configureDateFormat(builder);
                //设置序列化的命名策略
                configurePropertyNamingStrategy(builder);
                configureModules(builder);
                configureLocale(builder);
            }

            private void configureFeatures(Jackson2ObjectMapperBuilder builder,
                    Map<?, Boolean> features) {
                features.forEach((feature, value) -> {
                    if (value != null) {
                        if (value) {
                            builder.featuresToEnable(feature);
                        }
                        else {
                            builder.featuresToDisable(feature);
                        }
                    }
                });
            }

            private void configureVisibility(Jackson2ObjectMapperBuilder builder,
                    Map<PropertyAccessor, JsonAutoDetect.Visibility> visibilities) {
                visibilities.forEach(builder::visibility);
            }
           //配置Date格式化类
            private void configureDateFormat(Jackson2ObjectMapperBuilder builder) {
                // 支持全限定名的DateFormat或者时间格式串例如`yyyy-MM-dd HH:mm:ss`
                String dateFormat = this.jacksonProperties.getDateFormat();
                if (dateFormat != null) {
                    try {
                        Class<?> dateFormatClass = ClassUtils.forName(dateFormat, null);
                        builder.dateFormat(
                                (DateFormat) BeanUtils.instantiateClass(dateFormatClass));
                    }
                    catch (ClassNotFoundException ex) {
                       //若不是上送DateFormat的全限定名，那么使用SimpleDateFormat 进行格式化
                        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
                                dateFormat);
                        // 在Jackson 2.6.3 我们需要设置一个 TimeZone时区，若未设置，则使用默认的时区（UTC）
                        TimeZone timeZone = this.jacksonProperties.getTimeZone();
                        if (timeZone == null) {
                            timeZone = new ObjectMapper().getSerializationConfig()
                                    .getTimeZone();
                        }
                        simpleDateFormat.setTimeZone(timeZone);
                        builder.dateFormat(simpleDateFormat);
                    }
                }
            }

            private void configurePropertyNamingStrategy(
                    Jackson2ObjectMapperBuilder builder) {
                // We support a fully qualified class name extending Jackson's
                // PropertyNamingStrategy or a string value corresponding to the constant
                // names in PropertyNamingStrategy which hold default provided
                // implementations
                String strategy = this.jacksonProperties.getPropertyNamingStrategy();
                if (strategy != null) {
                    try {
                        configurePropertyNamingStrategyClass(builder,
                                ClassUtils.forName(strategy, null));
                    }
                    catch (ClassNotFoundException ex) {
                        configurePropertyNamingStrategyField(builder, strategy);
                    }
                }
            }

            private void configurePropertyNamingStrategyClass(
                    Jackson2ObjectMapperBuilder builder,
                    Class<?> propertyNamingStrategyClass) {
                builder.propertyNamingStrategy((PropertyNamingStrategy) BeanUtils
                        .instantiateClass(propertyNamingStrategyClass));
            }

            private void configurePropertyNamingStrategyField(
                    Jackson2ObjectMapperBuilder builder, String fieldName) {
                // Find the field (this way we automatically support new constants
                // that may be added by Jackson in the future)
                Field field = ReflectionUtils.findField(PropertyNamingStrategy.class,
                        fieldName, PropertyNamingStrategy.class);
                Assert.notNull(field, () -> "Constant named '" + fieldName
                        + "' not found on " + PropertyNamingStrategy.class.getName());
                try {
                    builder.propertyNamingStrategy(
                            (PropertyNamingStrategy) field.get(null));
                }
                catch (Exception ex) {
                    throw new IllegalStateException(ex);
                }
            }

            private void configureModules(Jackson2ObjectMapperBuilder builder) {
                Collection<Module> moduleBeans = getBeans(this.applicationContext,
                        Module.class);
                builder.modulesToInstall(moduleBeans.toArray(new Module[0]));
            }

            private void configureLocale(Jackson2ObjectMapperBuilder builder) {
                Locale locale = this.jacksonProperties.getLocale();
                if (locale != null) {
                    builder.locale(locale);
                }
            }

            private static <T> Collection<T> getBeans(ListableBeanFactory beanFactory,
                    Class<T> type) {
                return BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory, type)
                        .values();
            }
        }
    }
}

2. 修改方式

2.1 配置文件修改

spring:
  jackson:
      serialization:
        write-dates-as-timestamps: true   # date日期转换为时间戳
    date-format: yyyy-MM-dd HH:mm:ss   #指定日期格式，比如yyyy-MM-dd HH:mm:ss，或者具体的格式化类的全限定名

2.2 java代码配置

@Component
public class MyJackson2ObjectMapperBuilderCustomizer implements Jackson2ObjectMapperBuilderCustomizer, Ordered {
    @Override
    public void customize(Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder) {
       //禁止Date类型转化为时间戳。
       jacksonObjectMapperBuilder.featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

三、Jackson中ObjectMapper配置详解

上文讲述了如何在SpringBoot2.x环境下去修改容器中的ObjectMapper。那么ObjectMapper提供了什么样的配置供开发人员操作？

16013479-417b6662d5bc5e92

1. ObjectMapper的参数配置

1.1 针对于ObjectMapper直接配置

源码：com.fasterxml.jackson.databind.SerializationFeature该类是一个枚举类型，只有一个boolean类型的参数。即开启/禁用该设置。一般我们使用ObjectMapper objectMapper = new ObjectMapper();创建出来的ObjectMapper对象，实际上包含了SerializationFeature类的默认配置。我们若想修改配置，可以使用下面的方法，如代码1所示：

代码1：修改ObjectMapper中的SerializationFeature参数。

//SerializationFeature代表配置；state代表状态
public ObjectMapper configure(SerializationFeature f, boolean state)
//启用SerializationFeature配置
public ObjectMapper enable(SerializationFeature f)
//禁用配置
public ObjectMapper disable(SerializationFeature f)

1.2 SpringBoot2.x使用Builder进行配置

我们按照SpringBoot2.x的思路，需要自定义Jackson2ObjectMapperBuilderCustomizer子类并加入到IOC容器中。

并且在SpringBoot2.x中，引入了下面的依赖。使用builder创建ObjectMapper时注册objectMapper.registerModule(new JavaTimeModule())。解决了JDK1.8的新时间类LocalDateTime的问题。

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

核心代码：可以调整ObjectMapper序列化和反序列化特性。

@Component
public class MyJackson2ObjectMapperBuilderCustomizer implements Jackson2ObjectMapperBuilderCustomizer, Ordered {
    @Override
    public void customize(Jackson2ObjectMapperBuilder jacksonObjectMapperBuilder) {
        //若POJO对象的属性值为null，序列化时不进行显示
        jacksonObjectMapperBuilder.serializationInclusion(JsonInclude.Include.NON_NULL);
        //若POJO对象的属性值为""，序列化时不进行显示
        jacksonObjectMapperBuilder.serializationInclusion(JsonInclude.Include.NON_EMPTY);
        //DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES相当于配置，JSON串含有未知字段时，反序列化依旧可以成功
        jacksonObjectMapperBuilder.failOnUnknownProperties(false);
        //序列化时的命名策略——驼峰命名法
        jacksonObjectMapperBuilder.propertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
        //针对于Date类型，文本格式化
        jacksonObjectMapperBuilder.simpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //针对于JDK新时间类。序列化时带有T的问题，自定义格式化字符串
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        jacksonObjectMapperBuilder.modules(javaTimeModule);

//            jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        //默认关闭，将char[]数组序列化为String类型。若开启后序列化为JSON数组。
        jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS);

        //默认开启，若map的value为null，则不对map条目进行序列化。(已废弃)。
        // 推荐使用：jacksonObjectMapperBuilder.serializationInclusion(JsonInclude.Include.NON_NULL);
        jacksonObjectMapperBuilder.featuresToDisable(SerializationFeature.WRITE_NULL_MAP_VALUES);

        //默认开启，将Date类型序列化为数字时间戳(毫秒表示)。关闭后，序列化为文本表现形式(2019-10-23T01:58:58.308+0000)
        //若设置时间格式化。那么均输出格式化的时间类型。
        jacksonObjectMapperBuilder.featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        //默认关闭，在类上使用@JsonRootName(value="rootNode")注解时是否可以包裹Root元素。
        // (https://blog.csdn.net/blueheart20/article/details/52212221)
//            jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRAP_ROOT_VALUE);
        //默认开启：如果一个类没有public的方法或属性时，会导致序列化失败。关闭后，会得到一个空JSON串。
        jacksonObjectMapperBuilder.featuresToDisable(SerializationFeature.FAIL_ON_EMPTY_BEANS);

        //默认关闭，即以文本(ISO-8601)作为Key，开启后，以时间戳作为Key
        jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS);

        //默认禁用，禁用情况下，需考虑WRITE_ENUMS_USING_TO_STRING配置。启用后，ENUM序列化为数字
        jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_ENUMS_USING_INDEX);

        //仅当WRITE_ENUMS_USING_INDEX为禁用时(默认禁用)，该配置生效
        //默认关闭，枚举类型序列化方式，默认情况下使用Enum.name()。开启后，使用Enum.toString()。注：需重写Enum的toString方法;
        jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);

        //默认开启，空Collection集合类型输出空JSON串。关闭后取消显示。(已过时)
        // 推荐使用serializationInclusion(JsonInclude.Include.NON_EMPTY);
        jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS);

        //默认关闭，当集合Collection或数组一个元素时返回："list":["a"]。开启后，"list":"a"
        //需要注意，和DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY 配套使用，要么都开启，要么都关闭。
//            jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED);

        //默认关闭。打开后BigDecimal序列化为文本。(已弃用)，推荐使用JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN配置
//            jacksonObjectMapperBuilder.featuresToEnable(SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN);
        //默认关闭，即使用BigDecimal.toString()序列化。开启后，使用BigDecimal.toPlainString序列化，不输出科学计数法的值。
        jacksonObjectMapperBuilder.featuresToEnable(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN);

        /**
         * JsonGenerator.Feature的相关参数（JSON生成器）
         */

        //默认关闭，即序列化Number类型及子类为{"amount1":1.1}。开启后，序列化为String类型，即{"amount1":"1.1"}
        jacksonObjectMapperBuilder.featuresToEnable(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS);

        /******
         *  反序列化
         */
        //默认关闭，当JSON字段为""(EMPTY_STRING)时，解析为普通的POJO对象抛出异常。开启后，该POJO的属性值为null。
        jacksonObjectMapperBuilder.featuresToEnable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        //默认关闭
//            jacksonObjectMapperBuilder.featuresToEnable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        //默认关闭，若POJO中不含有JSON中的属性，则抛出异常。开启后，不解析该字段，而不会抛出异常。
        jacksonObjectMapperBuilder.featuresToEnable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

官方文档参考

【2.7.0 SerializationFeature API文档】

【2.7.0 DeserializationFeature API文档】

【2.7.0 JsonGenerator.Feature API文档】

四、Jackson“默认的”时间格式化类—StdDateFormat解析

1、SpringBoot2.x环境下默认的日期格式

在SpringBoot2.x环境下，默认情况下使用com.fasterxml.jackson.databind.util.StdDateFormat类对Date时间类进行格式化和反序列化，效果如下图所示：

1 2	{"id":1001,"userName":"李白","password":"123456","age":12,"date":"2020-02-13T06:44:27.417+0000"} UserT{id=1001, userName='李白', password='123456', age=12, date=Thu Feb 13 14:44:27 CST 2020}

此处需要注意：Json中date与Object对象中的date相差8个小时的时差。

测试代码如下：

@RestController
@Slf4j
public class ObjectMapperController {
    @Autowired //获取Spring容器中的ObjectMapper对象
    private ObjectMapper objectMapper;
    public static UserT userT;

    static {
        userT = new UserT();
        userT.setId(1001);
        userT.setUserName("李白");
        userT.setAge(12);
        userT.setPassword("123456");
        userT.setDate(new Date());
    }

    @RequestMapping("/testJackson")
    public String insertUser() {
        String result = null;
        try {
            result = objectMapper.writeValueAsString(userT);
            UserT userT = objectMapper.readValue(result, UserT.class);
            System.out.println(result);
            System.out.println(userT.toString());
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //JSON串再次解析为Object对象
        return result;
    }
}

ObjectMapper提供了DateFormat参数来处理Date类型的格式化，默认情况下，Jackson使用com.fasterxml.jackson.databind.util.StdDateFormat类进行格式化。

时间格式为：yyyy-MM-dd'T'HH:mm:ss.SSSZ，为ISO-8601数据类型。

若是请求上送的Date格式为：yyyy-MM-dd HH:mm:ss而SpringBoot使用默认的Jackson配置会出现异常：

Cannot deserialize value of type `java.util.Date` from String \"2020-04-20 20:30:00\": 
not a valid representation (error: Failed to parse Date value '2020-04-20 20:30:00': Cannot parse date \"2020-04-20 20:30:00\": while it seems to fit format 'yyyy-MM-dd'T'HH:mm:ss.SSSZ', 
parsing fails (leniency? null))\n at [Source: (PushbackInputStream); line: 1, column: 477] 
(through reference chain: ....}

解决方案：

方案1. 在yml配置中进行配置：

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss # 默认是StdDateFormat
    time-zone: GMT+8

方案二.在实体类参数使用注解

1	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")

2. StdDateFormat类解析

该类实现了DateFormat接口，提供了对Date日期的序列化与反序列化的程序。

序列化：默认使用ISO-8601的格式（会将Date类型格式成“yyyy-MM-dd’T’HH:MM:ss.SSSZ”字符串类型）。
反序列化：可以解析ISO-8601（yyyy-MM-dd'T'HH:mm:ss.SSSZ）和RFC-1123（yyyy-MM-dd）类型的字符串。

public class StdDateFormat
    extends DateFormat{
    //ISO-8601时间格式的字符串
    public final static String DATE_FORMAT_STR_ISO8601 = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
    /**
     * ISO-8601，只有日期部分，没有时间：错误消息需要
     */
    protected final static String DATE_FORMAT_STR_PLAIN = "yyyy-MM-dd";

    /**
     * 定义的是符合 RFC 1123 / RFC 822的日期格式。
     */
    protected final static String DATE_FORMAT_STR_RFC1123 = "EEE, dd MMM yyyy HH:mm:ss zzz";
    /**
     * 默认时区 UTC，在Jackson2.6之前使用的是GMT。这就是为什么我们格式化后的时间时差相差8小时的原因，因为北京时间与美国时间，相差8小时！
     */
    protected final static TimeZone DEFAULT_TIMEZONE;
    static {
        DEFAULT_TIMEZONE = TimeZone.getTimeZone("UTC"); // since 2.7
    }
    //默认的地区：美国
    protected final static Locale DEFAULT_LOCALE = Locale.US;
    //程序中会将Date日期转换为Calendar格式，以便处理日期类型。由于线程安全的问题，不能直接使用CALENDAR去格式化数据。
    //一般通过clone获取Calendar 实例，他会比new Calendar更有效率。
    protected static final Calendar CALENDAR = new GregorianCalendar(DEFAULT_TIMEZONE, DEFAULT_LOCALE);
    //设置时区
    protected transient TimeZone _timezone;
    //设置地区
    protected final Locale _locale;
    //是否允许宽松的时间格式
    protected Boolean _lenient;
    //2.9.1版本：TZ偏移量是否必须在小时和分钟之间用冒号格式化（{@code HH:mm}格式）
    private boolean _tzSerializedWithColon = false;
    //构造方法，创建StdDateFormat对象
    public StdDateFormat() {
        _locale = DEFAULT_LOCALE;
    }
    /**
     * 2.9.1版本后才存在的构造方法 lenient：是否允许宽松的时间格式；
     *  formatTzOffsetWithColon 格式化时是否允许Tz的偏移
     */
    protected StdDateFormat(TimeZone tz, Locale loc, Boolean lenient,
            boolean formatTzOffsetWithColon) {
        _timezone = tz;
        _locale = loc;
        _lenient = lenient;
        _tzSerializedWithColon = formatTzOffsetWithColon;
    }    
    //该方法用于创建带有特殊时区的StdDateFormat实例对象，若时区不是特殊的，返回默认的StdDateFormat对象（UTC时区）
    // withLenient(Boolean b) 方法和withLocale(Locale loc)方法withColonInTimeZone(boolean b) 同理
    public StdDateFormat withTimeZone(TimeZone tz) {
        if (tz == null) {
            tz = DEFAULT_TIMEZONE;
        }
        if ((tz == _timezone) || tz.equals(_timezone)) {
            return this;
        }
        return new StdDateFormat(tz, _locale, _lenient, _tzSerializedWithColon);
    }

上述格式化后时间相差8个小时可以通过修改TimeZone为北京时区去解决。

 @Test
 public void configureDateFormat() {
     // GMT+08:00  北京时间
     TimeZone timeZone = TimeZone.getTimeZone("GMT+08:00");
     StdDateFormat stdDateFormat = new StdDateFormat();
     //获取到北京时间的时区
     stdDateFormat.setTimeZone(timeZone);
     //获取到Locale为中国大陆地区
     stdDateFormat = stdDateFormat.withLocale(Locale.SIMPLIFIED_CHINESE);
     String format2 = stdDateFormat.format(new Date());
     System.out.println(format2);
}

2.1 Date转换为String源码分析

    //将Date格式化为yyyy-MM-dd'T'HH:mm:ss.SSSZ类型的数据，需要注意的是，若使用StdDateFormat那么返回的是例如：2020-02-13T06:44:27.417+0000格式的数据。
    //不能手动的填入'yyyy-MM-dd HH:mm:ss'等模板类型。
    @Override
    public StringBuffer format(Date date, StringBuffer toAppendTo,
            FieldPosition fieldPosition)
    {
        TimeZone tz = _timezone;
        if (tz == null) {
            tz = DEFAULT_TIMEZONE;
        }
        _format(tz, _locale, date, toAppendTo);
        return toAppendTo;
    }

    protected void _format(TimeZone tz, Locale loc, Date date,
            StringBuffer buffer)
    {
        //通过clone()方法获取到到Calendar实例。
        Calendar cal = _getCalendar(tz);
        cal.setTime(date);
        // [databind#2167]: handle range beyond [1, 9999]
        //处理的范围是[1，9999]年
        final int year = cal.get(Calendar.YEAR);

        //判断年份是否是公元前（BC（BCE）-公元前；AD-公元）
        if (cal.get(Calendar.ERA) == GregorianCalendar.BC) {
            _formatBCEYear(buffer, year);
        } else {
            if (year > 9999) {
              //超过4位数的处理没有明确规定，但是加前缀是强制性的。
                buffer.append('+');
            }
          //该方法时填充4位数，例如年份是100，最终得到的为0100；若是2001，最终得到是2001
            pad4(buffer, year);
        }
        buffer.append('-');
        //填充两位数，即若是1，最终得到01；
        pad2(buffer, cal.get(Calendar.MONTH) + 1);
        buffer.append('-');
        pad2(buffer, cal.get(Calendar.DAY_OF_MONTH));
        buffer.append('T');
        pad2(buffer, cal.get(Calendar.HOUR_OF_DAY));
        buffer.append(':');
        pad2(buffer, cal.get(Calendar.MINUTE));
        buffer.append(':');
        pad2(buffer, cal.get(Calendar.SECOND));
        buffer.append('.');
        pad3(buffer, cal.get(Calendar.MILLISECOND));
        //判读Calendar时间戳的偏移和类中TimeZone的偏移是否相同
        int offset = tz.getOffset(cal.getTimeInMillis());
        if (offset != 0) {
            int hours = Math.abs((offset / (60 * 1000)) / 60);
            int minutes = Math.abs((offset / (60 * 1000)) % 60);
            buffer.append(offset < 0 ? '-' : '+');
            pad2(buffer, hours);
            if( _tzSerializedWithColon ) {
                    buffer.append(':');
            }
            pad2(buffer, minutes);
        } else {
            //根据_tzSerializedWithColon属性值，来决定最终填充的是+00:00类型还是+0000类型
//            formatted.append('Z');
                if( _tzSerializedWithColon ) {
                buffer.append("+00:00");
                }
                else {
                    buffer.append("+0000");
                }
        }
    }

}

填充数据的公共方法（实际项目中可以利用！）。

private static void pad2(StringBuffer buffer, int value) {
    int tens = value / 10;
    if (tens == 0) {
        buffer.append('0');
    } else {
        buffer.append((char) ('0' + tens));
        value -= 10 * tens;
    }
    buffer.append((char) ('0' + value));
}

private static void pad3(StringBuffer buffer, int value) {
    int h = value / 100;
    if (h == 0) {
        buffer.append('0');
    } else {
        buffer.append((char) ('0' + h));
        value -= (h * 100);
    }
    pad2(buffer, value);
}

private static void pad4(StringBuffer buffer, int value) {
    //h=99/100，那么h==0，会填充00，value=99-100*0
    //使用pad2()方法继续填充99这个数据。
    int h = value / 100;
    if (h == 0) {
        buffer.append('0').append('0');
    } else {
        if (h > 99) { // [databind#2167]: handle above 9999 correctly
            buffer.append(h);
        } else {
            pad2(buffer, h);
        }
        value -= (100 * h);
    }
    pad2(buffer, value);
}

2.2 String转换为Date源码分析

将String解析为Date类型的方法（可根据实际需求进行扩展）

根据解析是DATE_FORMAT_STR_ISO8601（yyyy-MM-dd'T'HH:mm:ss.SSSZ）或者DATE_FORMAT_STR_PLAIN（yyyy-MM-dd）格式。
解析普通时间戳类型格式（可以允许存在负数，可以参考代码，判断字符串是否是时间戳）即：若上送的是时间戳，也可以解析为Date格式；
解析RFC1123格式的数据；

@Override
public Date parse(String dateStr) throws ParseException
{
    //去除参数空格
    dateStr = dateStr.trim();
    ParsePosition pos = new ParsePosition(0);
    Date dt = _parseDate(dateStr, pos);
    if (dt != null) {
        return dt;
    }
    StringBuilder sb = new StringBuilder();
    for (String f : ALL_FORMATS) {
        if (sb.length() > 0) {
            sb.append("\", \"");
        } else {
            sb.append('"');
        }
        sb.append(f);
    }
    sb.append('"');
    throw new ParseException
        (String.format("Cannot parse date \"%s\": not compatible with any of standard forms (%s)",
                       dateStr, sb.toString()), pos.getErrorIndex());
}

// 24-Jun-2017, tatu: I don't think this ever gets called. So could... just not implement?
@Override
public Date parse(String dateStr, ParsePosition pos)
{
    try {
        return _parseDate(dateStr, pos);
    } catch (ParseException e) {
        // 可能看起来很奇怪，但这是“DateFormat”建议的做法
    }
    return null;
}

protected Date _parseDate(String dateStr, ParsePosition pos) throws ParseException
{
  //判断传入的str是否是DATE_FORMAT_STR_ISO8601 格式或者DATE_FORMAT_STR_PLAIN 格式（判断特定位置和特定格式）
    if (looksLikeISO8601(dateStr)) { 
        //解析字符串
        return parseAsISO8601(dateStr, pos);
    }
    // 也可以考虑“简化”的简单时间戳（将时间戳解析为Date类型）

    int i = dateStr.length();
    while (--i >= 0) {
        char ch = dateStr.charAt(i);
        if (ch < '0' || ch > '9') {
            // 07-Aug-2013, tatu: And [databind#267] points out that negative numbers should also work
            if (i > 0 || ch != '-') {
                break;
            }
        }
    }
    //（1）解析dateStr字符串，字符串每个类型均为0-9之内的数字或ch等于`-`号时，继续解析，直到break或遍历完毕。若是break结束，那么i<0为false，若是遍历完毕，i<0为true。
   //（2）判断`-`号是否是第一位或者dateStr是否是Long类型
    if ((i < 0)
        // 假设负数是可以的（无论如何都不能是RFC-1123）；
            && (dateStr.charAt(0) == '-' || NumberInput.inLongRange(dateStr, false))) {
        return _parseDateFromLong(dateStr, pos);
    }
    // 否则，回到使用RFC 1123。注意：调用不会抛出异常，只返回'null`。
    return parseAsRFC1123(dateStr, pos);
}

根据字符串特定位置的字符，判断是否是ISO8601类型的格式。

protected boolean looksLikeISO8601(String dateStr)
{
    //字符串长度大于7，且第0位时数字，第三位是数字，第四位时-号，第5位时数字，即返回true
    if (dateStr.length() >= 7 // really need 10, but...
        && Character.isDigit(dateStr.charAt(0))
        && Character.isDigit(dateStr.charAt(3))
        && dateStr.charAt(4) == '-'
        && Character.isDigit(dateStr.charAt(5))
        ) {
        return true;
    }
    return false;
}
//将字符串解析为Date类型
private Date _parseDateFromLong(String longStr, ParsePosition pos) throws ParseException
{
    long ts;
    try {
        ts = NumberInput.parseLong(longStr);
    } catch (NumberFormatException e) {
        throw new ParseException(String.format(
                "Timestamp value %s out of 64-bit value range", longStr),
                pos.getErrorIndex());
    }
    return new Date(ts);
}

解析ISO8601格式的字符串为Date类型。

    protected Date _parseAsISO8601(String dateStr, ParsePosition bogus)
        throws IllegalArgumentException, ParseException
    {
      //获取传入的字符串的长度；
        final int totalLen = dateStr.length();
        //事实上，若以Z结尾，一定是UTC时区
        TimeZone tz = DEFAULT_TIMEZONE;
        if ((_timezone != null) && ('Z' != dateStr.charAt(totalLen-1))) {
            tz = _timezone;
        }
        //通过clone的方式获取到Calendar对象
        Calendar cal = _getCalendar(tz);
        cal.clear();
        String formatStr;
       //判断传入字符的长度，若小于10，那么使用DATE_FORMAT_STR_PLAIN去解析
        if (totalLen <= 10) {
            //使用正则表达式判断类型
            Matcher m = PATTERN_PLAIN.matcher(dateStr);
            if (m.matches()) {
                int year = _parse4D(dateStr, 0);
                int month = _parse2D(dateStr, 5)-1;
                int day = _parse2D(dateStr, 8);

                cal.set(year, month, day, 0, 0, 0);
                cal.set(Calendar.MILLISECOND, 0);
                //解析为Date类型，且返回
                return cal.getTime();
            }
            formatStr = DATE_FORMAT_STR_PLAIN;
        } else {
            //使用正则表达式，判断DATE_FORMAT_STR_ISO8601 格式
            Matcher m = PATTERN_ISO8601.matcher(dateStr);
            if (m.matches()) {
                // Important! START with optional time zone; otherwise Calendar will explode
                
                int start = m.start(2);
                int end = m.end(2);
                int len = end-start;
                if (len > 1) { // 0 -> none, 1 -> 'Z'
                    // NOTE: first char is sign; then 2 digits, then optional colon, optional 2 digits
                    int offsetSecs = _parse2D(dateStr, start+1) * 3600; // hours
                    if (len >= 5) {
                        offsetSecs += _parse2D(dateStr, end-2) * 60; // minutes
                    }
                    if (dateStr.charAt(start) == '-') {
                        offsetSecs *= -1000;
                    } else {
                        offsetSecs *= 1000;
                    }
                    cal.set(Calendar.ZONE_OFFSET, offsetSecs);
                    // 23-Jun-2017, tatu: Not sure why, but this appears to be needed too:
                    cal.set(Calendar.DST_OFFSET, 0);
                }
                
                int year = _parse4D(dateStr, 0);
                int month = _parse2D(dateStr, 5)-1;
                int day = _parse2D(dateStr, 8);

                // So: 10 chars for date, then `T`, so starts at 11
                int hour = _parse2D(dateStr, 11);
                int minute = _parse2D(dateStr, 14);

                // Seconds are actually optional... so
                int seconds;
                if ((totalLen > 16) && dateStr.charAt(16) == ':') {
                    seconds = _parse2D(dateStr, 17);
                } else {
                    seconds = 0;
                }
                cal.set(year, month, day, hour, minute, seconds);

                // Optional milliseconds
                start = m.start(1) + 1;
                end = m.end(1);
                int msecs = 0;
                if (start >= end) { // no fractional
                    cal.set(Calendar.MILLISECOND, 0);
                } else {
                    // first char is '.', but rest....
                    msecs = 0;
                    final int fractLen = end-start;
                    switch (fractLen) {
                    default: // [databind#1745] Allow longer fractions... for now, cap at nanoseconds tho

                        if (fractLen > 9) { // only allow up to nanos
                            throw new ParseException(String.format(
"Cannot parse date \"%s\": invalid fractional seconds '%s'; can use at most 9 digits",
                                       dateStr, m.group(1).substring(1)
                                       ), start);
                        }
                        // fall through
                    case 3:
                        msecs += (dateStr.charAt(start+2) - '0');
                    case 2:
                        msecs += 10 * (dateStr.charAt(start+1) - '0');
                    case 1:
                        msecs += 100 * (dateStr.charAt(start) - '0');
                        break;
                    case 0:
                        break;
                    }
                    cal.set(Calendar.MILLISECOND, msecs);
                }
                return cal.getTime();
            }
            formatStr = DATE_FORMAT_STR_ISO8601;
        }
       //若不满足上述条件，则之间抛出异常。
        throw new ParseException
        (String.format("Cannot parse date \"%s\": while it seems to fit format '%s', parsing fails (leniency? %s)",
                       dateStr, formatStr, _lenient),
                // [databind#1742]: Might be able to give actual location, some day, but for now
                //  we can't give anything more indicative
                0);
    }

实际上StdDateFormat不会解析yyyy-MM-dd HH:mm:ss格式的字符串。若我们上述这种类型的数据，它通过looksLikeISO8601方法，判断其为DATE_FORMAT_STR_ISO8601或者DATE_FORMAT_STR_PLAIN类型的数据。

但在parseAsISO8601方法中，会发现不存在对应类型。直接抛出异常。

五、Jackson的ObjectMapper.DefaultTyping.NON_FINAL属性

ObjectMapper是jackson的核心。Jackson的Json操作都是在ObjectMapper中实现的。ObjectMapper有一个配置：

1 2	ObjectMapper om = new ObjectMapper(); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

这个配置会对JSON的序列化和反序列化带来什么影响呢？

在SpringBoot2.x整合Redis时，若使用Jackson作为序列化工具，为何要设置该配置？

1. 源码的描述

1	源码:com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping

/**
 * Value that means that default typing will be used for
 * all non-final types, with exception of small number of
 * "natural" types (String, Boolean, Integer, Double), which
 * can be correctly inferred from JSON; as well as for
 * all arrays of non-final types.
 *<p>
 * Since 2.4, this does NOT apply to {@link TreeNode} and its subtypes.
 */
NON_FINAL

源码的解释是：对于除了一些自然类型(String、Double、Integer、Double)类型外的**非常量(non-final)**类型，类型将会用在值的含义上。以便可以在JSON串中正确的推测出值所属的类型。

2. 区别

1. 序列化的区别

我们先不设置ObjectMapper.DefaultTyping.NON_FINAL属性。对POJO进行序列化。

    @Test
    public void testDefaultTyping() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        //POJO无public的属性或方法时，不报错
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        //null值字段不显示
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //美化JSON输出
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        User user = new User();
        user.setAa(new Aa());   //普通POJO对象
        user.setAmount1(1.1);   //Double对象
        user.setUName("Tom");  //String类型
        user.setDate(new Date()); //Date类型
        String string = objectMapper.writeValueAsString(user);   //解析对象
        System.out.println(string);
    }

输出结果如图1所示，这个是正常的JSON串。

16013479-646793957fb6fba0

图1_输出结果.png

接着开启objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);配置，对POJO对象进行序列化。得到的JSON串的值中带有对象的类型。这也就是源码的含义。如图2所示。

16013479-a852dde53f67017b

图2_开启DefaultTyping.NON_FINAL的输出配置.png

2. 反序列化的区别

我们将POJO对象进行序列化，大多数是为了存储或传输。最终我们还是需要进行反序列化成为POJO的。那么这两种JSON串进行反序列化时会有问题吗？

我们对ObjectMapper设置了objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);参数，对普通的JSON串进行反序列化。

@Test
public void testDefaultTyping() throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    //POJO无public的属性或方法时，不报错
    objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    //null值字段不显示
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    //序列化JSON串时，在值上打印出对象类型
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    String string="{\"date\":1571887801613,\"aa\":{},\"amount1\":1.1,\"uname\":\"Tom\"}";
    User user = objectMapper.readValue(string, User.class);
    System.out.println(user);
}

运行结果，如下列代码所示，因为我们的JSON串中不含有字段的类型，所以不能进行反序列化。

com.fasterxml.jackson.databind.exc.MismatchedInputException: 
Unexpected token (START_OBJECT), expected START_ARRAY: 
need JSON Array to contain As.WRAPPER_ARRAY type information for class com.galax.jackson.User
at [Source: (String)"{"date":1571887801613,"aa":{},"amount1":1.1,"uname":"Tom"}"; line: 1, column: 1]

未设置objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);字段，对含有值类型的JSON串进行反序列化。

    @Test
    public void testDefaultTyping() throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        //POJO无public的属性或方法时，不报错
        objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
        //null值字段不显示
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //序列化JSON串时，在值上打印出对象类型
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        String string="[\"com.galax.jackson.User\",{\"date\":[\"java.util.Date\",1571888059184],\"aa\":[\"com.galax.jackson.Aa\",{}],\"amount1\":1.1,\"uname\":\"Tom\"}]";
        User user = objectMapper.readValue(string, User.class);
        System.out.println(user);
    }

运行结果依旧是不能解析。

1 2	com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot deserialize instance of `com.galax.jackson.User` out of START_ARRAY token

3. 注意事项

Spring源码中是使用容器中的ObjectMapper对象进行序列化和反序列化。当我们将自定义的ObjectMapper对象放入IOC容器中后，会自动覆盖SpringBoot自动装载的ObjectMapper对象。若是我们在自定义的ObjectMapper中设置了objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);属性。那么可能会影响我们的@RequestBody反序列化JSON串，导致Spring Boot默认错误返回格式变成数组@RequestBody无法解析Json格式异常。

如何去自定义配置IOC容器中的ObjectMapper对象，实际上，SpringBoot给了两种方式，详情请参考：SpringBoot配置ObjectMapper源码，以及ObjectMapper序列化/反序列化配置。

4. 项目运用

SpringBoot2.X整合Redis缓存中，使用Jackson作为序列化工具，其中就使用了ObjectMapper.DefaultTyping.NON_FINAL配置。

 Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
 ObjectMapper om = new ObjectMapper();
 om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//序列化时允许非常量字段均输出类型
 om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
 jackson2JsonRedisSerializer.setObjectMapper(om);

因为数据在反序列化为具体类时，需要传入具体的对象类型。而Redis的序列化配置是公共配置。我们只能传入Object.class类型进行反序列化。

序列化得到的字段为

序列化对象格式.png
反序列化会得到LinkedHashMap类型，该类型不能强转为具体的对象类型，即抛出

1	java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to com.galax.pojo.Account

所以我们需要ObjectMapper.DefaultTyping.NON_FINAL配置，在序列化时记录对象类型，以便反序列化时得到对应的具体对象。

六、引用

https://www.jianshu.com/p/560e9b114c29
https://www.jianshu.com/p/68fce8b23341
https://www.jianshu.com/p/89f8040fe956
https://www.jianshu.com/p/307ad48978d6
https://www.jianshu.com/p/c5fcd2a1ab49

本文作者： 初心
本文链接： http://funzzz.fun/2021/01/04/jackson---3springBoot/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！