我用过的mybatisplus处理枚举过程

我用过的mybatisplus处理枚举过程，这里作一个记录，方便自己后面用到时，借鉴。

1：我的枚举都继承一个BaseEnum接口。

2：我写了一个枚举的类型转化工厂，BaseEnumConverterFactory工厂类。

3：在我的ObjectMapper中使用了这个枚举类的序列化和反序列化。 然后将ObjectMapper放入mybatis中的typeHandler中。

晒第一步代码：

public interface BaseEnum {

    String getDesc();

    default Serializable getValue(){
        return ((Enum) this).ordinal();
    }

    default Map<String,Object> toMap(){
        TreeMap<String, Object> map = new TreeMap<>();
        map.put("value", getValue());
        map.put("desc", getDesc());
        return map;
    }

}

我的实体类中的枚举都是要继承此枚举的。如：

@Slf4j
public enum  PayType implements BaseEnum {
    ALI("支付宝"),WX("微信");

    private String desc;

    PayType(String desc) {
        this.desc = desc;
    }

    @Override
    public String getDesc() {
        return desc;
    }

    public static PayType valueOf2(Integer fromType){
        if(Objects.equals(Constants.FLOW_ACCOUNT_ALI,fromType)){
            return ALI;
        }else if(Objects.equals(Constants.FLOW_ACCOUNT_WX,fromType)){
            return WX;
        }
        log.error("不支持的支付类型{}",fromType);
        return null;
    }
}

我的实体类中使用枚举：

@ApiModelProperty("支付状态:0.支付宝，1.微信")
private PayType payType;

第二步枚举类型转化工厂类：

package com.qianda.mall.common.config.converter;

import com.qianda.mall.common.enums.BaseEnum;
import com.qianda.mall.common.enums.store.SaleType;
import org.springframework.core.convert.converter.Converter;
import org.springframework.core.convert.converter.ConverterFactory;
import org.springframework.util.Assert;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author heqiwen
 * @version 1.0
 * @since 2020/11/10
 */
public class BaseEnumConverterFactory implements ConverterFactory<String, BaseEnum> {

    private static final Map<Class,SerializableToBaseEnum> converterMap = new ConcurrentHashMap<Class,SerializableToBaseEnum>();

    public static final BaseEnumConverterFactory INSTANCE = new BaseEnumConverterFactory();

    @Override
    public <T extends BaseEnum> Converter<String, T> getConverter(Class<T> targetType) {
        Class<?> enumType = getEnumType(targetType);
        SerializableToBaseEnum toBaseEnum = converterMap.get(enumType);
        if(null == toBaseEnum){
            toBaseEnum = new SerializableToBaseEnum(enumType);
            converterMap.put(enumType, toBaseEnum);
        }
        return toBaseEnum;
    }

    private static class SerializableToBaseEnum<T extends Enum & BaseEnum> implements Converter<Serializable, T> {

        private final Map<Serializable,T> enumMap;
        private final Class<T> enumType;
        public SerializableToBaseEnum(Class<T> enumType) {
            this.enumType = enumType;
            enumMap = new HashMap<>();
            for (T t : enumType.getEnumConstants()) {
                enumMap.put(String.valueOf(t.getValue()), t);
            }
        }

        @Override
        public T convert(Serializable source) {
            T t = enumMap.get(String.valueOf(source));
            if(t ==null && source instanceof String){
                Enum.valueOf(enumType,String.valueOf(source));
            }
            return t;
        }
    }


    private static Class<?> getEnumType(Class<?> targetType) {
        Class<?> enumType = targetType;
        while (enumType != null && !enumType.isEnum()) {
            enumType = enumType.getSuperclass();
        }
        Assert.notNull(enumType, () -> "The target type " + targetType.getName() + " does not refer to an enum");
        return enumType;
    }
}

第三步处理ObjectMapper并将它放入typeHandler中。

具体的ObjectMapper bean实例：

package com.qianda.mall.common.config;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.std.EnumDeserializer;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.databind.util.EnumResolver;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.qianda.mall.common.config.converter.BaseEnumConverterFactory;
import com.qianda.mall.common.enums.BaseEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.StringUtils;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDateTime;

import static com.fasterxml.jackson.databind.DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS;
import static com.macro.mall.common.util.DateFormatters.local_datetime_formatter;

/**
 * @author heqiwen    这里处理枚举的逻辑是：
 * @version 1.0
 * @since 2020/11/4
 */
@Configuration
public class JacksonConfig {

    @Bean
    @ConditionalOnMissingBean(ObjectMapper.class)
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder)
    {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        // 全局配置序列化返回 JSON 处理
        SimpleModule simpleModule = new SimpleModule();
        //JSON Long ==> String
        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
        simpleModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(local_datetime_formatter));
        simpleModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(local_datetime_formatter));
        //序列化枚举，  因为每个枚举都继承了BaseEnum。
        simpleModule.addSerializer(BaseEnum.class, new JsonSerializer<BaseEnum>() {
            @Override
            public void serialize(BaseEnum value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                gen.writeObject(value.getValue());
            }
        });
        simpleModule.addSerializer(BigDecimal.class, ToStringSerializer.instance);
        /*
        * TODO 类型条件限定过宽且仅做了名称处理 ，这里处理枚举的反序列化。
        * */
        simpleModule.addDeserializer(Enum.class, new CommonDeserializer());
        objectMapper.registerModule(simpleModule);
        return objectMapper;
    }


    public static class CommonDeserializer extends JsonDeserializer implements ContextualDeserializer {
        private final Class<BaseEnum> aClass;
        private static BaseEnumConverterFactory baseEnumConverterFactory = BaseEnumConverterFactory.INSTANCE;
        public CommonDeserializer(Class<BaseEnum> aClass) {
            this.aClass = aClass;
        }

        public CommonDeserializer() {
            aClass = null;
        }

        @Override
        public BaseEnum deserialize(JsonParser jsonParser, DeserializationContext ctx) throws IOException {
            if(StringUtils.isEmpty(jsonParser.getText())){
                return null;
            }
            return baseEnumConverterFactory.getConverter(aClass).convert(jsonParser.getText());
        }

        public JsonDeserializer createContextual(DeserializationContext ctx, BeanProperty property) throws JsonMappingException {
            Class rawCls = ctx.getContextualType().getRawClass();
            if(BaseEnum.class.isAssignableFrom(rawCls)){
                return new CommonDeserializer(rawCls);
            }
            return new EnumDeserializer(EnumResolver.constructFor((Class<Enum<?>>) rawCls, ctx.getConfig().getAnnotationIntrospector()),true);
        }
    }
}

然后要将这个ObjectMapper放入TypeHandler中。

package com.macro.mall.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * MyBatis相关配置
 * Created by heqiwen on 2019/4/8.
 */
@Configuration
@EnableTransactionManagement
@MapperScan({"com.macro.mall.mapper","com.macro.mall.dao","com.qianda.mall.store.mapper"})
public class MyBatisPlusConfig {

    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    /**
     * 将这里的ObjectMapper设置到JacksonTypeHandler中。
     * @param objectMapper
     */
    @Autowired
    public void autowiredObjectMapper(ObjectMapper objectMapper){
        JacksonTypeHandler.setObjectMapper(objectMapper);
    }

}

到此我的枚举就配置完了。

比较好的typeHandler说明可以参考其它人的地址：https://blog.youkuaiyun.com/yelangkingwuzuhu/article/details/109943552