springboot中常量枚举的使用及整合mybatis-plus进行枚举类型转换

qq_250056868

已于 2022-02-05 12:27:37 修改

阅读量1.6k

点赞数 1

分类专栏： springboot 文章标签： spring boot java 后端

于 2021-10-23 21:14:16 首次发布

本文链接：https://blog.csdn.net/qq_41604890/article/details/120886519

版权

springboot 专栏收录该内容

40 篇文章 5 订阅

订阅专栏

整合MyBatis-Plus

链接: springboot整合MyBatis-Plus(八).

建表语句

CREATE TABLE `label` (
  `id` int(4) NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `name` varchar(32) DEFAULT NULL COMMENT '名称',
  `sort` int(4) DEFAULT NULL COMMENT '排序号',
  `version` tinyint(4) DEFAULT '1' COMMENT '乐观锁',
  `deleted` tinyint(1) DEFAULT '0',
  `pay_type` varchar(10) DEFAULT NULL COMMENT '支付类型',
  `person_type` varchar(10) DEFAULT NULL COMMENT '学生类型',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8mb4 COMMENT='学生信息表';

基础类准备

/**
 * 通用枚举接口
 * @param <E>
 * @param <T>
 */
public interface BaseEnum<E extends Enum<?>, T> {

     T getValue();

     String getDisplayName();

     static <T extends Enum<T>> T valueOfEnum(Class<T> enumClass, Integer value) {
          if (value == null)
               throw  new IllegalArgumentException("DisplayedEnum value should not be null");
          if (enumClass.isAssignableFrom(BaseEnum.class))
               throw new IllegalArgumentException("illegal DisplayedEnum type");
          T[] enums = enumClass.getEnumConstants();
          for (T t: enums) {
               BaseEnum displayedEnum = (BaseEnum)t;
               if (displayedEnum.getValue().equals(value))
                    return (T) displayedEnum;
          }
          throw new IllegalArgumentException("cannot parse integer: " + value + " to " + enumClass.getName());
     }

}

package com.zm.constant;

public enum PayTypeEnum implements BaseEnum<PayTypeEnum,Integer>{
    /**
     *现金支付（1）
     */
    CASH(1, "现金支付"),
    /**
     * 扫码支付（2）
     */
    SCAN(2, "扫码支付"),
    /**
     * 会员余额支付（3）
     */
    VIP(3, "会员余额支付"),

    ;
    private Integer value;

    private String displayName;

    PayTypeEnum(Integer value,String displayName) {
        this.value=value;
        this.displayName=displayName;
    }

    public Integer getValue() {
        return value;
    }
    public void setValue(Integer value) {
        this.value = value;
    }
    public String getDisplayName() {
        return displayName;
    }
    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }

}

package com.zm.constant;

import com.baomidou.mybatisplus.annotation.IEnum;

public enum PersonType implements IEnum<Integer>,BaseEnum {

    student(1, "学生"),

    teacher(2, "教师"),

    ;

    private Integer value;

    private String displayName;

    PersonType(Integer value, String displayName) {
        this.value = value;
        this.displayName = displayName;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    public String getDisplayName() {
        return displayName;
    }

    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }

}

springboot中常量枚举的使用

什么是枚举呢？

   枚举，在数学上是指有穷序列集，就是说某一类东西，能一一列出来。
   比如月份，可以有一月、二月......十二月，不能再多了，星期也是一样的概念。

为什么要使用常量枚举

1.没有魔法值，代码可读性更高
2.将常量定义成一个枚举类,便于管理，有利于后来人维护
3.实现了代码复用

使用枚举的注意事项

在这里插入图片描述

不用枚举编写的代码

    void noEnum(Integer payType){
        if(payType.equals(1)){
            System.out.println("调用现金支付接口");
        }
        if(payType.equals(2)){
            System.out.println("调用扫码支付接口");
        }
        if(payType.equals(3)){
            System.out.println("调用会员余额支付接口");
        }
    }

