springboot项目配置序列化，反序列化器

向右看齐 2024-03-25 09:30 192阅读 0赞

介绍

本文介绍在项目中时间类型、枚举类型的序列化和反序列化自定义的处理类，也可以使用注解。

建议枚举都实现一个统一的接口，方便处理。我这定义了一个Dict接口。

枚举类型注解处理

这种方式比较灵活，可以让枚举按照自己的方式序列化，可以序列化code值（推荐），也可以序列化对象。序列化为对象：对于前端来说是比较好的，前端接收到code值和中文label，页面显示label就行了，但是对于后端，服务之间调用，使用feign调用的时候，序列化为对象，被调用服务的controller层就接收不到这个枚举值了，因为接收的是枚举序列化的对象，无法反序列化成枚举对象了。除非使用自定义反序列加判断去处理，比较麻烦。参考改进枚举工具类

定义统一枚举接口

  1. package com.common.interfaces;
  3. public interface Dict {
  4.     String name();
  6.     default Integer getCode() {
  7.         return null;
  8.     }
  10.     default String getLabel() {
  11.         return null;
  12.     }
  13. }

序列化code值

枚举代码

  1. package com.common.enums.app;
  3. import com.baomidou.mybatisplus.annotation.EnumValue;
  4. import com.common.interfaces.Dict;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Getter;
  8. @Getter
  9. @AllArgsConstructor
  10. public enum DeliverDateModelEnum implements Dict {
  12.     SAME(0, "相同时间"),
  13.     DIFFERENT(2, "不同时间"),
  14.     ;
  15.     // mybatis的处理注解                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
  16.     @EnumValue
  17.     // Jackson的序列化处理注解；序列化code值
  18.     @JsonValue
  19.     private final Integer code;
  20.     private final String label;
  22. }
  24. package com.common.enums.order;
  26. import com.common.exception.E;
  27. import com.common.interfaces.Dict;
  28. import com.fasterxml.jackson.annotation.JsonCreator;
  29. import lombok.AllArgsConstructor;
  30. import lombok.Getter;
  32. import java.util.Arrays;
  33. import java.util.Map;
  34. import java.util.stream.Collectors;
  36. /**
  37.  * 订单采购方式枚举
  38.  */
  39. @Getter
  40. @AllArgsConstructor
  41. public enum OrderPurchaseMethodEnum implements Dict {
  44.     INQUIRY("询价"),
  45.     MALL("商城"),
  46.     ;
  48.     private String label;
  50.     private static final Map<String, OrderPurchaseMethodEnum> MAP =
  51.             Arrays.stream(OrderPurchaseMethodEnum.values()).collect(Collectors.toMap(Enum::name, e -> e));
  53.     @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
  54.     public static OrderPurchaseMethodEnum resolve(String code) {
  55.         if (!MAP.containsKey(code)) {
  56.             throw new Exception("枚举类型错误");
  57.         }
  58.         return MAP.get(code);
  59.     }
  60. }

实体类

  1. package com.app.dto;
  3. import com.common.enums.apply.DeliverDateModelEnum;
  4. import com.common.enums.order.OrderPurchaseMethodEnum;
  5. import io.swagger.annotations.ApiModelProperty;
  6. import lombok.Data;
  7. import lombok.EqualsAndHashCode;
  9. import javax.validation.constraints.NotBlank;
  10. import javax.validation.constraints.NotNull;
  11. import java.io.Serializable;
  13. @Data
  14. @EqualsAndHashCode(callSuper = false)
  15. public class ApplyInfoDTO2 implements Serializable {
  17.     private static final long serialVersionUID = 1L;
  19.     @ApiModelProperty(value = "主键")
  20.     private Long id;
  22.     @ApiModelProperty(value = "标题", required = true)
  23.     private String title;
  25.    @NotNull(message = "时间方式不能为空")
  26.     private DeliverDateModelEnum deliverDateModel;
  28. // 后期会用到
  29.     private OrderPurchaseMethodEnum purchaseMethod;
  32. }

