给mybatis添加自动建表,自动加字段的功能

以前项目用惯了hibernate,jpa,它有个自动建表功能,只要在PO里加上配置就可以了,感觉很爽. 但现在用mybatis,发现没有该功能,每次都加个字段,还是要重新改表结构,我个人认为很麻烦. 上网找了一下,发现有个开源的actable,但是这个不好用,不符合实际项目要求。 开源的actable会自动删除表字段,更改表类型,更改表长度,但实际项目中,只允许自动创建表,加表字段即可,改长度,删字段这些都会有风险,不符合实际意义的,而且该开源库使用其来比较复杂 没办法,唯有自己拿过来改造。

  • 首先定义字段的通用类
@Data
public  abstract class CommonColumn implements ICommonColumn {

    /**
     * 字段类型
     */
    private String type;

    /**
     * 字段长度
     */
    private int length=0;

    /**
     *  字段名
     */
    private String name;
    /**
     * decimalLength
     */
    private  int decimalLength=0;

    /**
     * 是否为可以为null,true是可以,false是不可以,默认为true
     */
    private boolean nullValue=true;


    /**
     * 是否是主键,默认false
     */
    private boolean key=false;


    /**
     * 是否自动递增,默认false 只有主键才能使用
     */
    private boolean autoIncrement=false;

    /**
     * 默认值,默认为“”
     */
    private String defaultValue="";
 
}

上述类,注册了字段的通用类型,继承该类,我们生成StringColumn,LongColumn等类型

@Data
public class LongColumn extends CommonColumn {


    public LongColumn() {
        this.setType("bigint");
        this.setLength(16);
    }

 
}

该类限定了String 对应的数据库类型及长度,将上述所有字段类注册到工厂中

public class ColumnFactory {
    public static Map<String, Class<CommonColumn>> columnMap = new HashMap<>();

    static {
        add(Date.class.getName(), DateColumn.class);
        add(Double.class.getName(), DoubleColumn.class);
        add(Integer.class.getName(), IntegerColumn.class);
        add(int.class.getName(), IntegerColumn.class);
        add(Long.class.getName(), LongColumn.class);
        add(long.class.getName(), LongColumn.class);
        add(boolean.class.getName(), BooleanColumn.class);
        add(Boolean.class.getName(), BooleanColumn.class);
        add(String.class.getName(), StringColumn.class);


    }

    /**
     * 增加字段类型
     *
     * @param javaType
     * @param columnClass
     */
    public static void add(String javaType, Class columnClass) {
        columnMap.put(javaType, columnClass);
    }

    public static Class<CommonColumn> getCommonColumn(
            String javaType) {

        return columnMap.get(javaType);
    }
}

-生成建表,加字段的mapper

public interface CreateMysqlTablesMapper {

    /**
     * 根据结构注解解析出来的信息创建表
     * @param tableSql
     */
    public void createTable(TableSql tableSql);

    /**
     * 根据表名查询表在库中是否存在,存在返回1,不存在返回0
     * @param tableName 表结构的map
     * @return 存在返回1,不存在返回0
     */
    public int findTableCountByTableName(@Param("tableName") String tableName);
    
    /**
     * 根据表名查询库中该表的字段结构等信息
     * @param tableName 表结构的map
     * @return 表的字段结构等信息
     */
    public List<String> findTableEnsembleByTableName(@Param("tableName") String tableName);
    
    /**
     * 增加字段
     * @param tableSql
     */
    public void addTableField(TableSql tableSql);
    
    /**
     * 根据表名删除表
     * @param tableName 表结构的map
     */
    public void dorpTableByName(@Param("tableName") String tableName);
}

处理表与字段的SQL如下

<mapper namespace="com.starmark.actable.mapper.CreateMysqlTablesMapper">
    <!-- 抽取出来的公共部分 -->
    <sql id="commonSql">
            `${fields.fieldName}` ${fields.fieldType}
    </sql>
    <!-- 创建表的 -->
    <select id="createTable" parameterType="com.starmark.actable.table.TableSql">
            create table `${name}`(
            <foreach collection="columnSqls" item="fields" separator=",">
                <include refid="commonSql"></include>
            </foreach>
            <if test="primaryKey">
                ,PRIMARY KEY (`${primaryKey}`)
            </if>
            );
    </select>
    
    <!-- 验证表是否存在 -->
    <select id="findTableCountByTableName" resultType="int" parameterType="String">
        select count(1) from information_schema.tables
        where table_name = #{tableName} and table_schema = (select database())
    </select>
    
    <!-- 根据表名查询表的结构 -->
    <select id="findTableEnsembleByTableName"    resultType="java.lang.String" parameterType="String">
        select column_name  from information_schema.columns where table_name = #{tableName} and table_schema = (select database())
    </select>
    
    <!-- 增加字段 -->
    <select id="addTableField" parameterType="com.starmark.actable.table.TableSql">
        <foreach collection="columnSqls" index="key" item="fields" separator=";" close=";">
                alter table `${name}` add
                <include refid="commonSql"></include>
        </foreach>
    </select>
    
    <!-- 验证表是否存在 -->
    <select id="dorpTableByName" parameterType="String">
        DROP TABLE IF EXISTS `${tableName}`;
    </select>
    