使用枚举编写的代码

    void yydsEnum(Integer payType){
        if(PayTypeEnum.CASH.getValue().equals(payType)){
            System.out.println("调用现金支付接口");
        }
        if(PayTypeEnum.SCAN.getValue().equals(payType)){
            System.out.println("调用扫码支付接口");
        }
        if(PayTypeEnum.VIP.getValue().equals(payType)){
            System.out.println("调用会员余额支付接口");
        }
    }

mybatis-plus进行枚举类型转换

参考链接

链接: mybatis自定义TypeHandler转换null值为空字符串.
链接: MyBatis自定义类型处理器 TypeHandler.

链接: mybatis枚举自动转换实现.

链接: MyBatis-Plus（十五）通用枚举.

链接: SpringBoot与MybatisPlus3.X整合之通用枚举(十二).

链接: Mybatis类型转换TypeHandler介绍.

说明

自3.1.0开始,可配置默认枚举处理类来省略扫描通用枚举配置默认枚举配置
方式一：使用 @EnumValue 注解枚举属性
方式二：实现 IEnum 接口

mybatis-plus:
  type-enums-package: com.zm.constant # 枚举类的包

方式二

import com.baomidou.mybatisplus.annotation.IEnum;

public enum PersonType implements IEnum<Integer> {

    student(1, "学生"),

    teacher(2, "教师"),

    ;

    private Integer value;

    private String displayName;

    PersonType(Integer value, String displayName) {
        this.value = value;
        this.displayName = displayName;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    public String getDisplayName() {
        return displayName;
    }

    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }

}

package com.zm.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.Version;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;

import com.zm.constant.PayTypeEnum;
import com.zm.constant.PersonType;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 学生信息表
 * </p>
 *
 * @author zhoum
 * @since 2021-10-23
 */
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("label")
public class LabelEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * ID
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 名称
     */
    private String name;

    /**
     * 排序号
     */
    private Integer sort;

    /**
     * 乐观锁
     */
    @Version
    private Integer version;

    @TableLogic
    private Boolean deleted;

    /**
     * 支付类型
     */
    @TableField("pay_type")
    private PayTypeEnum payType;


    /**
     * 学生类型
     */
    @TableField("person_type")
    private PersonType personType;


    /**
     * 创建时间
     */
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    /**
     * 更新时间
     */
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;


}

数据库字段

在这里插入图片描述

import com.zm.entity.LabelEntity;
import com.zm.mapper.LabelMapper;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
class SpringMybatisApplicationTests {

    @Autowired
    private LabelMapper labelMapper;

    @Test
    void contextLoads() {
        LabelEntity labelEntitie = labelMapper.selectById("16");
        System.out.println(labelEntitie);
        System.out.println(labelEntitie.getPayType().getDisplayName());
        System.out.println(labelEntitie.getPersonType().getDisplayName());

    }


}

通用的枚举自定义转换器

yml配置

mybatis-plus:
  type-handlers-package: com.zm.typeHandler #自定义的转换器

package com.zm.typeHandler;

import com.zm.constant.BaseEnum;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedTypes;

import java.lang.reflect.Field;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * 通用BaseTypeHandler使用注解@MappedTypes
 *
 * @param <E>
 */
@MappedTypes(value = {BaseEnum.class})
public class PayTypeHandler<E extends Enum<E>> extends BaseTypeHandler<E> {

    private Class<E> type;

    public PayTypeHandler(Class<E> type) {
        this.type = type;
    }

    /**
     * 通过属性名获取属性值  忽略大小写
     *
     * @param o
     * @param name
     * @return
     * @throws Exception
     */

    public static Object getFieldValue(Object o, String name) throws Exception {
        Field[] fields = o.getClass().getDeclaredFields();
        Object object = null;
        for (Field field : fields) {
            field.setAccessible(true);//可以获取到私有属性
            if (field.getName().toUpperCase().equals(name.toUpperCase())) {
                object = field.get(o);
                break;
            }
        }
        return object;
    }