测试代码

  1. @RestController
  2. @Slf4j
  3. @RequestMapping("/api/test")
  4. public class TestController2 {
  7.     @PostMapping(value = "/hh")
  8.     public ApplyInfoDTO2 test9(@RequestBody ApplyInfoDTO2 applyInfoDTO) {
  10.         System.out.println("hhhhh");
  11.         applyInfoDTO.setId(55L);
  12.         System.out.println("----"+ JacksonUtils.toJson(applyInfoDTO));
  13.         return applyInfoDTO;
  14.     }
  15. }
  17. 请求参数
  18. {
  19.     "id":11,
  20.     "title": "dajf",
  21.     "deliverDateModel":2
  22. }
  24. 响应结果
  25. {
  26.     "id": 55,
  27.     "title": "dajf",
  28.     "deliverDateModel": 2,
  29.     "purchaseMethod": null
  30. }

序列化对象

这里只改枚举就可以了

  1. package com.common.enums.app;
  3. import com.baomidou.mybatisplus.annotation.EnumValue;
  4. import com.common.interfaces.Dict;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Getter;
  8. @Getter
  9. @AllArgsConstructor
  10. @JsonFormat(shape = JsonFormat.Shape.OBJECT)
  11. public enum DeliverDateModelEnum implements Dict {
  13.     SAME(0, "相同时间"),
  14.     DIFFERENT(2, "不同时间"),
  15.     ;
  16.     // mybatis的处理注解
  17.     @EnumValue
  18.     // 由于上边注解标记序列化为对象了，这就不起作用了，可以注掉
  19.     // @JsonValue
  20.     private final Integer code;
  21.     private final String label;
  23. }

结果

  1. 请求参数
  2. {
  3.     "id":11,
  4.     "title": "dajf",
  5.     "deliverDateModel":0
  6. }
  8. 响应结果
  9. {
  10.     "id": 55,
  11.     "title": "dajf",
  12.     "deliverDateModel": {
  13.         "code": 0,
  14.         "label": "相同时间"
  15.     },
  16.     "purchaseMethod": null
  17. }

反序列化处理

这就是说，前端传code值0，后端可以对应到枚举字段上，默认的是使用下标ordinal来反序列化的，按照0,1,2,3…去对应上，如果中跳过了，接收值的时候就会报错。比如上边的枚举类DeliverDateModelEnum，传0不会报错，传2就找不到了，错误如下，

  1. Caused by: com.fasterxml.jackson.databind.exc.InvalidFormatException: Cannot deserialize value of type `com.common.enums.apply.DeliverDateModelEnum` from number 2: index value outside legal index range [0..1]
  2.  at [Source: (PushbackInputStream); line: 4, column: 21] (through reference chain: com.cnpc.app.dto.ApplyInfoDTO2["deliverDateModel"])

解决方案：在枚举类加反序列化处理代码@JsonCreator

  1. package com.common.enums.app;
  3. import com.baomidou.mybatisplus.annotation.EnumValue;
  4. import com.common.interfaces.Dict;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Getter;
  8. @Getter
  9. @AllArgsConstructor
  10. @JsonFormat(shape = JsonFormat.Shape.OBJECT)
  11. public enum DeliverDateModelEnum implements Dict {
  13.     SAME(0, "相同时间"),
  14.     DIFFERENT(2, "不同时间"),
  15.     ;
  16.     // mybatis的处理注解                      
  17.     @EnumValue
  18.     // 由于上边注解标记序列化为对象了，这就不起作用了，可以注掉
  19.     // @JsonValue
  20.     private final Integer code;
  21.     private final String label;
  23.     private static final Map<Integer, DeliverDateModelEnum> map =
  24.             Arrays.stream(DeliverDateModelEnum.values()).collect(Collectors.toMap(DeliverDateModelEnum::getCode, e -> e));
  26.     @JsonCreator(mode = JsonCreator.Mode.DELEGATING)
  27.     public static DeliverDateModelEnum resolve(Integer code) {
  28.         if (!map.containsKey(code)) {
  29.             throw new E("找不到枚举");
  30.         }
  31.         return map.get(code);
  32.     }
  34. }

以上就是注解的枚举处理方法，统一定义接口后，为了前端可以通过code值展示枚举中午label，所以又写了一个字典解析类，将所以实现Dict接口的枚举，都拿到，然后解析存储，再给前端提供一个请求路径。前端存储起来，去解析，退出的时候，可以清除前端缓存。

