SpringBoot自定义类型java类型并使用

秒速五厘米 2022-03-19 16:11 299阅读 0赞

一、序言

可能Java的八种基本数据类型有时候并不能够满足我们的需求，我们可以通过自定一些数据类型来解决这个问题，毕竟自己做项目基本上八种基本数据类型是足够了，但是为了满足公司的某些方面需求，我们不得不寻求方法解决这个问题。

springboot+mybatis

二、分析

要实现使用自定义的数据类型，我们需要解决几个问题：

1、自定义的数据类型怎么和数据库打交道呢，数据库只识别八种基本数据类型

2、使用了自定义的数据类型，我们在代码中怎么使用呢

3、一般前端需要的是key:value样式的json串，我们又怎么将自定义的数据类型转为想要的结果呢

三、解决问题

1、先说说怎么使用自定义类型定义属性

（1）首先为自定义数据类型定义一个父类，至于为什么定义一个父类是有原因的，首先，我们可以将各个自定义的数据类型的公共属性写道父类中，减少代码量，也增加可读性以及简约性，另外就是在使用的时候，我们可以通过反射得到对应的相对应的自定义数据类型，但是我们使用什么来接呢，这时候我们就可以使用该父类来接受，如果获取公共属性的属性值，可以直接获取到。

@Data
    public class CommonTypeBase {
        private String name;
        private String description;
        private String help;
        private String compute;
        private boolean store;
        private boolean required;
        private boolean readonly;
        private boolean copy;
        private Object value;
    }

写个String的变种吧

@Data
    public class CommonTypeString extends CommonTypeBase implements Serializable {
        private String default_value;
        private String [] selection;
    
    
        public CommonTypeString(String name, String description, String help, String compute, boolean store, boolean required, boolean readonly, boolean copy, String [] selection, String default_value, Object value) {
            super(name, description, help, compute, store, required, readonly, copy, value);
            this.default_value = default_value;
            this.selection = selection;
        }
    
        public CommonTypeString() {
            super();
        }
    }

如果我想要获取一个实体类的某个属性的value值，我就可以使用   CommonTypeBase来接受得到value值，但是如果我想要获取default\_value值，我之恶能够通过反射得到

同样我们使用自定义数据类型时我们也可以使用继承来实现，至于为什么使用继承道理和上面一样

@Data
    public class BaseModelDto {
        private CommonTypeInteger id=new CommonTypeInteger("id",null,null,null,true,false,true,true,null,false);
        @TableField("create_uid")
        private CommonTypeInteger create_uid=new CommonTypeInteger("create_uid",null,null,null,true,true,true,false,null,false);
        @TableField("create_date")
        private CommonTypeDateTime create_date=new CommonTypeDateTime("create_date",null,null,null,true,true,true,false,null,false);
        @TableField("write_uid")
        private CommonTypeInteger write_uid=new CommonTypeInteger("write_uid",null,null,null,true,true,true,false,null,false);
        @TableField("write_date")
        private CommonTypeDateTime write_date=new CommonTypeDateTime("write_date",null,null,null,true,true,true,false,null,false);
    
    }

定义实体类

@Data
    @TableName("res_users")
    public class Users extends BaseModelDto {
    
        private CommonTypeBoolean active=new CommonTypeBoolean("active",null,null,null,true,false,false,true,false ,false);
    
    
        private CommonTypeString login=new CommonTypeString("login",null,null,null,true,true,true,false,null,null ,false);
        private CommonTypeString password=new CommonTypeString("password",null,null,null,true,true,true,false,null,null ,false);
    }

哈哈，到现在应该知道怎么使用自定义数据类型来定义实体类了吧

2、将自定义的数据类型转为基本数据类型和数据库打交道

mybatis已经为我们想到了这个问题，自然页提供了解决方法

首先我们需要提供每个自定义类型（基本数据类型的变种）的handler类，还拿String打比喻

