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

其他 2020-05-28 10:45:41 阅读次数: 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文件中配置即可

    自己需要指定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的，谢谢观赏

猜你喜欢

转载自blog.csdn.net/JavaWeb_Hao/article/details/87562269
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
基本数据类型封装类比较 Java源码解读(一) 8种基本类型对应的封装类型
JS实现无缝滚动上
深入解析HashMap原理（基于JDK1.8）
mysql的连接池
关于.htc
linux下的ubuntu12.04图形界面
【数论】好推不好记的扩展欧几里德
设备树详解
cscope + tags 简单设置
xml学习
每日归档
更多
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022