将枚举转字典存储

  1. package com.dict.service;
  3. import com.common.annotation.DictType;
  4. import com.common.exception.E;
  5. import com.common.interfaces.Dict;
  6. import com.dict.vo.DictItemVO;
  7. import com.dict.vo.DictVO;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.apache.commons.lang3.StringUtils;
  10. import org.apache.logging.log4j.util.Strings;
  11. import org.reflections.Reflections;
  12. import org.springframework.beans.factory.annotation.Value;
  13. import org.springframework.stereotype.Component;
  15. import javax.annotation.PostConstruct;
  16. import java.lang.reflect.InvocationTargetException;
  17. import java.lang.reflect.Method;
  18. import java.util.*;
  19. import java.util.stream.Collectors;
  21. /**
  22.  * 系统字典Service
  23.  */
  24. @Slf4j
  25. @Component
  26. public class SystemDictService {
  28.     /**
  29.      * 反射要扫描的包路径
  30.      */
  31.     @Value("${dict.scanPath:com.company}")
  32.     private String scanPath;
  34.     /**
  35.      * 字典集合
  36.      */
  37.     private static Set<DictVO> DICT_SET = new HashSet<>();
  39.     /**
  40.      * 提供给外部获取字典集合的方法
  41.      *
  42.      * @author sun
  43.      */
  44.     public Set<DictVO> getDictSet() {
  46.         return DICT_SET;
  47.     }
  49.     /**
  50.      * 启动时扫描
  51.      */
  52.     @PostConstruct
  53.     public void initDict() {
  55.         DICT_SET = scanDict();
  56.     }
  58.     /**
  59.      * 扫描字典列表
  60.      */
  61.     private Set<DictVO> scanDict() {
  63.         // 反射要扫描的包路径
  64.         Reflections reflections = new Reflections(scanPath);
  66.         // 反射获取所有实现 DictInterface 接口的枚举
  67.         Set<Class<? extends Dict>> monitorClasses = reflections.getSubTypesOf(Dict.class);
  69.         /*
  70.          * 封装字典列表
  71.          * 过滤掉不是枚举的实现
  72.          * 反射调用枚举的 values 方法, 获取每个枚举内部的值列表
  73.          */
  74.         return monitorClasses.stream()
  75.                 .filter(Class::isEnum)
  76.                 .map(sub -> {
  77.                     DictVO vo = new DictVO();
  78.                     try {
  80.                        /* 这块没有使用到
  81.                         DictType annotation = sub.getAnnotation(DictType.class);
  82.                         if (Objects.nonNull(annotation) && Strings.isNotBlank(annotation.type())) {
  83.                             // 有DictType注解并且type不是空白时使用注解中的值作为字典的类别
  84.                             vo.setType(annotation.type());
  85.                         } else {
  86.                             // 否则使用类名作为字典的类别
  87.                             vo.setType(sub.getSimpleName());
  88.                         }*/
  90.                         Method valuesMethod = sub.getMethod("values");
  91.                         Object valuesObj = valuesMethod.invoke(sub);
  92.                         Dict[] values = (Dict[]) valuesObj;
  94.                         List<DictItemVO> collect = Arrays.stream(values)
  95.                                 .map(item -> {
  96.                                     // code和label都可以没有，全部以name为默认
  97.                                     String code = item.getCode() != null ? item.getCode().toString() : item.name();
  98.                                     String label = item.getLabel() != null ? item.getLabel() : item.name();
  99.                                     return new DictItemVO(code, label);
  100.                                 }).collect(Collectors.toList());
  102.                         vo.setItems(collect);
  104.                     } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
  105.                         log.error("{}", e.getMessage(), e);
  106.                     }
  107.                     return vo;
  108.                 })
  109.                 // 这里转map是校验有没有重复的type, 如果存在重复的会报错
  110.                 .collect(Collectors.toMap(item -> item, item -> item, (a1, a2) -> {throw new E("字典类型:" + a1.getType() + ", 有重复");}))
  111.                 .keySet();
  112.     }
  114. }
  116. // controller层提供外部访问    
  117. @ApiOperation("系统字典列表查询")
  118.     @GetMapping(value = "/system")
  119.     public R<Set<DictVO>> querySystemDict() {
  121.         return R.of(systemDictService.getDictSet());
  122.     }
  124. package com.dict.vo;
  126. import lombok.Data;
  128. import java.util.List;
  129. import java.util.Objects;
  131. /**
  132.  * 字典VO
  133.  *
  134.  */
  135. @Data
  136. public class DictVO {
  138.     /**
  139.      * 字典类别名称
  140.      */
  141.     private String type;
  143.     /**
  144.      * 字典项列表
  145.      */
  146.     private List<DictItemVO> items;
  148.     @Override
  149.     public boolean equals(Object o) {
  150.         if (this == o) {
  151.             return true;
  152.         }
  153.         if (o == null || getClass() != o.getClass()) {
  154.             return false;
  155.         }
  156.         DictVO dictVO = (DictVO) o;
  157.         return Objects.equals(type, dictVO.type);
  158.     }
  160.     @Override
  161.     public int hashCode() {
  163.         return Objects.hash(type);
  164.     }
  165. }
  167. package com.dict.vo;
  169. import lombok.AllArgsConstructor;
  170. import lombok.Data;
  171. import lombok.NoArgsConstructor;
  173. /**
  174.  * 字典项
  175.  */
  176. @Data
  177. @NoArgsConstructor
  178. @AllArgsConstructor
  179. public class DictItemVO {
  181.     /**
  182.      * 编码
  183.      */
  184.     private String code;
  186.     /**
  187.      * 标签
  188.      */
  189.     private String label;
  191. }