</mapper>
  • 核心处理类方法如下: 先查出要添加表的记录或加字段的表
  /**
     * 构建出全部表的增删改的map
     *
     * @param classes     从包package中获取所有的Class
     * @param newTableMap 用于存需要创建的表名+结构
     * @param addTableMap 用于存需要增加字段的表名+结构
     */
    private void allTableMapConstruct(Set<Class<?>> classes,
                                      Map<String, List<CommonColumn>> newTableMap,
                                      Map<String, List<CommonColumn>> addTableMap) throws InstantiationException, IllegalAccessException {
        for (Class<?> clas : classes) {

            String tableName = this.getTableName(clas);
            // 用于存新增表的字段
            List<CommonColumn> newFieldList = new ArrayList<CommonColumn>();
            // 用于存新增的字段
            List<CommonColumn> addFieldList = new ArrayList<CommonColumn>();
            // 迭代出所有model的所有fields存到newFieldList中
            tableFieldsConstruct(clas, newFieldList);

            // 如果配置文件配置的是create,表示将所有的表删掉重新创建
            if ("create".equals(actableConfig.getTableAuto())) {
                createMysqlTablesMapper.dorpTableByName(tableName);
            }
            // 先查该表是否以存在
            int exist = createMysqlTablesMapper.findTableCountByTableName(tableName);
            // 不存在时
            if (exist == 0) {
                newTableMap.put(tableName, newFieldList);
            } else {
                // 已存在时理论上做修改的操作,这里查出该表的结构
                List<String> columnNames = createMysqlTablesMapper
                        .findTableEnsembleByTableName(tableName);

                // 验证对比从model中解析的fieldList与从数据库查出来的columnList
                // 1. 找出增加的字段

                buildAddFields(
                        newFieldList, addFieldList,
                        columnNames);
                if(addFieldList.size()>0) {
                    addTableMap.put(tableName, addFieldList);
                }
            }
        }
    }

    /**
     * 构建增加的删除的修改的字段
     *
     * @param newFieldList 用于存新增表的字段
     * @param addFieldList 用于存新增的字段
     * @param columnNames  从sysColumns中取出我们需要比较的列的List
     */
    private void buildAddFields(List<CommonColumn> newFieldList, List<CommonColumn> addFieldList,
                                List<String> columnNames) {
        for (CommonColumn commonColumn : newFieldList) {
            if (!this.isExistField(columnNames, commonColumn)) {
                addFieldList.add(commonColumn);
            }
        }
    }

    /**
     * 判断字段是否已经存在了
     *
     * @param columnNames
     * @param commonColumn
     * @return
     */
    private boolean isExistField(List<String> columnNames, CommonColumn commonColumn) {
        for (String columnName : columnNames) {
            if (commonColumn.getName().equalsIgnoreCase(columnName)) {
                return true;
            }
        }

        return false;
    }


    /**
     * 迭代出所有model的所有fields存到newFieldList中
     *
     * @param clas         准备做为创建表依据的class
     * @param newFieldList 用于存新增表的字段
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    private void tableFieldsConstruct(Class<?> clas,
                                      List<CommonColumn> newFieldList) throws IllegalAccessException, InstantiationException {
        Field[] fields = clas.getDeclaredFields();
        // 判断是否有父类,如果有拉取父类的field,这里只支持多层继承
        fields = recursionParents(clas, fields);
        for (Field field : fields) {
            Column column = field.getAnnotation(Column.class);
            // 注解,不需要的字段
            if (column!=null&&column.isIgnore()) {
                continue;
            }
            Class<CommonColumn> commonColumnClass = ColumnFactory.getCommonColumn(field.getType().getName());
            CommonColumn commonColumn =   commonColumnClass.newInstance();
            //设置字段
            if(column!=null&&StringUtils.isNoneEmpty(column.name())){
                commonColumn.setName(column.name());
            } else {
                //获取字段名称
                String fieldName = CamelCaseUtil.humpToLine2(field.getName());
                commonColumn.setName(fieldName);
            }
            //设置字段类型
            if(column!=null&&StringUtils.isNoneEmpty(column.type())){
                commonColumn.setType(column.type());
            }

            //设置长度
            if(column!=null&&column.length()>0){
                commonColumn.setLength(column.length());
            }
            //设置长度
            if(column!=null&&column.length()>0){
                commonColumn.setDecimalLength(column.decimalLength());
            }
            //设置自增
            if(column!=null&&column.isAutoIncrement()){
                commonColumn.setAutoIncrement(column.isAutoIncrement());
            }
            //设置自增
            if(column!=null&&column.isAutoIncrement()){
                commonColumn.setAutoIncrement(column.isAutoIncrement());
            }
            //是否为空
            if(column!=null&&!column.isNull()){
                commonColumn.setNullValue(column.isNull());
            }
            //是否主键
            if(column!=null&&!column.isKey()){
                commonColumn.setKey(column.isKey());
            }
            //设置字段类型
            if(column!=null&&StringUtils.isNoneEmpty(column.defaultValue())){
                commonColumn.setDefaultValue(column.defaultValue());
            }
            newFieldList.add(commonColumn);

        }
    }

    /**
     * 递归扫描父类的fields
     *
     * @param clas   类
     * @param fields 属性
     */
    @SuppressWarnings("rawtypes")
    private Field[] recursionParents(Class<?> clas, Field[] fields) {
        if (clas.getSuperclass() != null) {
            Class clsSup = clas.getSuperclass();
            fields = (Field[]) ArrayUtils.addAll(fields, clsSup.getDeclaredFields());
            fields = recursionParents(clsSup, fields);
        }
        return fields;
    }

    /**
     * 根据传入的map创建或修改表结构
     *
     * @param newTableMap 用于存需要创建的表名+结构
     * @param addTableMap 用于存需要增加字段的表名+结构
     */
    private void createOrModifyTableConstruct(Map<String, List<CommonColumn>> newTableMap,
                                              Map<String, List<CommonColumn>> addTableMap) {
        // 1. 创建表
        createTableByMap(newTableMap);
        // 2. 添加新的字段
        addFieldsByMap(addTableMap);
    }


    /**
     * 根据map结构对表中添加新的字段
     *
     * @param addTableMap 用于存需要增加字段的表名+结构
     */
    private void addFieldsByMap(Map<String, List<CommonColumn>> addTableMap) {
        // 做增加字段操作
        if (addTableMap.size() > 0) {
            for (Entry<String, List<CommonColumn>> entry : addTableMap.entrySet()) {
                List<CommonColumn> columnList= entry.getValue();
                for(CommonColumn column:columnList) {
                    //因为mysql一次只能执行一条sql
                    List<CommonColumn> fieldList=new ArrayList<CommonColumn>();
                    fieldList.add(column);
                    TableSql tableSql = this.getTableSql(entry.getKey(), fieldList);

                    log.info("开始为表" + entry.getKey() + "增加字段"+column.getName());
                    createMysqlTablesMapper.addTableField(tableSql);
                    log.info("完成为表" + entry.getKey() + "增加字段"+column.getName());
                }
            }
        }
    }


    /**
     * 根据map结构创建表
     *
     * @param newTableMap 用于存需要创建的表名+结构
     */
    private void createTableByMap(Map<String, List<CommonColumn>> newTableMap) {
        // 做创建表操作
        if (newTableMap.size() > 0) {
            for (Entry<String, List<CommonColumn>> entry : newTableMap.entrySet()) {
                TableSql tableSql = this.getTableSql(entry.getKey(), entry.getValue());
                log.info("开始创建表:" + entry.getKey());
                createMysqlTablesMapper.createTable(tableSql);
                log.info("完成创建表:" + entry.getKey());
            }
        }
    }

    /**
     * 构造执行的SQL
     *
     * @param tableName
     * @param columns
     * @return
     */
    private TableSql getTableSql(String tableName, List<CommonColumn> columns) {
        TableSql tableSql = new TableSql();
        tableSql.setName(tableName);
        List<String> primaryKeys =this.getPrimaryKey(columns);
        List<ColumnSql> columnSqls = new ArrayList<ColumnSql>();
        for (CommonColumn column : columns) {
            columnSqls.add(new ColumnSql(column,primaryKeys));
        }
        tableSql.setPrimaryKey(StringUtils.join(primaryKeys,","));
        tableSql.setColumnSqls(columnSqls);
        return tableSql;
    }

