• MyBatis-plus+注解形式实现项目与数据库绑定动态更新

    前言：在自己电脑上使用mybatis-plus生成映射数据库表的实体类，将项目上传到服务器启动时根据实体类自动创建、更新相应的数据库表，这样做的目的是使得在自己电脑上创建数据库表后不用再到服务器去创建

     实现思路：

    1. 使用mybatis-plus生成实体类
    2. 在生成实体类的时候获取类字段信息并通过注解的形式写入到实体类里面去
    3. 在服务器启动项目的时候获取项目的所有实体类与数据库所有表进行对比，解析实体类上注解信息，写入特定的类用于将数据库没有对应的表进行创建

    详细步骤

    1.配置mybatis-plus自动生成代码

       依赖mybatis-plus   

    2. <dependency>
    3.     <groupId>com.baomidougroupId>
    4.     <artifactId>mybatis-plusartifactId>
    5.     <version>2.3version>
    6. dependency>
    7. <dependency>
    8.     <groupId>com.baomidougroupId>
    9.     <artifactId>mybatisplus-spring-boot-starterartifactId>
    10.     <version>1.0.5version>
    11. dependency>
    13. <dependency>
    14.     <groupId>org.freemarkergroupId>
    15.     <artifactId>freemarkerartifactId>
    16. dependency>
    18. <dependency>
    19.     <groupId>org.apache.velocitygroupId>
    20.     <artifactId>velocity-engine-coreartifactId>
    21.     <version>2.0version>
    22. dependency>

     配置

    1. mybatis-plus:
    2.   mapper-locations: classpath*:/mapper/*/*Mapper.xml
    3.   global-config:
    4.     id-type: 3
    5.     field-strategy: 2
    6.     db-column-underline: true
    7.     refresh-mapper: true
    8.   configuration:
    9.     map-underscore-to-camel-case: true
    10.     cache-enabled: true
    11.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

     代码生成器

    MpGenerator.java

    1. import com.baomidou.mybatisplus.enums.FieldFill;
    2. import com.baomidou.mybatisplus.enums.IdType;
    3. import com.baomidou.mybatisplus.exceptions.MybatisPlusException;
    4. import com.baomidou.mybatisplus.generator.AutoGenerator;
    5. import com.baomidou.mybatisplus.generator.InjectionConfig;
    6. import com.baomidou.mybatisplus.generator.config.*;
    7. import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
    8. import com.baomidou.mybatisplus.generator.config.po.TableField;
    9. import com.baomidou.mybatisplus.generator.config.po.TableFill;
    10. import com.baomidou.mybatisplus.generator.config.po.TableInfo;
    11. import com.baomidou.mybatisplus.generator.config.rules.DbColumnType;
    12. import com.baomidou.mybatisplus.generator.config.rules.DbType;
    13. import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    14. import com.baomidou.mybatisplus.toolkit.StringUtils;
    15.  
    16. import java.sql.Connection;
    17. import java.sql.PreparedStatement;
    18. import java.sql.ResultSetMetaData;
    19. import java.sql.SQLException;
    20. import java.util.*;
    21.  
    22. public class MpGenerator {
    23.  
    24.     /**
    25.      * 
    26.      * 读取控制台内容
    27.      * 
    28.      */
    29.     public String scanner(String tip) {
    30.         Scanner scanner = new Scanner(System.in);
    31.         StringBuilder help = new StringBuilder();
    32.         help.append("请输入" + tip + "：");
    33.         System.out.println(help.toString());
    34.         if (scanner.hasNext()) {
    35.             String ipt = scanner.next();
    36.             if (StringUtils.isNotEmpty(ipt)) {
    37.                 return ipt;
    38.             }
    39.         }
    40.         throw new MybatisPlusException("请输入正确的" + tip + "！");
    41.     }
    42.  
    43.     private int type;
    44.  
    45.  
    46.  
    47.     public PackageConfig getPackageConfig() {
    48.         PackageConfig pc = new PackageConfig();
    49.         if (type == 3) {
    50.             pc.setParent("com.wdz.tofs");
    51.         } else {
    52.             pc.setParent("com.wdz");
    53.         }
    54.         pc.setModuleName(scanner("模块名"));
    55.         pc.setEntity("entity");
    56.         pc.setController(null);
    57.         return pc;
    58.     }
    59.     /**
    60.      * 获取表字段信息
    61.      */
    62.     public ResultSetMetaData getMetaData(DataSourceConfig dsc,String tableName){
    63.         Connection connection = dsc.getConn();
    64.         try {
    65.             try (PreparedStatement preparedStatement = connection.prepareStatement("select * from " + tableName)) {
    66.                 return preparedStatement.executeQuery().getMetaData();
    67.             }
    68.         } catch (SQLException e) {
    69.             e.printStackTrace();
    70.             return null;
    71.         }
    72.     }
    73.     /**
    74.      * 
    75.      * MySQL 生成演示
    76.      * 
    77.      */
    78.     public static void main(String[] args) {
    79.         AutoGenerator mpg = new AutoGenerator();
    80.         MpGenerator mpGenerator = new MpGenerator();
    81.         // 选择 freemarker 引擎，默认 Veloctiy
    82.         //mpg.setTemplateEngine(new FreemarkerTemplateEngine());
    83.         // 全局配置
    84.         GlobalConfig gc = new GlobalConfig();
    85.         gc.setOpen(false);//完成后不打开文件夹
    86.         gc.setAuthor("autor");
    87.         String oPath = System.getProperty("user.dir");//得到当前项目的路径
    88.         gc.setOutputDir(oPath + "/core_database/src/main/java/");   //生成文件输出根目录
    89.         gc.setFileOverride(false);// 是否覆盖同名文件，默认是false
    90.         gc.setActiveRecord(true);// 不需要ActiveRecord特性的请改为false
    91.         gc.setEnableCache(false);// XML 二级缓存
    92.         gc.setBaseResultMap(true);// XML ResultMap
    93.         gc.setBaseColumnList(false);// XML columList
    94.         gc.setIdType(IdType.UUID);
    95.         mpg.setGlobalConfig(gc);
    96.  
    97.         // 数据源配置
    98.         DataSourceConfig dsc = new DataSourceConfig();
    99.         dsc.setDbType(DbType.MYSQL);
    100.         dsc.setTypeConvert(new MySqlTypeConvert() {
    101.             // 自定义数据库表字段类型转换【可选】
    102.             @Override
    103.             public DbColumnType processTypeConvert(String fieldType) {
    104.                 // 注意！！processTypeConvert 存在默认类型转换，如果不是你要的效果请自定义返回、非如下直接返回。
    105.                 if (fieldType.equals("datetime")) {
    106.                     fieldType = "String";
    107.                 }
    108.                 System.out.println("转换类型：" + fieldType);
    109.                 return super.processTypeConvert(fieldType);
    110.             }
    111.         });
    112.         dsc.setDriverName("com.mysql.jdbc.Driver");
    113.  
    114.         dsc.setUsername("root");
    115.         dsc.setPassword("00000");
    116.         dsc.setUrl("jdbc:mysql://190.289.20.1:3306/***?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT&allowPublicKeyRetrieval=true");
    117.         mpg.setDataSource(dsc);
    118.         // 包配置
    119.         PackageConfig pc = mpGenerator.getPackageConfig();
    120.         mpg.setPackageInfo(pc);
    121.         // 策略配置
    122.         StrategyConfig strategy = new StrategyConfig();
    123.  
    124.         // strategy.setCapitalMode(true);// 全局大写命名 ORACLE 注意
    125.         strategy.setTablePrefix(new String[]{""});// 此处可以修改为您的表前缀
    126.         //下划线转驼峰命名法
    127.         strategy.setNaming(NamingStrategy.underline_to_camel);// 表名生成策略
    128.         //自动填充设置
    129.         List tableFillList = new ArrayList();
    130.         tableFillList.add(new TableFill("create_date", FieldFill.INSERT));//设置为插入时自动填充
    131.         tableFillList.add(new TableFill("update_date", FieldFill.INSERT_UPDATE));//设置为更新时自动填充
    132.         strategy.setTableFillList(tableFillList);
    133.         strategy.setRestControllerStyle(true);
    134.         String tables = mpGenerator.scanner("表名,以逗号隔开需要生成的表");
    135.         if (tables.length() != 0) {
    136.             if ((tables.charAt(tables.length() - 1)) == ',') {
    137.                 tables = tables.substring(0, tables.length() - 1);
    138.             }
    139.             String[] tabless = tables.split(",");
    140.  
    141.             strategy.setInclude(tabless); // 需要生成的表
    142.         }
    143.         strategy.setControllerMappingHyphenStyle(true);
    144.         mpg.setStrategy(strategy);
    145.  
    146.         // 自定义配置
    147.         InjectionConfig cfg = new InjectionConfig() {
    148.             @Override
    149.             public void initMap() {
    150.                 // to do nothing
    151.                 Map map = new HashMap<>();
    152.                 this.setMap(map);
    153.             }
    154.         };
    155.  
    156.         // 如果模板引擎是 freemarker
    157.         // String templatePath = "/templates/mapper.xml.ftl";
    158.         // 如果模板引擎是 velocity
    159.         String templatePath = "/templates/mapper.xml.vm";
    160.         String entityPath = "/template/entity.java.vm";
    161.         // 自定义输出配置
    162.         List focList = new ArrayList<>();
    163.         // 自定义配置会被优先输出
    164.         focList.add(new FileOutConfig(templatePath) {
    165.             @Override
    166.             public String outputFile(TableInfo tableInfo) {
    167.                 // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
    168.                 List list = tableInfo.getFields();
    169.                 Iterator iterator = list.iterator();
    170.                 ResultSetMetaData resultSetMetaData = mpGenerator.getMetaData(dsc,tableInfo.getName());
    171.                 int i = 1;
    172.                 while (iterator.hasNext()){
    173.                     Map map = new HashMap();
    174.                     try {
    175.                         //在数据库中字符最大长度
    176.                         map.put("length",resultSetMetaData.getColumnDisplaySize(i));
    177.                         //类型
    178.                         map.put("type",resultSetMetaData.getColumnTypeName(i));
    179.                         //是否为null
    180.                         map.put("nullable",resultSetMetaData.isNullable(i));
    181.                     } catch (SQLException e) {
    182.                         e.printStackTrace();
    183.                     }
    184.                     i++;
    185.                     iterator.next().setCustomMap(map);
    186.                 }
    187.                 return oPath + "/core_database/src/main/resources/mapper/" + mpGenerator.change(tableInfo.getEntityName())+ "/"+tableInfo.getEntityName() + "Mapper.xml";
    188.             }
    189.         });
    190.  
    191.         cfg.setFileOutConfigList(focList);
    192.         mpg.setCfg(cfg);
    193.         TemplateConfig tc = new TemplateConfig();
    194.         //不生成controller
    195.         tc.setController(null);
    196.         //不生成xml(xml已经放到resource下面了,这里是不再Java文件夹下面存放了)
    197.         tc.setXml(null);
    198.         mpg.setTemplate(tc);
    199.         // 执行生成
    200.         mpg.execute();
    201.     }
    202.     /**
    203.      * 全部转换为小写
    204.      *
    205.      * @param str 需要转换的参数
    206.      * @return 返回替换后字符串
    207.      */
    208.     private String change(String str) {
    209.         char[] cs = str.toCharArray();
    210.         StringBuilder rstr = new StringBuilder();
    211.         for (char c : cs) {
    212.             //如果输入的是大写，+32即可得到小写
    213.             if (c >= 'A' && c <= 'Z') {
    214.                 c += 32;
    215.             }
    216.             rstr.append(c);
    217.         }
    218.         return rstr.toString();
    219.     }
    220. }

     自定义表信息以及表字段信息注解

    TableInfo（表信息）

    1. import java.lang.annotation.*;
    2.  
    3. /**
    4.  * 表详细信息
    5.  * @author wuchuancheng
    6.  * @since 2022-07-28
    7.  */
    8. @Documented
    9. @Retention(RetentionPolicy.RUNTIME)
    10. @Target(ElementType.TYPE)
    11. public @interface TableInfo {
    12.     /**
    13.      * 表名
    14.      * @return
    15.      */
    16.     String name() default "";
    17.  
    18.     /**
    19.      * 是否需要自动创建
    20.      * @return
    21.      */
    22.     boolean isCreate() default true;
    23.  
    24.     /**
    25.      * 注释
    26.      * @return
    27.      */
    28.     String comment() default "";
    29. }

    ColumnInfo（表字段信息）

    1. import java.lang.annotation.*;
    2.  
    3. /**
    4.  * 表字段详细信息
    5.  * @author wuchuancheng
    6.  * @since 2022-07-28
    7.  */
    8. @Documented
    9. @Retention(RetentionPolicy.RUNTIME)
    10. @Target(ElementType.FIELD)
    11. public @interface ColumnInfo {
    12.  
    13.     /**
    14.      * 字段名
    15.      */
    16.     String name() default "";
    17.  
    18.     /**
    19.      * 字段注释
    20.      */
    21.     String comment() default "";
    22.  
    23.     /**
    24.      * 最大长度
    25.      */
    26.     int length() default 0;
    27.  
    28.     /**
    29.      * 字段类型
    30.      */
    31.     String type() default "";
    32.  
    33.     /**
    34.      * 是否是主键
    35.      */
    36.     boolean key() default false;
    37.  
    38.     /**
    39.      * 是否为空
    40.      */
    41.     int nullable() default 0;
    42. }

    自定义模板

    entity.java.vm（放在resource/template下面）

    1. package ${package.Entity};
    2.  
    3. //这两个改写成你自己的目录
    4. import com.wdz.annotations.ColumnInfo;
    5. import com.wdz.annotations.TableInfo;
    6.  
    7. #foreach($pkg in ${table.importPackages})
    8. import ${pkg};
    9. #end
    10. #if(${entityLombokModel})
    11.  
    12. import com.baomidou.mybatisplus.annotations.Version;
    13.  
    14. import lombok.Data;
    15. import lombok.EqualsAndHashCode;
    16. import lombok.experimental.Accessors;
    17. #end
    18.  
    19. /**
    20.  * 
    21.  * $!{table.comment}
    22.  * 
    23.  *
    24.  * @author ${author}
    25.  * @since ${date}
    26.  */
    27. @TableInfo(name="${table.name}",comment = "${table.comment}")
    28. #if(${entityLombokModel})
    29. @Data
    30. #if(${superEntityClass})
    31. @EqualsAndHashCode(callSuper = true)
    32. #else
    33. @EqualsAndHashCode(callSuper = false)
    34. #end
    35. @Accessors(chain = true)
    36. #end
    37. #if(${table.convert})
    38. @TableName("${table.name}")
    39. #end
    40. #if(${superEntityClass})
    41. public class ${entity} extends ${superEntityClass}#if(${activeRecord})<${entity}>#end {
    42. #elseif(${activeRecord})
    43. public class ${entity} extends Model<${entity}> {
    44. #else
    45. public class ${entity} implements Serializable {
    46. #end
    47.  
    48.     private static final long serialVersionUID = 1L;
    49.  
    50. ## ----------  BEGIN 字段循环遍历  ----------
    51. #foreach($field in ${table.fields})
    52.     #if(${field.keyFlag})
    53. #set($keyPropertyName=${field.propertyName})
    54. #end
    55. #if("$!field.comment" != "")
    56.     /**
    57.      * ${field.comment}
    58.      */
    59. #end
    60. @ColumnInfo(name="${field.name}",comment = "${field.comment}",length = ${field.customMap.length},type = "${field.customMap.type}",key = ${field.keyFlag},nullable = ${field.customMap.nullable})
    61. #if(${field.keyFlag})
    62. ## 主键
    63. #if(${field.keyIdentityFlag})
    64.     @TableId(value = "${field.name}", type = IdType.AUTO)
    65. #elseif(!$null.isNull(${idType}) && "$!idType" != "")
    66.     @TableId(value = "${field.name}", type = IdType.${idType})
    67. #elseif(${field.convert})
    68.     @TableId("${field.name}")
    69. #end
    70. ## 普通字段
    71. #elseif(${field.fill})
    72. ## -----   存在字段填充设置   -----
    73. #if(${field.convert})
    74.     @TableField(value = "${field.name}", fill = FieldFill.${field.fill})
    75. #else
    76.     @TableField(fill = FieldFill.${field.fill})
    77. #end
    78. #elseif(${field.convert})
    79.     @TableField("${field.name}")
    80. #end
    81. ## 乐观锁注解
    82. #if(${versionFieldName}==${field.name})
    83.     @Version
    84. #end
    85. ## 逻辑删除注解
    86. #if(${logicDeleteFieldName}==${field.name})
    87.     @TableLogic
    88. #end
    89.     private ${field.propertyType} ${field.propertyName};
    90. #end
    91. ## ----------  END 字段循环遍历  ----------
    92.  
    93. #if(!${entityLombokModel})
    94. #foreach($field in ${table.fields})
    95. #if(${field.propertyType.equals("boolean")})
    96. #set($getprefix="is")
    97. #else
    98. #set($getprefix="get")
    99. #end
    100.  
    101.     public ${field.propertyType} ${getprefix}${field.capitalName}() {
    102.         return ${field.propertyName};
    103.     }
    104.  
    105. #if(${entityBuilderModel})
    106.     public ${entity} set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
    107. #else
    108.     public void set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
    109. #end
    110.         this.${field.propertyName} = ${field.propertyName};
    111. #if(${entityBuilderModel})
    112.         return this;
    113. #end
    114.     }
    115. #end
    116. #end
    117.  
    118. #if(${entityColumnConstant})
    119. #foreach($field in ${table.fields})
    120.     public static final String ${field.name.toUpperCase()} = "${field.name}";
    121.  
    122. #end
    123. #end
    124. #if(${activeRecord})
    125.     @Override
    126.     protected Serializable pkVal() {
    127. #if(${keyPropertyName})
    128.         return this.${keyPropertyName};
    129. #else
    130.         return null;
    131. #end
    132.     }
    133.  
    134. #end
    135. #if(!${entityLombokModel})
    136.     @Override
    137.     public String toString() {
    138.         return "${entity}{" +
    139. #foreach($field in ${table.fields})
    140. #if($!{velocityCount}==1)
    141.         "${field.propertyName}=" + ${field.propertyName} +
    142. #else
    143.         ", ${field.propertyName}=" + ${field.propertyName} +
    144. #end
    145. #end
    146.         "}";
    147.     }
    148. #end
    149. }

    第一阶段代码生成器的改造基本完成，这一阶段的作用是根据数据库表生成相对应的实体类，实体类里面还有描述实体类的表信息注解以及字段信息注解，如以下代码类似

    1. import com.wdz.annotations.ColumnInfo;
    2.  
    3. import com.baomidou.mybatisplus.annotations.TableField;
    4. import com.baomidou.mybatisplus.enums.FieldFill;
    5. import com.baomidou.mybatisplus.annotations.TableId;
    6. import com.baomidou.mybatisplus.enums.IdType;
    7. import com.baomidou.mybatisplus.activerecord.Model;
    8. import com.baomidou.mybatisplus.annotations.TableName;
    9. import com.wdz.annotations.TableInfo;
    10.  
    11. import java.io.Serializable;
    12.  
    13. /**
    14.  * 
    15.  * 测试
    16.  * 
    17.  *
    18.  * @author wuchuancheng
    19.  * @since 2022-07-28
    20.  */
    21. @TableInfo(name="test",comment = "测试")
    22. @TableName("test")
    23. public class Test extends Model {
    24.  
    25.     private static final long serialVersionUID = 1L;
    26.  
    27.     /**
    28.      * 主键
    29.      */
    30. @ColumnInfo(name="id",comment = "主键",length = 32,type = "VARCHAR",key = true,nullable = 0)
    31.     @TableId(value = "id", type = IdType.UUID)
    32.     private String id;
    33.     /**
    34.      * 测试
    35.      */
    36. @ColumnInfo(name="test",comment = "测试",length = 255,type = "VARCHAR",key = false,nullable = 1)
    37.     private String test;
    38.  
    39.     public String getWay() {
    40.         return way;
    41.     }
    42.  
    43.     public void setWay(String way) {
    44.         this.way = way;
    45.     }
    46.  
    47.     /**
    48.      * 测试way
    49.      */
    50.     @ColumnInfo(name="way",comment = "测试way",length = 255,type = "VARCHAR",key = false,nullable = 1)
    51.     private String way;
    52.     /**
    53.      * 数字
    54.      */
    55. @ColumnInfo(name="ino",comment = "数字",length = 10,type = "INT",key = false,nullable = 1)
    56.     private Integer int1;
    57.     /**
    58.      * 时间
    59.      */
    60. @ColumnInfo(name="create_date",comment = "时间",length = 0,type = "DATETIME",key = false,nullable = 1)
    61.     @TableField(value = "create_date", fill = FieldFill.INSERT)
    62.     private String createDate;
    63.  
    64.  
    65.     public String getId() {
    66.         return id;
    67.     }
    68.  
    69.     public void setId(String id) {
    70.         this.id = id;
    71.     }
    72.  
    73.     public String getTest() {
    74.         return test;
    75.     }
    76.  
    77.     public void setTest(String test) {
    78.         this.test = test;
    79.     }
    80.  
    81.     public Integer getInt1() {
    82.         return int1;
    83.     }
    84.  
    85.     public void setInt1(Integer int1) {
    86.         this.int1 = int1;
    87.     }
    88.  
    89.     public String getCreateDate() {
    90.         return createDate;
    91.     }
    92.  
    93.     public void setCreateDate(String createDate) {
    94.         this.createDate = createDate;
    95.     }
    96.  
    97.     @Override
    98.     protected Serializable pkVal() {
    99.         return this.id;
    100.     }
    101.  
    102.     @Override
    103.     public String toString() {
    104.         return "Test{" +
    105.         ", id=" + id +
    106.         ", test=" + test +
    107.         ", int1=" + int1 +
    108.         ", createDate=" + createDate +
    109.         "}";
    110.     }
    111. }

    另外，mapper.xml会在resource下生成，不会生成controller。

    关键代码解释：

    这一部分的精髓在这里

    1. // 如果模板引擎是 freemarker
    2.         // String templatePath = "/templates/mapper.xml.ftl";
    3.         // 如果模板引擎是 velocity
    4.         String templatePath = "/templates/mapper.xml.vm";
    5.         String entityPath = "/template/entity.java.vm";
    6.         // 自定义输出配置
    7.         List focList = new ArrayList<>();
    8.         // 自定义配置会被优先输出
    9.         focList.add(new FileOutConfig(templatePath) {
    10.             @Override
    11.             public String outputFile(TableInfo tableInfo) {
    12.                 // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
    13.                 List list = tableInfo.getFields();
    14.                 Iterator iterator = list.iterator();
    15.                 ResultSetMetaData resultSetMetaData = mpGenerator.getMetaData(dsc,tableInfo.getName());
    16.                 int i = 1;
    17.                 while (iterator.hasNext()){
    18.                     Map map = new HashMap();
    19.                     try {
    20.                         //在数据库中字符最大长度
    21.                         map.put("length",resultSetMetaData.getColumnDisplaySize(i));
    22.                         //类型
    23.                         map.put("type",resultSetMetaData.getColumnTypeName(i));
    24.                         //是否为null
    25.                         map.put("nullable",resultSetMetaData.isNullable(i));
    26.                     } catch (SQLException e) {
    27.                         e.printStackTrace();
    28.                     }
    29.                     i++;
    30.                     iterator.next().setCustomMap(map);
    31.                 }
    32.                 return oPath + "/core_database/src/main/resources/mapper/" + mpGenerator.change(tableInfo.getEntityName())+ "/"+tableInfo.getEntityName() + "Mapper.xml";
    33.             }
    34.         });

    /templates/mapper.xml.vm模板是在依赖包mybatis-plus-generate下面

    /template/entity.java.vm模板是在自己项目resource下面

     resultSetMetaData对象是表字段信息集合

    1. /**
    2.      * 获取表字段信息
    3.      */
    4.     public ResultSetMetaData getMetaData(DataSourceConfig dsc,String tableName){
    5.         Connection connection = dsc.getConn();
    6.         try {
    7.             try (PreparedStatement preparedStatement = connection.prepareStatement("select * from " + tableName)) {
    8.                 return preparedStatement.executeQuery().getMetaData();
    9.             }
    10.         } catch (SQLException e) {
    11.             e.printStackTrace();
    12.             return null;
    13.         }
    14.     }

    而这一段

    1. while (iterator.hasNext()){
    2.                     Map map = new HashMap();
    3.                     try {
    4.                         //在数据库中字符最大长度
    5.                         map.put("length",resultSetMetaData.getColumnDisplaySize(i));
    6.                         //类型
    7.                         map.put("type",resultSetMetaData.getColumnTypeName(i));
    8.                         //是否为null
    9.                         map.put("nullable",resultSetMetaData.isNullable(i));
    10.                     } catch (SQLException e) {
    11.                         e.printStackTrace();
    12.                     }
    13.                     i++;
    14.                     iterator.next().setCustomMap(map);
    15.                 }

    是将表字段信息写入到实体类里面去，重点在于.setCustomMap();这个方法

    源码

    将几个数据写入 customMap里面去就可以在entity.java.vm里面使用它

     然后就可以生成带有表信息以及表字段信息注解的实体类了

    2.项目启动时创建表

    这一步的关键是要去数据库读取所有表名和项目的实体类名然后进行判断，判断出若项目有某个实体类而数据库没有这张表，就自动创建这张表，所以我自建了Table，FieldInfo和与之对应的TableMapper，FieldInfoMapper类来查询数据库表以及表字段、创建或更新表。创建或更新表也可以直接在mapper.xml里面写sql语句

     封装表信息实体类

    Table.java

    1. import com.baomidou.mybatisplus.activerecord.Model;
    2.  
    3. import java.io.Serializable;
    4. import java.util.List;
    5.  
    6. /**
    7.  * 数据库表名集合
    8.  * @author wuchuancheng
    9.  */
    10. public class Table extends Model {
    11.     private static final long serialVersionUID = 1L;
    12.  
    13.     private String tableName;
    14.  
    15.     private String comment;
    16.  
    17.     private List fieldInfos;
    18.  
    19.     public List getFieldInfos() {
    20.         return fieldInfos;
    21.     }
    22.  
    23.     public void setFieldInfos(List fieldInfos) {
    24.         this.fieldInfos = fieldInfos;
    25.     }
    26.  
    27.     public String getTableName() {
    28.         return tableName;
    29.     }
    30.  
    31.     public String getComment() {
    32.         return comment;
    33.     }
    34.  
    35.     public void setComment(String comment) {
    36.         this.comment = comment;
    37.     }
    38.  
    39.     public void setTableName(String tableName) {
    40.         this.tableName = tableName;
    41.     }
    42.  
    43.     @Override
    44.     protected Serializable pkVal() {
    45.         return serialVersionUID;
    46.     }
    47. }
      48. Mapper
      TableMapper.java
      1. import com.baomidou.mybatisplus.mapper.BaseMapper;
      2. import org.apache.ibatis.annotations.Mapper;
      3. import org.apache.ibatis.annotations.Select;
      4.  
      5. import java.util.List;
      6.  
      7. /**
      8.  * @author wuchuancheng
      9.  */
      10. @Mapper
      11. public interface TableMapper extends BaseMapper
       
 
 

       {
    48.     
    49.     /**
    50.      * 查询所以表名
    51.      * @return 表集合
    52.      */
    53.     @Select("select table_name from information_schema.tables where table_schema='bd_dongzhebk' and table_type='base table';")
    54.     List
      55. tableList();
    55.  
    56.     /**
    57.      * 创建表
    58.      * @param tableInfo 表信息
    59.      */
    60.     void createTable(Table tableInfo);
    61.  
    62.     /**
    63.      * 更新表
    64.      * @param tableInfo 表信息
    65.      */
    66.     void alterField(Table tableInfo);
    67.  
    68. }
      69.  TableMapper.xml
      2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
      3. <mapper namespace="com.wdz.table.mapper.TableMapper">
      4.  
      5.     
      6.     <resultMap id="BaseResultMap" type="com.wdz.table.entity.Table">
      7.         <result column="table_name" property="tableName"/>
      8.     resultMap>
      9.     
      10.     <update id="createTable" parameterType="com.wdz.table.entity.Table">
      11.         SET NAMES utf8mb4;
      12.         SET FOREIGN_KEY_CHECKS = 0;
      13.         DROP TABLE IF EXISTS ${tableName};
      14.         CREATE TABLE ${tableName}
      15.         <foreach collection="fieldInfos" index="index" item="item" open="(" close=")">
      16.             ${item.name} ${item.type}(${item.length})
      17.             <if test="item.type=='VARCHAR'">
      18.                 CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci
      19.             if>
      20.             <if test="item.isNull==0">NOT NULLif>
      21.             <if test="item.isNull==1">NULL DEFAULT
      22.                 <if test="(item.type).contains('INT')">
      23.                     0
      24.                 if>
      25.                 <if test="!(item.type).contains('INT')">
      26.                     NULL
      27.                 if>
      28.             if>
      29.             COMMENT '${item.comment}',
      30.             <if test="index == fieldInfos.size()-1">
      31.                 <foreach collection="fieldInfos" item="item2">
      32.                     <if test="item2.isKey == true">
      33.                         PRIMARY KEY (${item2.name}) USING BTREE
      34.                     if>
      35.                 foreach>
      36.             if>
      37.         foreach>
      38.  
      39.         ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci COMMENT = '${comment}' ROW_FORMAT
      40.         = Compact;
      41.     update>
      42.     
      43.     <update id="alterField" parameterType="com.wdz.table.entity.Table">
      44.         <foreach collection="fieldInfos" item="item">
      45.             alter table ${tableName} add ${item.name} ${item.type}(${item.length})
      46.             <if test="item.type=='VARCHAR'">
      47.                 CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci
      48.             if>
      49.             <if test="item.isNull==0">NOT NULLif>
      50.             <if test="item.isNull==1">NULL DEFAULT
      51.                 <if test="(item.type).contains('INT')">
      52.                     0
      53.                 if>
      54.                 <if test="!(item.type).contains('INT')">
      55.                     NULL
      56.                 if>
      57.             if>
      58.             comment '${item.comment}';
      59.         foreach>
      60.     update>
      61. mapper>
      封装字段信息实体类
       FieldInfo.java
      1. import com.baomidou.mybatisplus.activerecord.Model;
      2.  
      3. import java.io.Serializable;
      4.  
      5. /**
      6.  * 字段信息
      7.  * @author wuchuancheng
      8.  */
      9. public class FieldInfo extends Model {
      10.  
      11.     private static final long serialVersionUID = 1L;
      12.  
      13.     private String name;
      14.  
      15.     private String type;
      16.  
      17.     private Integer length;
      18.  
      19.     private Integer decimal;
      20.  
      21.     private String defaulc;
      22.  
      23.     public String getDefaulc() {
      24.         return defaulc;
      25.     }
      26.  
      27.     public void setDefaulc(String defaulc) {
      28.         this.defaulc = defaulc;
      29.     }
      30.  
      31.     public String getCollation() {
      32.         return collation;
      33.     }
      34.  
      35.     public void setCollation(String collation) {
      36.         this.collation = collation;
      37.     }
      38.  
      39.     private Integer isNull;
      40.  
      41.     private String nullable;
      42.  
      43.     private String collation;
      44.  
      45.     private String keyValue;
      46.  
      47.     public String getKeyValue() {
      48.         return keyValue;
      49.     }
      50.  
      51.     public void setKeyValue(String keyValue) {
      52.         this.keyValue = keyValue;
      53.     }
      54.  
      55.     public String getNullable() {
      56.         return nullable;
      57.     }
      58.  
      59.     public void setNullable(String nullable) {
      60.         this.nullable = nullable;
      61.     }
      62.  
      63.     private boolean isKey;
      64.  
      65.     public String getName() {
      66.         return name;
      67.     }
      68.  
      69.     public void setName(String name) {
      70.         this.name = name;
      71.     }
      72.  
      73.     public String getType() {
      74.         return type;
      75.     }
      76.  
      77.     public void setType(String type) {
      78.         this.type = type;
      79.     }
      80.  
      81.     public Integer getLength() {
      82.         return length;
      83.     }
      84.  
      85.     public void setLength(Integer length) {
      86.         this.length = length;
      87.     }
      88.  
      89.     public Integer getDecimal() {
      90.         return decimal;
      91.     }
      92.  
      93.     public void setDecimal(Integer decimal) {
      94.         this.decimal = decimal;
      95.     }
      96.  
      97.     public Integer getIsNull() {
      98.         return isNull;
      99.     }
      100.  
      101.     public void setIsNull(Integer isNull) {
      102.         this.isNull = isNull;
      103.     }
      104.  
      105.     public boolean isKey() {
      106.         return isKey;
      107.     }
      108.  
      109.     public void setKey(boolean key) {
      110.         isKey = key;
      111.     }
      112.  
      113.     public String getAnnotate() {
      114.         return annotate;
      115.     }
      116.  
      117.     public void setAnnotate(String annotate) {
      118.         this.annotate = annotate;
      119.     }
      120.  
      121.     private String annotate;
      122.  
      123.     private String comment;
      124.  
      125.     public String getComment() {
      126.         return comment;
      127.     }
      128.  
      129.     public void setComment(String comment) {
      130.         this.comment = comment;
      131.     }
      132.  
      133.     @Override
      134.     protected Serializable pkVal() {
      135.         return serialVersionUID;
      136.     }
      137.  
      138.     @Override
      139.     public String toString() {
      140.         return "FieldInfo{" +
      141.                 "name='" + name + '\'' +
      142.                 ", type='" + type + '\'' +
      143.                 ", length=" + length +
      144.                 ", decimal=" + decimal +
      145.                 ", isNull=" + isNull +
      146.                 ", isKey=" + isKey +
      147.                 ", annotate='" + annotate + '\'' +
      148.                 ", comment='" + comment + '\'' +
      149.                 '}';
      150.     }
      151. }
       FieldInfoMapper.java
      1. import com.baomidou.mybatisplus.mapper.BaseMapper;
      2. import org.apache.ibatis.annotations.Param;
      3. import org.apache.ibatis.annotations.Select;
      4.  
      5. import java.util.List;
      6.  
      7. /**
      8.  * @author wuchuancheng
      9.  */
      10. public interface FieldInfoMapper extends BaseMapper {
      11.     
      12.     /**
      13.      * 根据表名查询所有字段信息集合
      14.      * @param tableName 表名
      15.      * @return 字段信息集合
      16.      */
      17.     List getFieldInfos(@Param("tableName") String tableName);
      18. }
      FieldInfoMapper.xml
      2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
      3. <mapper namespace="com.wdz.table.mapper.FieldInfoMapper">
      4.  
      5.     
      6.     <resultMap id="BaseResultMap" type="com.wdz.table.entity.FieldInfo">
      7.         <result column="Field" property="name" />
      8.         <result column="Type" property="type" />
      9.         <result column="length" property="length" />
      10.         <result column="decimal" property="decimal" />
      11.         <result column="Null" property="nullable" />
      12.         <result column="Comment" property="comment" />
      13.         <result column="Collation" property="collation" />
      14.         <result column="Default" property="defaulc" />
      15.         <result column="Key" property="keyValue" />
      16.     resultMap>
      17.     <select id="getFieldInfos" parameterType="String" resultMap="BaseResultMap">
      18.         show full columns from ${tableName};
      19.     select>
      20. mapper>
      功能类
      AutomaticConstruct.java
      1. import com.wdz.annotations.ColumnInfo;
      2. import com.wdz.annotations.TableInfo;
      3. import com.wdz.table.entity.FieldInfo;
      4. import com.wdz.table.entity.Table;
      5. import com.wdz.table.mapper.FieldInfoMapper;
      6. import com.wdz.table.mapper.TableMapper;
      7. import org.springframework.beans.factory.annotation.Value;
      8. import org.springframework.boot.ApplicationArguments;
      9. import org.springframework.boot.ApplicationRunner;
      10. import org.springframework.core.annotation.Order;
      11. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
      12. import org.springframework.core.io.support.ResourcePatternResolver;
      13. import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
      14. import org.springframework.core.type.classreading.MetadataReader;
      15. import org.springframework.core.type.classreading.MetadataReaderFactory;
      16. import org.springframework.stereotype.Component;
      17. import org.springframework.util.ClassUtils;
      18.  
      19. import javax.annotation.Resource;
      20. import java.io.IOException;
      21. import java.lang.reflect.Field;
      22. import java.util.*;
      23.  
      24. @Component
      25. @Order(1)//项目启动时自动执行
      26. public class AutomaticConstruct implements ApplicationRunner {
      27.  
      28.  
      29.     /**
      30.      * 获取当前所在环境 根据项目自己更改，作用是判断当前项目是不是在正式服启动
      31.      */
      32.     @Value("${spring.profiles.active}")
      33.     private String tenant;
      34.  
      35.     @Resource
      36.     private TableMapper tableMapper;
      37.  
      38.     @Resource
      39.     private FieldInfoMapper fieldInfoMapper;
      40.  
      41.  
      42.     /**
      43.      * 将测试服数据库同步到正式服上
      44.      * @param args
      45.      * @throws Exception
      46.      */
      47.     @Override
      48.     public void run(ApplicationArguments args) throws Exception {
      49.         //如果是正式服环境就做这些事情，这些自动建表的事情
      50.         String tenant = "pro";
      51.         if(tenant.equals(this.tenant)){
      52.             List
        
 
 
 
 
 
 
 
 
 
 
 

       iterator = tableMapper.tableList();
    69.             List
      70.  tables = getTableNames();
    70.             boolean bln = true;
    71.             List
      72.  n = new ArrayList<>();
    72.             for (Table table : tables) {
    73.                 bln = true;
    74.                 for(Table table1 : iterator){
    75.                     if((table.getTableName()).equals(table1.getTableName())){
    76.                         bln = false;
    77.                         List fieldInfos = fieldInfoMapper.getFieldInfos(table.getTableName());
    78.                         List fieldInfos2 = table.getFieldInfos();
    79.                         List list = new ArrayList<>();
    80.                         boolean bln2 = true,bln3 = false;
    81.                         for(FieldInfo fieldInfo:fieldInfos2){
    82.                             bln2 = true;
    83.                             for(FieldInfo fieldInfo2:fieldInfos){
    84.                                 if((fieldInfo.getName()).equals(fieldInfo2.getName())){
    85.                                     bln2 = false;
    86.                                     break;
    87.                                 }
    88.                             }
    89.                             if(bln2){
    90.                                 list.add(fieldInfo);
    91.                                 bln3 = true;
    92.                             }
    93.                         }
    94.                         //执行更新
    95.                         if(bln3) {
    96.                             Table table2 = new Table();
    97.                             table2.setTableName(table.getTableName());
    98.                             table2.setFieldInfos(list);
    99.                             tableMapper.alterField(table2);
    100.                         }
    101.                         break;
    102.                     }
    103.                 }
    104.                 if(bln){
    105.                    n.add(table);
    106.                 }
    107.             }
    108.             for(Table table:n){
    109.                 tableMapper.createTable(table);
    110.             }
    111.         }
    112.     }
    113.  
    114.     /**
    115.      * 获取模块中的数据库对应实体类
    116.      * @return
    117.      */
    118.     public List
      119. getTableNames(){
    119.         List
      120.  
       list = new ArrayList<>();
    120.  
    121.         //spring工具类，可以获取指定路径下的全部类
    122.         ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    123.         try {
    124.             String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
    125.                     ClassUtils.convertClassNameToResourcePath("com.wdz") + "/**/entity/*.class";
    126.             org.springframework.core.io.Resource[] resources =resourcePatternResolver.getResources(pattern);
    127.             //MetadataReader 的工厂类
    128.             MetadataReaderFactory readerfactory = new CachingMetadataReaderFactory(resourcePatternResolver);
    129.             for (org.springframework.core.io.Resource resource : resources) {
    130.                 //用于读取类信息
    131.                 MetadataReader reader = readerfactory.getMetadataReader(resource);
    132.                 //扫描到的class
    133.                 String classname = reader.getClassMetadata().getClassName();
    134.                 Class clazz = Class.forName(classname);
    135.                 //判断是否有指定主解
    136.                 TableInfo anno = clazz.getAnnotation(TableInfo.class);
    137.                 if (anno != null && anno.isCreate()) {
    138.                     //将含有@TableInfo的类的类名放入list
    139.                     Table table = new Table();
    140.                     table.setTableName(anno.name());
    141.                     table.setComment(anno.comment());
    142.                     List fieldInfos = new ArrayList<>();
    143.                     Field[] fields = clazz.getDeclaredFields();
    144.                     for(Field field:fields){
    145.                         field.setAccessible(true);
    146.                         ColumnInfo columnInfo = field.getAnnotation(ColumnInfo.class);
    147.                         if(columnInfo != null){
    148.                             FieldInfo fieldInfo = new FieldInfo();
    149.                             fieldInfo.setType(columnInfo.type());
    150.                             fieldInfo.setName(columnInfo.name());
    151.                             fieldInfo.setLength(columnInfo.length());
    152.                             fieldInfo.setKey(columnInfo.key());
    153.                             fieldInfo.setIsNull(columnInfo.nullable());
    154.                             fieldInfo.setComment(columnInfo.comment());
    155.                             fieldInfos.add(fieldInfo);
    156.                         }
    157.                     }
    158.                     table.setFieldInfos(fieldInfos);
    159.                     list.add(table);
    160.                 }
    161.             }
    162.         } catch (IOException | ClassNotFoundException ignored) {
    163.             ignored.printStackTrace();
    164.         }
    165.         return list;
    166.     }
    167. }
      168.  
 
      AutomaticConstruct类的作用是，在项目启动的时候
       
 
      1. 获取数据库所有表集合（调用tableMapper.tableList()）
      2. 获取项目所有实体类集合（调用getTableNames()）
      3. 两者进行判断，数据库没有的就创建（调用tableMapper.createTable(table)）
      4. 数据库有但是表字段不全（调用tableMapper.alterField(table2)）更新
      

      3.完成
      就这样大功告成了，我把所有需要用到的都贴出来了，复制就可以直接使用，不会有问题。制作不易，还望点个赞。如果有问题可以留言评论。
      欢迎大家访问我的博客way博客
    168. 

                    相关阅读:
      
                    
2022年Java面试题最新整理，附白话答案                            
      
测试.net文字转语音模块System.Speech                            
      
XML配置文件解析与建模                            
      
数据库复习                            
      
亿级流量高并发春晚互动前端技术揭秘                            
      
开源相机管理库Aravis学习（一）——安装                            
      
CCF CSP认证 历年题目自练Day26                            
      
Linux友人帐之环境变量                            
      
​Linux·i2c驱动架构​                            
      
vue实现防抖函数、节流函数，全局使用【输入框、按钮】                            
      
                          
                
    169. 
                    原文地址：https://blog.csdn.net/weixin_43900374/article/details/126049835
                
      170.