自定义枚举类型处理（不建议使用）

这种方式只能支持单个属性接收值，接收list枚举，map。set接收枚举都会报错。

由于上边规定所有的枚举都需要实现Dict接口，下面的反序列化只针对符合条件的处理

处理工具类

  1. package com.common.config;
  3. import com.common.interfaces.Dict;
  5. import java.util.Arrays;
  6. import java.util.Map;
  7. import java.util.Objects;
  8. import java.util.concurrent.ConcurrentHashMap;
  9. import java.util.stream.Collectors;
  11. /**
  12.  * 枚举匹配工具类
  13.  */
  14. public class EnumUtil {
  16.     private static final Map<Class<? extends Enum<?>>, Map<Integer, ? extends Enum<? extends Dict>>> CLASS_ENUM_MAP =
  17.             new ConcurrentHashMap<>(16);
  19.     @SuppressWarnings("unchecked")
  20.     public static <E extends Enum<E> & Dict> E match(Class<E> enumClass, Integer type) {
  21.         Map enumMap = CLASS_ENUM_MAP.get(enumClass);
  22.         if (Objects.isNull(enumMap)) {
  23.            // Map<Integer, ? extends Enum<? extends Dict>> unmodifiableMap = Arrays.stream(enumClass.getEnumConstants())
  24.                                              // 这种表达式写法会报错
  25.             //       .collect(Collectors.toMap(Dict::getCode, v -> v));
  26.               Map<Integer, ? extends Enum<? extends Dict>> unmodifiableMap = Arrays.stream(enumClass.getEnumConstants())
  27.                     .collect(Collectors.toMap(obj -> obj.getCode(), v -> v));
  28.             CLASS_ENUM_MAP.putIfAbsent(enumClass, unmodifiableMap);
  29.             return (E) unmodifiableMap.get(type);
  30.         }
  31.         return (E) enumMap.get(type);
  32.     }
  33. }

自定义的反序列化类

  1. package com.common.config;
  3. import com.common.interfaces.Dict;
  4. import com.fasterxml.jackson.core.JsonParser;
  5. import com.fasterxml.jackson.databind.BeanProperty;
  6. import com.fasterxml.jackson.databind.DeserializationContext;
  7. import com.fasterxml.jackson.databind.JavaType;
  8. import com.fasterxml.jackson.databind.JsonDeserializer;
  9. import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
  10. import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
  12. import java.io.IOException;
  14. /**
  15.  * 枚举反序列化器
  16.  */
  17. public class DictEnumDeserializer extends StdDeserializer<Dict> implements ContextualDeserializer {
  19.     public DictEnumDeserializer() {
  20.         super((JavaType) null);
  21.     }
  23.     public DictEnumDeserializer(JavaType valueType) {
  24.         super(valueType);
  25.     }
  27.     @Override
  28.     public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) {
  29.         return new DictEnumDeserializer(property.getType());
  30.     }
  32.     @Override
  33.     @SuppressWarnings("all")
  34.     public Dict deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
  35.         return (Dict) EnumUtil.match((Class) _valueClass, p.getIntValue());
  36.     }
  37. }

注入到spring中

注入方式1