上述代码为相关核心代码,如开源的actable一样,支技自动建表,自动加字段,有hiberate的created,update,none三种处理。 该代码因为限定了各种字段对应的数据库字段,可以不在PO上加任何信息,自动根据PO生成相关表。 真正使用时,我也自定义了注解类,让特殊情况时,可以自动定义对象的长度及数据为字段类型。

`// 该注解用于方法声明
@Target(ElementType.FIELD)
// VM将在运行期也保留注释,因此可以通过反射机制读取注解的信息
@Retention(RetentionPolicy.RUNTIME)
// 将此注解包含在javadoc中
@Documented
// 允许子类继承父类中的注解
@Inherited
public @interface Column {


    /**
     * 字段名
     * 
     * @return 字段名
     */
    public String name()  default  "";

    /**
     * 字段类型
     * 
     * @return 字段类型
     */
    public String type() default  "";

    /**
     * 字段长度,默认是255
     * 
     * @return 字段长度,默认是255
     */
    public int length() default 0 ;

    /**
     * 小数点长度,默认是0
     * 
     * @return 小数点长度,默认是0
     */
    public int decimalLength()  default 0  ;

    /**
     * 是否为可以为null,true是可以,false是不可以,默认为true
     * 
     * @return 是否为可以为null,true是可以,false是不可以,默认为true
     */
    public boolean isNull()  default true  ;

    /**
     * 是否是主键,默认false
     * 
     * @return 是否是主键,默认false
     */
    public boolean isKey() default false  ;

    /**
     * 是否自动递增,默认false 只有主键才能使用
     * 
     * @return 是否自动递增,默认false 只有主键才能使用
     */
    public boolean isAutoIncrement() default  false ;

    /**
     * 默认值,默认为null
     * 
     * @return 默认值,默认为null
     */
    public String defaultValue() default "";


    /**忽略该字段,不自动生成数据库字段
     * @return
     */
    public boolean isIgnore() default false ;
}

真正使用时,只需要一个PO就能生成想要的表,这个配合mybtais plus ,用,真的爽歪歪了。 示例PO如下:

@Data
public class Person {
    /** 唯一标识 */
    private Long id;

    /** 姓名 */
    private String name;

    /** 年龄 */
    private int age;

    /** 描述 */
    private String description;

    private Date birthDate;

    private boolean valid;

    /**
     * 自定义字段
     */
    @Column(name="larget_text",type="text")
    private String textContent;

    /**
     * 该字段不自动生成
     */
    @Column(isIgnore = true)
    private String loginName;
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

编辑于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏码农分享

SQL Server 多表数据增量获取和发布 4

最关键的在于获取捕获表信息(系统表中间_CT结尾的数据)。 根据网上资料查取,找到了获取当前捕获表时间区间范围内数据的方式。 见[SQL Server 多表...

1432
来自专栏程序员的SOD蜜

左求值表达式,堆栈,调试陷阱与ORM查询语言的设计

1,表达式的求值顺序与堆栈结构 “表达式” 是程序语言一个很重要的术语,也是大家天天写的程序中很常见的东西,但是表达式的求值顺序一定是从左到右么? C/C++语...

3266
来自专栏chenssy

【死磕Sharding-jdbc】---group by结果合并(2)

在sharding-jdbc源码之group by结果合并(1)中主要分析了sharding-jdbc如何在GroupByStreamResultSetMerg...

992
来自专栏码匠的流水账

聊聊kafka的partition分配

本文主要研究一下kafka的partition分配,主要是key到parition的映射,partition对consumer的分配,以及partition的r...

2721
来自专栏我叫刘半仙

原自己手写一个Mybatis框架(简化)

       继上一篇手写SpringMVC之后,我最近趁热打铁,研究了一下Mybatis。MyBatis框架的核心功能其实不难,无非就是动态代理和jdbc的操...

1.9K6
来自专栏鸿的学习笔记

Python写的Python解释器(二)

玩具解释器 首先从一个玩具解释器开始,这个微型解释器只能做加法,而且值包含了三个指令,这三个指令是:

912
来自专栏MasiMaro 的技术博文

windows 纤程

纤程本质上也是线程,是多任务系统的一部分,纤程为一个线程准并行方式调用多个不同函数提供了一种可能,它本身可以作为一种轻量级的线程使用。它与线程在本质上没有区别,...

1612
来自专栏简书专栏

Python程序结构2

上面一段代码的运行结果如下,从下面的结果可以看出速度差距为2、3倍左右,当数据量更大时,可能差距更大。:

1083
来自专栏Java成神之路

HQL语句大全

Hibernate配备了一种非常强大的查询语言,这种语言看上去很像SQL。但是不要被语法结构 上的相似所迷惑,HQL是非常有意识的被设计为完全面向对象的查询,它...

1495
来自专栏AhDung

【SQL】小心字符串拼接导致长度爆表

别想当然以为它会返回8002,而是8000,select @max也只会得到8000个a,后面两个b没了。我们知道,varchar(max)类型不受字符数限制,...

1553

扫码关注云+社区

领取腾讯云代金券