@MappedJdbcTypes(JdbcType.VARCHAR)
    @MappedTypes(CommonTypeString.class)
    public class StringTypeHandler extends BaseTypeHandler {
        @Override
        public void setNonNullParameter(PreparedStatement preparedStatement, int i, Object o, JdbcType jdbcType) throws SQLException {
            String value = (String)o;
            CommonTypeString cts = new CommonTypeString();
            cts.setValue(value);
            preparedStatement.setString(i,value);
        }
    
        @Override
        public Object getNullableResult(ResultSet resultSet, String s) throws SQLException {
            String str = resultSet.getString(s);
            CommonTypeString cts = new CommonTypeString();
            cts.setValue(str);
            if (StringUtils.isBlank(str)) return null;
            return cts;
        }
    
        @Override
        public Object getNullableResult(ResultSet resultSet, int i) throws SQLException {
            String str = resultSet.getString(i);
            CommonTypeString cts = new CommonTypeString();
            cts.setValue(str);
            if (StringUtils.isBlank(str)) return null;
            return cts;
        }
    
        @Override
        public Object getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
            String str = callableStatement.getString(i);
            CommonTypeString cts = new CommonTypeString();
            cts.setValue(str);
            if (StringUtils.isBlank(str)) return null;
            return cts;
        }
    }

从代码中就可以看到解决方法，那就是继承mybatis为我们提供的BaseTypeHandler抽象类，另外通过两个注解指定自定义数据类型和数据库的类型的对应关系，并且实现相对应的方法，我们数据库中查询出来的值就是在这里解决的。

先不要太高兴，到目前我们只是书写了基本数据类型和自定义数据类型的转换的handler类，我们还要指定哪些时handler，所以我们还需要指定handler的位置，在application.yml文件中配置即可

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phdmFXZWJfSGFv_size_16_color_FFFFFF_t_70][]

自己需要指定handler所在的包名即可

3、从前端传过来的是属性名称，我们又是怎么获取属性的值

如果前端需要active的值，怎么办，这时我可以通过实体类的全路名通过反射得到实体类的class，然后通过反射获取到active的get方法，就可以得到active的自定义数据类型，我们就可以使用自定义的数据类型的父类CommonTypeBase来接，然后通过反射得到自定义数据类型中的任意一个值，当然我们是想要获取自定义数据类型中的value值，我是不需要通过反射，而是通过刚刚得到的CommonTypeBase类获取getValue()值，如果想要的值不在公共属性的CommonTypeBase中，需要反射得到。

4、将结果传给前端，我们肯定不能什么事都让前端来做，我们需要将自定义数据类型进行转换

这一步就是将自定义的数据类型转为java的基本数据类型