由于项目中还配置有时间的序列化所以就把它们放一起了。建议使用的，把所有的序列化反序列化的都放这。

  1. package com.cnpc.common.config;
  3. import com.common.interfaces.Dict;
  4. import com.fasterxml.jackson.databind.*;
  5. import com.fasterxml.jackson.databind.module.SimpleDeserializers;
  6. import com.fasterxml.jackson.databind.module.SimpleModule;
  7. import com.fasterxml.jackson.databind.type.ClassKey;
  8. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  9. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
  10. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
  11. import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
  12. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
  13. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
  14. import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
  15. import org.springframework.context.annotation.Bean;
  16. import org.springframework.context.annotation.Configuration;
  17. import org.springframework.context.annotation.Primary;
  19. import java.time.LocalDate;
  20. import java.time.LocalDateTime;
  21. import java.time.LocalTime;
  22. import java.time.format.DateTimeFormatter;
  23. import java.util.Objects;
  25. /**
  26.  * LocalDateTime配置
  27.  */
  28. @Configuration
  29. // public class LocalDateTimeFormatConfig { 改了一个名字
  30. public class WebCustomerConfig {
  32.     private static final String DEFAULT_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  33.     private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";
  34.     private static final String DEFAULT_TIME_PATTERN = "HH:mm:ss";
  36. // 这里加@Primary，在项目启动的时候一共会加载12个convert，第7个是MappingJackson2HttpMessageConverter
  37. // 处理json映射对象参数的类，会采用这个ObjectMapper，默认的是 new ObjectMapper();这里自己增加了一些序列化处理的方法
  38.     @Bean
  39.     @Primary
  40.     public ObjectMapper objectMapper() {
  41.         ObjectMapper objectMapper = new ObjectMapper();
  43. // 注册时间的序列化和反序列化处理
  44.         JavaTimeModule javaTimeModule = new JavaTimeModule();
  45.         javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_PATTERN)));
  46.         javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)));
  47.         javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)));
  48.         javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_PATTERN)));
  49.         javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)));
  50.         javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)));
  51.         objectMapper.registerModule(javaTimeModule);
  52.         //忽略识别不了的属性
  53.         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  57. // 注册枚举的处理序列化和反序列的方式
  58.         SimpleModule sm = new SimpleModule();
  59.         //自定义查找规则
  60.         sm.setDeserializers(new SimpleDeserializers() {
  61.             @Override
  62.             public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config,
  63.                                                             BeanDescription beanDesc) throws JsonMappingException {
  64.                 JsonDeserializer enumDeserializer = super.findEnumDeserializer(type, config, beanDesc);
  65.                 if (enumDeserializer != null) {
  66.                     return enumDeserializer;
  67.                 }
  70.                 //遍历枚举实现的接口, 查找反序列化器
  71.                 for (Class typeInterface : type.getInterfaces()) {
  72.                     // 如果实现了Dict接口但是没有code值的就返回null，如果项目比较规范都有code值，或者没有code值的，没有实现Dict接口，可以去掉下面这个代码
  73.                    if (typeInterface.equals(Dict.class) ){
  74.                         Dict[] enumConstants = (Dict[]) type.getEnumConstants();
  75.                         if (Objects.isNull(enumConstants[0].getCode())) {
  76.                             return null;
  77.                         }
  78.                     }
  80.                     enumDeserializer = this._classMappings.get(new ClassKey(typeInterface));
  81.                     if (enumDeserializer != null) {
  82.                         return enumDeserializer;
  83.                     }
  84.                 }
  85.                 return null;
  86.             }
  87.         });
  88.         sm.addDeserializer(Dict.class, new TypeEnumDeserializer());
  90. // 增加枚举的序列化方式
  91.         sm.addSerializer(Dict.class, new JsonSerializer<Dict>() {
  93.             @Override
  94.             public void serialize(Dict value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
  95.                  // 相当于在枚举类上加 @JsonFormat(shape = JsonFormat.Shape.OBJECT)；返给页面的是一个对象code和label都返回
  96. //                gen.writeStartObject();
  97. //                gen.writeNumberField("code", value.getCode());
  98. //                gen.writeStringField("label", value.getLabel());
  99. //                gen.writeEndObject();
  101.                 // 相当于在枚举code字段上加 @JsonValue  返回给页面一个code值
  102.                 gen.writeNumber(value.getCode());
  103.             }
  105.             @Override
  106.             public void serializeWithType(Dict value, JsonGenerator gen, SerializerProvider serializers,
  107.                                           TypeSerializer typeSer) throws IOException {
  108.                 WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen, typeSer.typeId(value, JsonToken.VALUE_STRING));
  109.                 serialize(value, gen, serializers);
  110.                 typeSer.writeTypeSuffix(gen, typeIdDef);
  111.             }
  112.         });
  113.         objectMapper.registerModule(sm);
  115.         return objectMapper;
  116.     }
  117. }

