• 使用枚举Enum代替Integer类型

    一、问题

    虽然项目使用了枚举类Enum，来替代原来的Constant常量类，但Java对象的入参仍然是Integer类型，顶多再加个 {@link } 说明它是对应哪个枚举。

    但这仍然无法限制传入的值不会乱传。要是有人不写{@link } 或者{@link } 写错，那更死。

    二、实现效果

    1、最开始使用常量类的写法：（我觉得这种写法最烦的一点就是，如果常量类定义了Integer类型，就没法使用switch case来做判断)

    1. import com.aa.docking.common.DataDictionary;
    2. import lombok.Data;
    3.  
    4. @Data
    5. public class DataReq {
    6.     /**
    7.      * 模式类型 {@link DataDictionary.ManageMode}
    8.      */
    9.     private Integer modeType;
    10. }
    11.  
    12. /**
    13.  * 数据字典
    14.  */ 
    15. public class DataDictionary {
    16.    /**
    17.     * 模式类型
    18.     */
    19.    public class ManageMode {
    20.       /**
    21.        * 模式一
    22.        */ 
    23.       public static final Integer MODE_1 = 1;
    24.       /**
    25.        * 模式二
    26.        */
    27.       public static final Integer MODE_2 = 2;
    28.    }
    29. }

    2、改进以后使用枚举的写法：

    1. import lombok.Data;
    2. import com.aa.docking.module.amc.enums.outside.ManagementModeEnum;
    3.  
    4. @Data
    5. public class DataReq {
    6.     /**
    7.      * 模式类型 {@link ManagementModeEnum}
    8.      */
    9.     private Integer modeType;
    10. }
    11.  
    12.  
    13. import lombok.AllArgsConstructor;
    14. import lombok.Getter;
    15. import lombok.experimental.Accessors;
    16. @Getter
    17. @Accessors(fluent = true)
    18. @AllArgsConstructor
    19. public enum ManagementModeEnum {
    20.     MODE_1(1, "模式一"),
    21.     MODE_2(2, "模式二"),
    22.  
    23.     ;
    24.  
    25.     /**
    26.      * 字典码值
    27.      */
    28.     private Integer code;
    29.     /**
    30.      * 字典描述
    31.      */
    32.     private String desc;
    33.  
    34. }

    3、改进以后使用枚举代替Integer类型的写法：

    1. import com.aa.docking.module.amc.enums.outside.ManagementModeEnum;
    2. import lombok.Data;
    3.  
    4. @Data
    5. public class DataReq {
    6.     /**
    7.      * 模式类型
    8.      */
    9.     private ManagementModeEnum modeType;
    10. }

    但存在一个问题，传参的时候需要传入一个枚举对象，否则匹配不到：

    1. {
    2.   "modeType": {
    3.      "code": 1
    4.   }
    5. }

    我想要像原来一样直接传Integer类型就能匹配到枚举类：

    1. {
    2.   "modeType": 1
    3. }

    要怎么实现呢？继续往下看：

    三、什么是序列化和反序列化

    1）序列化过程：把一个 Java 对象变成二进制内容（byte[]数组）存储起来。这里的存储方式可能是存储到磁盘中，也可能是发布到网络中。

    一个 Java 对象要能序列化，必须实现一个特殊的java.io.Serializable接口。

    Serializable 没有定义任何方法，它是一个空接口。这样的空接口称为“标记接口”(Marker Interface)，实现了标记接口的类仅仅是给自身贴了个“标记”，并没有增加任何方法。

    1. package java.io;
    2.  
    3. public interface Serializable {
    4. }

    2) 反序列化过程：把一个二进制内容（byte[]数组）变回 Java 对象。

    有了反序列化，保存到磁盘中的 byte[] 又可以“变回” Java 对象，或者从网络上读取 byte[] 并把它“变回” Java 对象。

    四、自定义序列化和反序列规则

    1、首先定义接口IDictEnum（所有枚举类都要去实现该接口）

    指定反序列化的方法：EnumJsonDeserializer

    指定序列化的方法：EnumJsonSerializer

    1. import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
    2. import com.fasterxml.jackson.databind.annotation.JsonSerialize;
    3.  
    4. /**
    5.  * @description: 数据字典公共接口
    6.  */
    7. @JsonDeserialize(using = EnumJsonDeSerializer.class)
    8. @JsonSerialize(using = EnumJsonSerializer.class)
    9. public interface IDictEnum {
    10.     /**
    11.      * 获得字典码值
    12.      */
    13.     Integer code();
    14.  
    15.     /**
    16.      * 获得字典描述, 这里不能用name, 因为java.lang.Enum已经定义了name
    17.      */
    18.     String desc();
    19.  
    20. }

    2、反序列化方法：EnumJsonDeserializer

    1. import com.fasterxml.jackson.core.JsonParser;
    2. import com.fasterxml.jackson.core.JsonStreamContext;
    3. import com.fasterxml.jackson.databind.*;
    4. import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
    5.  
    6. import java.io.IOException;
    7. import java.util.Arrays;
    8.  
    9. /**
    10.  * @description: 数据字典枚举反序列化
    11.  * @see springboot项目中枚举类型的最佳实践
    12.  */
    13. public class EnumJsonDeSerializer extends JsonDeserializer implements ContextualDeserializer {
    14.  
    15.     private Classextends IDictEnum> clazz;
    16.  
    17.     public EnumJsonDeSerializer() {
    18.     }
    19.  
    20.     public EnumJsonDeSerializer(Class clazz) {
    21.         this.clazz = clazz;
    22.     }
    23.  
    24.     @Override
    25.     public IDictEnum deserialize(JsonParser jsonParser, DeserializationContext ctxt) throws IOException {
    26.         String param = jsonParser.getText();
    27.         IDictEnum[] enumConstants = clazz.getEnumConstants();
    28.         JsonStreamContext parsingContext = jsonParser.getParsingContext();
    29.         IDictEnum iDictEnum = Arrays.stream(enumConstants)
    30.                 .filter(x -> {
    31.                     //x.toString(),取枚举的具体值，如：xxx.enums.share.DelFlagEnum 枚举里的“NOT_DELETE”
    32.                     //从而使得两种形式都能识别
    33.                     String enumCodeStr = x.toString();
    34.                     return enumCodeStr.equals(param) || param.equals(x.code() + "");
    35.                 })
    36.                 .findFirst()
    37.                 .orElse(null);
    38.         /*if (null == iEnum) {
    39.             String msg = String.format("枚举类型%s从%s未能转换成功", clazz.toString(), param);
    40.             throw new Exception(msg);
    41.         }*/
    42.         return iDictEnum;
    43.     }
    44.  
    45.     @Override
    46.     public Class handledType() {
    47.         return IDictEnum.class;
    48.     }
    49.  
    50.     @SuppressWarnings({"unchecked"})
    51.     @Override
    52.     public JsonDeserializer createContextual(DeserializationContext ctxt, BeanProperty property)
    53.             throws JsonMappingException {
    54.         JavaType type = property.getType();
    55.         // 如果是容器，则返回容器内部枚举类型
    56.         while (type.isContainerType()) {
    57.             type = type.getContentType();
    58.         }
    59.         return new EnumJsonDeSerializer((Classextends IDictEnum>) type.getRawClass());
    60.     }
    61. }

    3、序列化方法：EnumJsonSerializer

    1. import com.fasterxml.jackson.core.JsonGenerator;
    2. import com.fasterxml.jackson.databind.JsonSerializer;
    3. import com.fasterxml.jackson.databind.SerializerProvider;
    4.  
    5. import java.io.IOException;
    6.  
    7. /**
    8.  * @description: 数据字典枚举序列化
    9.  * @see springboot项目中枚举类型的最佳实践
    10.  */
    11. public class EnumJsonSerializer extends JsonSerializer {
    12.  
    13.     @Override
    14.     public void serialize(IDictEnum iDictEnum, JsonGenerator generator, SerializerProvider provider) throws IOException {
    15.         // 序列化只要code的值
    16.         generator.writeNumber(iDictEnum.code());
    17.         // 序列化形式: {"code": "", "desc": ""}
    18.         //generator.writeStartObject();
    19.         //generator.writeNumberField("code", iBaseDict.code());
    20.         //generator.writeStringField("desc", iBaseDict.desc());
    21.         //generator.writeEndObject();
    22.     }
    23.  
    24.     @Override
    25.     public Class handledType() {
    26.         return IDictEnum.class;
    27.     }
    28. }

    4、我们前面创建的枚举类，需要去实现 IDictEnum接口

    1. import com.aa.docking.base.common.enums.IDictEnum;
    2. import lombok.AllArgsConstructor;
    3. import lombok.Getter;
    4. import lombok.experimental.Accessors;
    5.  
    6. @Getter
    7. @Accessors(fluent = true)
    8. @AllArgsConstructor
    9. public enum ManagementModeEnum implements IDictEnum {
    10.     MODE_1(1, "模式一"),
    11.     MODE_2(2, "模式二"),
    12.  
    13.     ;
    14.  
    15.     /**
    16.      * 字典码值
    17.      */
    18.     private Integer code;
    19.     /**
    20.      * 字典描述
    21.      */
    22.     private String desc;
    23.  
    24. }

    5、这样就搞定啦！！经验证，还支持List，Map等复杂的传参形式哦！！

    1. @Data
    2. public class NeighInfoPageReq {
    3.     private ManagementModeEnum modeType;
    4.     private List modeTypeList;
    5.     private Map map1;
    6. }

    传参只要带Integer类型就能匹配到枚举类啦^_^

    1. {
    2.     "modeType": 1,
    3.     "modeTypeList": [1, 2]
    4.     "map1": {
    5.       "模式一", 1,
    6.       "模式二", 2
    7.     }
    8. }

    6、假如枚举值传错了要怎么判断呢？加上validation的@NotNull就可以啦。此时如果传“managementMode”: 3 就会报错。

    1. import lombok.Data;
    2. import javax.validation.constraints.NotNull;
    3.  
    4. @Data
    5. public class NeighInfoPageReq {
    6.     /**
    7.      * 模式类型
    8.      */
    9.     @NotNull(message = "模式不能为空或码值不正确")
    10.     private ManagementModeEnum modeType;
    11. }

    五、mybatis枚举序列化和反序列化处理

    1、mybatis有自己的一套序列化反序列化规则，所以我们还需要使用@MappedTypes，单独针对IDictEnum定义一套规则。

    1. package com.aa.docking.base.common.enums;
    2.  
    3. import com.aa.docking.base.common.util.EnumUtil;
    4. import org.apache.ibatis.type.BaseTypeHandler;
    5. import org.apache.ibatis.type.JdbcType;
    6. import org.apache.ibatis.type.MappedTypes;
    7.  
    8. import java.sql.CallableStatement;
    9. import java.sql.PreparedStatement;
    10. import java.sql.ResultSet;
    11. import java.sql.SQLException;
    12.  
    13. /**
    14.  * @description: mybatis自定义枚举类型转换
    15.  * @see springboot + mybatis 自定义枚举类型转换
    16.  */
    17. @MappedTypes({IDictEnum.class})
    18. public class EnumTypeHandlerextends Enum & IDictEnum> extends BaseTypeHandler {
    19.     private Class type;
    20.  
    21.     public EnumTypeHandler(Class type) {
    22.         if (type == null) {
    23.             throw new IllegalArgumentException("Type argument cannot be null.");
    24.         }
    25.         this.type = type;
    26.     }
    27.  
    28.     /**
    29.      * 用于定义设置参数时，该如何把Java类型的参数转换为对应的数据库类型
    30.      */
    31.     @Override
    32.     public void setNonNullParameter(PreparedStatement ps, int i, IDictEnum parameter, JdbcType jdbcType)
    33.             throws SQLException {
    34.         ps.setInt(i, parameter.code());
    35.     }
    36.  
    37.     /**
    38.      * 用于定义通过字段名称获取字段数据时，如何把数据库类型转换为对应的Java类型
    39.      */
    40.     @Override
    41.     public E getNullableResult(ResultSet rs, String columnName) throws SQLException {
    42.         int code = rs.getInt(columnName);
    43.         return rs.wasNull() ? null : codeOf(code);
    44.     }
    45.  
    46.     /**
    47.      * 用于定义通过字段索引获取字段数据时，如何把数据库类型转换为对应的Java类型
    48.      */
    49.     @Override
    50.     public E getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
    51.         int code = rs.getInt(columnIndex);
    52.         return rs.wasNull() ? null : codeOf(code);
    53.     }
    54.  
    55.     /**
    56.      * 用定义调用存储过程后，如何把数据库类型转换为对应的Java类型
    57.      */
    58.     @Override
    59.     public E getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
    60.         int code = cs.getInt(columnIndex);
    61.         return cs.wasNull() ? null : codeOf(code);
    62.     }
    63.  
    64.     private E codeOf(int code) {
    65.         try {
    66.             return EnumUtil.getEnumByCode(type, code);
    67.         } catch (Exception ex) {
    68.             throw new IllegalArgumentException("Cannot convert " + code + " to " + type.getSimpleName() + " by code value.", ex);
    69.         }
    70.     }
    71. }

    这里的EnumUtil:

    1. import com.aa.docking.base.common.enums.IDictEnum;
    2. import org.apache.commons.lang3.StringUtils;
    3.  
    4. /**
    5.  * @description: 公共枚举方法
    6.  * @see 枚举Enum使用范例-公共枚举方法
    7.  */
    8. public class EnumUtil {
    9.  
    10.     /**
    11.      * 根据code获取枚举
    12.      */
    13.     public static extends IDictEnum> T getEnumByCode(Class tClass, Integer code) {
    14.         if (code != null) {
    15.             for (T t : tClass.getEnumConstants()) {
    16.                 if (t.code().equals(code)) {
    17.                     return t;
    18.                 }
    19.             }
    20.         }
    21.         return null;
    22.     }
    23.  
    24.     /**
    25.      * 根据desc获取枚举
    26.      */
    27.     public static extends IDictEnum> T getEnumByDesc(Class tClass, String desc) {
    28.         if (StringUtils.isNotBlank(desc)) {
    29.             for (T t : tClass.getEnumConstants()) {
    30.                 if (t.desc().equals(desc)) {
    31.                     return t;
    32.                 }
    33.             }
    34.         }
    35.         return null;
    36.     }
    37.  
    38.     /**
    39.      * 根据code获取desc
    40.      */
    41.     public static extends IDictEnum> String getDescByCode(Class tClass, Integer code) {
    42.         T t = getEnumByCode(tClass, code);
    43.         if (null != t) {
    44.             return t.desc();
    45.         }
    46.         return null;
    47.     }
    48.  
    49.     /**
    50.      * 根据desc获取code
    51.      */
    52.     public static extends IDictEnum> Integer getCodeByDesc(Class tClass, String desc) {
    53.         T t = getEnumByDesc(tClass, desc);
    54.         if (null != t) {
    55.             return t.code();
    56.         }
    57.         return null;
    58.     }
    59. }

    2、配置文件里面还需要定义mybatis的typeHandler扫描包路径：

    1. # mybatis配置参数
    2. mybatis:
    3.   # 定义typeHandler扫描包路径
    4.   type-handlers-package: com.aa.docking

    是不是很棒*_^

  • 相关阅读:
    【C++】C++中的IO流
    Linux系统调优详解（四）——内存状态查看命令
    Java编程练习题Demo61-Demo70
    31.JavaScript数组进阶，一网打尽数组操作函数slice、filter、map、reduce、some、every、find、splice
    论如何自研电动车控制器
    打击勒索病毒：防御.kat6.l6st6r勒索病毒的最佳策略
    李沐：机器学习者进阶学习建议
    中国生态功能保护区shp数据
    C语言动态内存管理、柔性数组（超详细版）
    Flutter-无限循环滚动标签
  • 原文地址：https://blog.csdn.net/why_su/article/details/133739639