以前项目用惯了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;
}
如果想要完整的代码，请打赏一注彩票钱再联系我。