注入方式2

下面这种注入会影响项目已经有配置ObjectMapper的地方，建议都放一起。如果采用下面这种方式，需要自己创建一个MappingJackson2HttpMessageConverter，并将converter添加到list的第一个，如果添加到最后一个，他会先找list中前边的MappingJackson2HttpMessageConverter，大约是第7个位置，就不会用自己写的。

  1. package com.common.config;
  3. import com.common.interfaces.Dict;
  4. import com.fasterxml.jackson.core.JsonGenerator;
  5. import com.fasterxml.jackson.core.JsonToken;
  6. import com.fasterxml.jackson.core.type.WritableTypeId;
  7. import com.fasterxml.jackson.databind.*;
  8. import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
  9. import com.fasterxml.jackson.databind.module.SimpleDeserializers;
  10. import com.fasterxml.jackson.databind.module.SimpleModule;
  11. import com.fasterxml.jackson.databind.type.ClassKey;
  12. import lombok.extern.slf4j.Slf4j;
  13. import org.springframework.http.converter.HttpMessageConverter;
  14. import org.springframework.http.converter.StringHttpMessageConverter;
  15. import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
  16. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  18. import java.io.IOException;
  19. import java.nio.charset.StandardCharsets;
  20. import java.util.List;
  22. /**
  23.  * 装载枚举序列化器
  24.  */
  25. @Configuration
  26. @Slf4j
  27. public class WebMvcConfig implements WebMvcConfigurer {
  29.     @Override
  30.     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
  31.         StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(StandardCharsets.UTF_8);
  32.         MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
  34.         converter.setObjectMapper(objectMapperForWebConvert());
  35.         converters.add(0, stringHttpMessageConverter);
  36.         // 将这个MappingJackson2HttpMessageConverter添加到第一个，是为了优先找到，否则就有其他MappingJackson2HttpMessageConverter去处理了
  37.         converters.add(0, converter);
  38.     }
  40. // 这个没有时间的处理配置。
  41.     public ObjectMapper objectMapperForWebConvert() {
  42.         ObjectMapper om = new ObjectMapper();
  43.         om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  45.         SimpleModule sm = new SimpleModule();
  46.         //自定义查找规则
  47.         sm.setDeserializers(new SimpleDeserializers() {
  48.             @Override
  49.             public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config,
  50.                                                             BeanDescription beanDesc) throws JsonMappingException {
  51.                 JsonDeserializer enumDeserializer = super.findEnumDeserializer(type, config, beanDesc);
  52.                 if (enumDeserializer != null) {
  53.                     return enumDeserializer;
  54.                 }
  55.                 //遍历枚举实现的接口, 查找反序列化器
  56.                 for (Class typeInterface : type.getInterfaces()) {
  57.                     // 如果实现了Dict接口但是没有code值的就返回null，如果项目比较规范都有code值，或者没有code值的，没有实现Dict接口，可以去掉下面这个代码
  58.                     if (typeInterface.equals(Dict.class)){
  59.                         Dict[] enumConstants = (Dict[]) type.getEnumConstants();
  60.                         if (Objects.isNull(enumConstants[0].getCode())) {
  61.                             return null;
  62.                         }
  63.                     }
  66.                                                               // 这里的classKey不要导错包，必须是com.fasterxml.jackson.databind.type.ClassKey，否则会找不到，导致自定义的反序列化类不起作用
  67.                     enumDeserializer = this._classMappings.get(new ClassKey(typeInterface));
  69.                     if (enumDeserializer != null) {
  70.                         return enumDeserializer;
  71.                     }
  73.                     // 上边的ClassKey导入包错误，找不到临时加的
  74. //                    if (typeInterface.equals(Dict.class)){
  75. //                        return new DictEnumDeserializer();
  76. //                    }
  78. //                    return new DictEnumDeserializer();
  79.                 }
  80.                 return null;
  81.             }
  82.         });
  83.         // 添加枚举反序列化处理器
  84.         sm.addDeserializer(Dict.class, new DictEnumDeserializer());
  86.         sm.addSerializer(Dict.class, new JsonSerializer<Dict>() {
  88.             @Override
  89.             public void serialize(Dict value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
  90.                 // 相当于在枚举类上加 @JsonFormat(shape = JsonFormat.Shape.OBJECT)；返给页面的是一个对象code和label都返回
  91. //                gen.writeStartObject();
  92. //                gen.writeNumberField("code", value.getCode());
  93. //                gen.writeStringField("label", value.getLabel());
  94. //                gen.writeEndObject();
  96.                 // 相当于在枚举code字段上加 @JsonValue  返回给页面一个code值
  97.                 gen.writeNumber(value.getCode());
  98.             }
  100.             @Override
  101.             public void serializeWithType(Dict value, JsonGenerator gen, SerializerProvider serializers,
  102.                                           TypeSerializer typeSer) throws IOException {
  103.                 WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen, typeSer.typeId(value, JsonToken.VALUE_STRING));
  104.                 serialize(value, gen, serializers);
  105.                 typeSer.writeTypeSuffix(gen, typeIdDef);
  106.             }
  107.         });
  108.         om.registerModule(sm);
  110.         return om;
  111.     }
  112. }