@Configuration
    public class JacksonConfig {
        /**
         * 自定义CommonTypeString类型序列化规则
         */
        static class CommonTypeStringSerializer extends JsonSerializer<CommonTypeString> {
            @Override
            public void serialize(CommonTypeString value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeBoolean类型序列化规则
         */
        static class CommonTypeBooleanSerializer extends JsonSerializer<CommonTypeBoolean> {
            @Override
            public void serialize(CommonTypeBoolean value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeDate类型序列化规则
         */
        static class CommonTypeDateSerializer extends JsonSerializer<CommonTypeDate> {
            @Override
            public void serialize(CommonTypeDate value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");//2019-02-14 10:15:03
                if (null != value && null != value.getValue()) {
                    gen.writeObject(dateFormat.format((java.sql.Date) value.getValue()));
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeDateTime类型序列化规则
         */
        static class CommonTypeDateTimeSerializer extends JsonSerializer<CommonTypeDateTime> {
            @Override
            public void serialize(CommonTypeDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//2019-02-14
                if (null != value && null != value.getValue()) {
                    gen.writeObject(dateFormat.format((java.sql.Date) value.getValue()));
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeDouble类型序列化规则
         */
        static class CommonTypeDoubleSerializer extends JsonSerializer<CommonTypeDouble> {
            @Override
            public void serialize(CommonTypeDouble value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeFloat类型序列化规则
         */
        static class CommonTypeFloatSerializer extends JsonSerializer<CommonTypeFloat> {
            @Override
            public void serialize(CommonTypeFloat value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeInteger类型序列化规则
         */
        static class CommonTypeIntegerSerializer extends JsonSerializer<CommonTypeInteger> {
            @Override
            public void serialize(CommonTypeInteger value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeObject类型序列化规则
         */
        static class CommonTypeObjectSerializer extends JsonSerializer<CommonTypeObject> {
            @Override
            public void serialize(CommonTypeObject value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeM2O类型序列化规则
         */
        static class CommonTypeM2OSerializer extends JsonSerializer<CommonTypeM2O> {
            @Override
            public void serialize(CommonTypeM2O value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeM2M类型序列化规则
         */
        static class CommonTypeM2MSerializer extends JsonSerializer<CommonTypeM2M> {
            @Override
            public void serialize(CommonTypeM2M value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        /**
         * 自定义CommonTypeO2M类型序列化规则
         */
        static class CommonTypeO2MSerializer extends JsonSerializer<CommonTypeO2M> {
            @Override
            public void serialize(CommonTypeO2M value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                if (null != value && null != value.getValue()) {
                    gen.writeObject(value.getValue());
                } else {
                    gen.writeObject(false);
                }
            }
        }
    
        @Bean
        public SimpleModule simpleModule() {
            SimpleModule module = new SimpleModule();
            //声明序列化类
            CommonTypeStringSerializer serializer_string = new CommonTypeStringSerializer();
            CommonTypeBooleanSerializer serializer_boolean = new CommonTypeBooleanSerializer();
            CommonTypeDateSerializer serializer_date = new CommonTypeDateSerializer();
            CommonTypeDoubleSerializer serializer_double = new CommonTypeDoubleSerializer();
            CommonTypeFloatSerializer serializer_float = new CommonTypeFloatSerializer();
            CommonTypeIntegerSerializer serializer_integer = new CommonTypeIntegerSerializer();
            CommonTypeObjectSerializer serializer_object = new CommonTypeObjectSerializer();
            CommonTypeM2OSerializer serializer_m2o = new CommonTypeM2OSerializer();
            CommonTypeM2MSerializer serializer_m2m = new CommonTypeM2MSerializer();
            CommonTypeO2MSerializer serializer_o2m = new CommonTypeO2MSerializer();
            CommonTypeDateTimeSerializer serializer_datetime = new CommonTypeDateTimeSerializer();
    
            //添加序列化，哪个类型对应哪个序列化类
            module.addSerializer(CommonTypeString.class, serializer_string);
            module.addSerializer(CommonTypeBoolean.class, serializer_boolean);
            module.addSerializer(CommonTypeDate.class, serializer_date);
            module.addSerializer(CommonTypeDouble.class, serializer_double);
            module.addSerializer(CommonTypeFloat.class, serializer_float);
            module.addSerializer(CommonTypeInteger.class, serializer_integer);
            module.addSerializer(CommonTypeObject.class, serializer_object);
            module.addSerializer(CommonTypeM2O.class, serializer_m2o);
            module.addSerializer(CommonTypeM2M.class, serializer_m2m);
            module.addSerializer(CommonTypeO2M.class, serializer_o2m);
            module.addSerializer(CommonTypeDateTime.class, serializer_datetime);
    
            return module;
        }
    
    }

该配置类就是在SpringBoot的@ResponseBody的返回json串时执行并转换的

四、总结

到目前为止，差不多已经讲解完成，因为时间问题，暂时不能够整理一个demo给大家分享，因为公司项目需要保密不能够给大家分享，但是一旦有时间，我会给带啊整理一个demo的，谢谢观赏

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phdmFXZWJfSGFv_size_16_color_FFFFFF_t_70]: /images/20220319/286fbf2c5b1a434182c3bdf37c172a94.png