    private E getE(int i) {
        E[] enumConstants = type.getEnumConstants();
        for (E enumConstant : enumConstants) {
            try {
                if (String.valueOf(i).equals(String.valueOf(getFieldValue(enumConstant, "value")))) {
                    return enumConstant;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 用于在Mybatis获取数据结果集时如何把数据库类型转换为对应的Java类型
     * @param rs 当前的结果集
     * @param columnName 当前的字段名称
     * @return 转换后的Java对象
     * @throws SQLException
     */
    @Override
    public E getNullableResult(ResultSet rs, String columnName) throws SQLException {
        // 根据数据库存储类型决定获取类型
        int i = rs.getInt(columnName);
        if (rs.wasNull()) {
            return null;
        } else {
            return getE(i);
        }
    }

    /**
     * 用于在Mybatis通过字段位置获取字段数据时把数据库类型转换为对应的Java类型
     * @param rs 当前的结果集
     * @param columnIndex 当前字段的位置
     * @return 转换后的Java对象
     * @throws SQLException
     */
    @Override
    public E getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        int i = rs.getInt(columnIndex);
        if (rs.wasNull()) {
            return null;
        } else {
            return getE(i);
        }
    }

    /**
     * 用于Mybatis在调用存储过程后把数据库类型的数据转换为对应的Java类型
     * @param cs 当前的CallableStatement执行后的CallableStatement
     * @param columnIndex 当前输出参数的位置
     * @return
     * @throws SQLException
     */
    @Override
    public E getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        int i = cs.getInt(columnIndex);
        if (cs.wasNull()) {
            return null;
        } else {
            return getE(i);
        }
    }


    /**
     * 用于定义在Mybatis设置参数时该如何把Java类型的参数转换为对应的数据库类型
     * @param ps 当前的PreparedStatement对象
     * @param i 当前参数的位置
     * @param parameter 当前参数的Java对象
     * @param jdbcType 当前参数的数据库类型
     * @throws SQLException
     */
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, E parameter, JdbcType jdbcType) throws SQLException {
        // baseTypeHandler已经帮我们做了parameter的null判断
        try {
            ps.setInt(i, (int) getFieldValue(parameter, "value"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

    <resultMap type="com.zm.entity.LabelEntity" id="labelMap">
        <result column="pay_type" property="payType" typeHandler="com.zm.typeHandler.PayTypeHandler" javaType=" com.zm.constant.PayTypeEnum" />
    </resultMap>

import com.zm.constant.PayTypeEnum;
import com.zm.constant.PersonType;
import com.zm.entity.LabelEntity;
import com.zm.mapper.LabelMapper;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
class SpringMybatisApplicationTests {

    @Autowired
    private LabelMapper labelMapper;

    @Test
    void contextLoads() {
        LabelEntity labelEntitie = labelMapper.selectById("16");
        System.out.println(labelEntitie);
        System.out.println(labelEntitie.getPayType().getDisplayName());
        System.out.println(labelEntitie.getPersonType().getDisplayName());

        labelEntitie.setPayType(PayTypeEnum.SCAN);
        labelEntitie.setPersonType(PersonType.student);
        labelMapper.updateById(labelEntitie);
        System.out.println(labelEntitie);
        System.out.println(labelEntitie.getPayType().getDisplayName());
        System.out.println(labelEntitie.getPersonType().getDisplayName());
    }


}

参考json反序列化扩展，可以定制类型转换逻辑

将前端传的数值转换为VO类中的枚举

链接: 整合SpringMVC之自定义JSON序列化器和反序列化器-枚举转换.

qq_250056868

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
springboot中常量枚举的使用及整合mybatis-plus进行枚举类型转换

https://mybatis.org/mybatis-3/configuration.html#typeHandlershttps://www.cnblogs.com/liwanping/p/11147161.html
复制链接

扫一扫