这样就可以测试了。没有实现Dict接口的枚举会采用下一个MappingJackson2HttpMessageConverter的new ObjectMapper（）去处理，按照默认的去处理

断点测试

715affc2d1274dc19296c8f6f1644d22.png

第一次赋值

6d17819ca1a57fe01fb31fe5b4c0f5d0.png

加载自定义的ObjectMapper

ff94ffd0a6cda4207e4fd7f5e8dedf37.png

现在converter变成了14个了，因为这是注入方式2，自己往里面放了2个，

262c12ffe3c9b82e656bcdbb362ab1de.png

请求访问时，断点

org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodArgumentResolver#readWithMessageConverters(org.springframework.http.HttpInputMessage, org.springframework.core.MethodParameter, java.lang.reflect.Type)

c7c567fde1e8d4d93a409db6793be2bb.png

注入方式1断点测试

168672c74bae4cc74fee0f522a30c125.png

启动过程中会放入2个MappingJackson,会看到第7个下移到第8个了

627f25fb2c71f1c8ea415ca14fc25d37.png

注入方式2断点测试

第一次启动地址是15536

eb8bdf484a7c734a2991bee7b7ae0880.png

6f05eeef35ec475b8e99ee3d411322d1.png

a82cd6d87b0164cc195341b6e6a7b50c.png

走到自己写的枚举处理

62ca0dd27e68eafe89a0c942f7547a8e.png

改进枚举工具类

