以前項目用慣了hibernate,jpa,它有個自動建表功能，只要在PO里加上配置就可以了，感覺很爽.
但現(xiàn)在用mybatis,發(fā)現(xiàn)沒有該功能，每次都加個字段，還是要重新改表結構，我個人認為很麻煩.
上網(wǎng)找了一下，發(fā)現(xiàn)有個開源的actable，但是這個不好用，不符合實際項目要求。
開源的actable會自動刪除表字段，更改表類型，更改表長度，但實際項目中，只允許自動創(chuàng)建表，加表字段即可，改長度，刪字段這些都會有風險，不符合實際意義的,而且該開源庫使用其來比較復雜
沒辦法，唯有自己拿過來改造。
- 首先定義字段的通用類
@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 對應的數(shù)據(jù)庫類型及長度，將上述所有字段類注冊到工廠中
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 {
/**
* 根據(jù)結構注解解析出來的信息創(chuàng)建表
* @param tableSql
*/
public void createTable(TableSql tableSql);
/**
* 根據(jù)表名查詢表在庫中是否存在，存在返回1，不存在返回0
* @param tableName 表結構的map
* @return 存在返回1，不存在返回0
*/
public int findTableCountByTableName(@Param("tableName") String tableName);
/**
* 根據(jù)表名查詢庫中該表的字段結構等信息
* @param tableName 表結構的map
* @return 表的字段結構等信息
*/
public List<String> findTableEnsembleByTableName(@Param("tableName") String tableName);
/**
* 增加字段
* @param tableSql
*/
public void addTableField(TableSql tableSql);
/**
* 根據(jù)表名刪除表
* @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>
<!-- 創(chuàng)建表的 -->
<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>
<!-- 根據(jù)表名查詢表的結構 -->
<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 用于存需要創(chuàng)建的表名+結構
* @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，表示將所有的表刪掉重新創(chuàng)建
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與從數(shù)據(jù)庫查出來的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);
}
}
}
/**
* 判斷字段是否已經(jīng)存在了
*
* @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 準備做為創(chuàng)建表依據(jù)的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;
}
/**
* 根據(jù)傳入的map創(chuàng)建或修改表結構
*
* @param newTableMap 用于存需要創(chuàng)建的表名+結構
* @param addTableMap 用于存需要增加字段的表名+結構
*/
private void createOrModifyTableConstruct(Map<String, List<CommonColumn>> newTableMap,
Map<String, List<CommonColumn>> addTableMap) {
// 1. 創(chuàng)建表
createTableByMap(newTableMap);
// 2. 添加新的字段
addFieldsByMap(addTableMap);
}
/**
* 根據(jù)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一次只能執(zhí)行一條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());
}
}
}
}
/**
* 根據(jù)map結構創(chuàng)建表
*
* @param newTableMap 用于存需要創(chuàng)建的表名+結構
*/
private void createTableByMap(Map<String, List<CommonColumn>> newTableMap) {
// 做創(chuàng)建表操作
if (newTableMap.size() > 0) {
for (Entry<String, List<CommonColumn>> entry : newTableMap.entrySet()) {
TableSql tableSql = this.getTableSql(entry.getKey(), entry.getValue());
log.info("開始創(chuàng)建表：" + entry.getKey());
createMysqlTablesMapper.createTable(tableSql);
log.info("完成創(chuàng)建表：" + entry.getKey());
}
}
}
/**
* 構造執(zhí)行的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三種處理。
該代碼因為限定了各種字段對應的數(shù)據(jù)庫字段，可以不在PO上加任何信息，自動根據(jù)PO生成相關表。
真正使用時，我也自定義了注解類，讓特殊情況時，可以自動定義對象的長度及數(shù)據(jù)為字段類型。
`// 該注解用于方法聲明
@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 ;
/**
* 小數(shù)點長度，默認是0
*
* @return 小數(shù)點長度，默認是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 "";
/**忽略該字段，不自動生成數(shù)據(jù)庫字段
* @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;
}
如果想要完整的代碼，請打賞一注彩票錢再聯(lián)系我。