改进之后，即可已返回给前端枚举对象，也可以接收对象类型的，也可以接收数值，也可以接收字符串

  1. package com.common.config;
  3. import com.common.interfaces.Dict;
  4. import com.fasterxml.jackson.core.JsonParser;
  5. import com.fasterxml.jackson.databind.BeanProperty;
  6. import com.fasterxml.jackson.databind.DeserializationContext;
  7. import com.fasterxml.jackson.databind.JavaType;
  8. import com.fasterxml.jackson.databind.JsonDeserializer;
  9. import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
  10. import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
  12. import java.io.IOException;
  14. /**
  15.  * 枚举反序列化器
  16.  */
  17. public class DictEnumDeserializer extends StdDeserializer<Dict> implements ContextualDeserializer {
  19.     public DictEnumDeserializer() {
  20.         super((JavaType) null);
  21.     }
  23.     public DictEnumDeserializer(JavaType valueType) {
  24.         super(valueType);
  25.     }
  27.     @Override
  28.     public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) {
  29.         return new DictEnumDeserializer(property.getType());
  30.     }
  32. // 自定义的反序列化器这个方法，需要传JsonParser
  33.     @Override
  34.     @SuppressWarnings("all")
  35.     public Dict deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
  36.         return (Dict) EnumUtil.match((Class) _valueClass, p);
  37.     }
  38. }
  40. package com.common.config;
  42. import com.common.interfaces.Dict;
  43. import com.fasterxml.jackson.core.JsonParser;
  44. import com.fasterxml.jackson.core.JsonToken;
  46. import java.io.IOException;
  47. import java.util.Arrays;
  48. import java.util.Map;
  49. import java.util.Objects;
  50. import java.util.concurrent.ConcurrentHashMap;
  51. import java.util.stream.Collectors;
  53. /**
  54.  * 枚举匹配工具类
  55. * 改进的枚举工具
  56.  */
  57. public class EnumUtil {
  59.     private static final Map<Class<? extends Enum<?>>, Map<Integer, ? extends Enum<? extends Dict>>> CLASS_ENUM_MAP =
  60.             new ConcurrentHashMap<>(16);
  62.     @SuppressWarnings("unchecked")
  63.     public static <E extends Enum<E> & Dict> E match(Class<E> enumClass, JsonParser jsonParser) throws IOException {
  65.         Integer code = null;
  67.         // 接收数值型的
  68.         if (jsonParser.currentToken() == JsonToken.VALUE_NUMBER_INT){
  69.             code = jsonParser.getValueAsInt();
  71.         // 接收OBJECT类型的参数
  72.         } else if (jsonParser.currentToken() == JsonToken.START_OBJECT){
  73.             while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
  74.                 String fieldname = jsonParser.getCurrentName();
  75.                 if ("code".equals(fieldname)) {
  76.                     jsonParser.nextToken();
  77.                     code = jsonParser.getValueAsInt();
  78.                     break;
  79.                 }
  80.             }
  82.         // 接收字符串类型的，需要判断是纯数字
  83.         }else  if (jsonParser.currentToken() == JsonToken.VALUE_STRING){
  84.             String codestr = jsonParser.getValueAsString();
  85.             if (codestr.matches("^[0-9]*$")) {
  86.                 code = Integer.valueOf(codestr);
  87.             }
  88.         }
  90.         if (Objects.isNull(code)){
  91.             throw new RuntimeException("没有code找不到对应的枚举");
  92.         }
  94.         return getDictEnum(enumClass, code);
  95.     }
  97.     private static <E extends Enum<E> & Dict> E getDictEnum(Class<E> enumClass, Integer type) {
  98.         Map enumMap = CLASS_ENUM_MAP.get(enumClass);
  99.         if (Objects.isNull(enumMap)) {
  100.             Map<Integer, ? extends Enum<? extends Dict>> unmodifiableMap = Arrays.stream(enumClass.getEnumConstants())
  101.                     .collect(Collectors.toMap(obj -> obj.getCode(), v -> v));
  102.             CLASS_ENUM_MAP.putIfAbsent(enumClass, unmodifiableMap);
  103.             E e = (E) unmodifiableMap.get(code);
  105.             if (Objects.isNull(e)){
  106.                 throw new RuntimeException("指定类型code找不到对应的枚举code = " + code);
  107.             }
  108.             return e;
  109.         }
  111.         E e = (E) enumMap.get(code);
  112.         if (Objects.isNull(e)){
  113.             throw new RuntimeException("指定类型code找不到对应的枚举code = " + code);
  114.         }
  115.         return e;
  116.     }
  118. // 原来的方法，只能接收数值code
  119.     /*public static <E extends Enum<E> & Dict> E match(Class<E> enumClass, Integer type) {
  120.         Map enumMap = CLASS_ENUM_MAP.get(enumClass);
  121.         if (Objects.isNull(enumMap)) {
  122.             Map<Integer, ? extends Enum<? extends Dict>> unmodifiableMap = Arrays.stream(enumClass.getEnumConstants())
  123.                     .collect(Collectors.toMap(Dict::getCode, v -> v));
  124.             CLASS_ENUM_MAP.putIfAbsent(enumClass, unmodifiableMap);
  125.             return (E) unmodifiableMap.get(type);
  126.         }
  127.         return (E) enumMap.get(type);
  128.     }*/
  129. }

参考文章

https://developer.aliyun.com/article/979501

http://events.jianshu.io/p/33e537ea6f10

JsonParser的处理

https://blog.csdn.net/band_mmbx/article/details/126749515

发表评论

表情：
评论列表 （有 0 条评论，192人围观）

还没有评论，来说两句吧...

相关阅读

    相关 序列化，反序列化

    序列化： 对象的序列化主要有两种用途： 　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中； 　　2） 在网络上传送对象的字节序列。 　　

    系统管理员系统管理员/ 0 赞/ 519 阅读