手把手带你鲁Java代码生成工具

项目搭建

添加模块

easyJava

1. application.properties

// 设置数据库驱动名称为com.mysql.jdbc.Driver
db.driver.name=com.mysql.jdbc.Driver

// 设置数据库连接URL，连接到本地MySQL服务器的test数据库，使用UTF-8编码
db.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8

// 设置数据库用户名为root
db.username=root

// 设置数据库密码为root
db.password=root

2. 配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 定义XML版本和编码格式 -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- 定义Maven项目的基本坐标信息 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 定义项目的groupId、artifactId和version -->
    <groupId>com.easyjava</groupId>
    <artifactId>easyJava</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 定义项目的属性，包括MySQL驱动版本、Apache Commons版本、Logback版本和SLF4J版本 -->
    <properties>
        <mysql.version>5.1.5</mysql.version>
        <apach.commons.version>3.4</apach.commons.version>
        <logback.version>1.2.10</logback.version>
        <slf4j.version>1.7.7</slf4j.version>

        <!-- 定义Maven编译器的源代码和目标代码版本 -->
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <!-- 定义项目构建时的源代码编码格式 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- 定义项目的依赖关系 -->
    <dependencies>
        <!-- MySQL驱动依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- Apache Commons依赖 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${apach.commons.version}</version>
        </dependency>
        <!-- Logback依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>${logback.version}</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>${logback.version}</version>
        </dependency>
        <!-- SLF4J依赖 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
    </dependencies>
</project>

easyJava-Demo

1. 添加application.properties

easyJava-Demo->src->main->resources->application.properties

# 设置服务器端口号为8070
server.port=8070

# 设置数据库驱动类名为com.mysql.cj.jdbc.Driver
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 设置数据库连接URL，连接到本地MySQL服务器的test数据库，设置时区为GMT+8，不使用SSL连接
spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&useSSL=false

# 设置数据库用户名为root
spring.datasource.data-username=root

# 设置数据库密码为root
spring.datasource.data-password=root

# 设置HikariCP连接池的最小空闲连接数为5
spring.datasource.hikari.minimum-idle=5

# 设置HikariCP连接池的空闲连接超时时间为180000毫秒（3分钟）
spring.datasource.hikari.idle-timeout=180000

# 设置HikariCP连接池的最大连接数为10
spring.datasource.hikari.maximum-pool-size=10

# 设置HikariCP连接池的自动提交为true
spring.datasource.hikari.auto-commit=true

# 设置HikariCP连接池的名称为easyjavaPoool
spring.datasource.hikari.pool-name=easyjavaPoool

# 设置HikariCP连接池中连接的最大生命周期为1800000毫秒（30分钟）
spring.datasource.hikari.max-lifetime=1800000

# 设置HikariCP连接池的连接超时时间为30000毫秒（30秒）
spring.datasource.hikari.connection-timeout=30000

# 设置HikariCP连接池的连接测试查询语句为SELECT 1
spring.datasource.hikari.connection-test-query=SELECT 1

2. 修改pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 定义XML文档的版本和编码 -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- 定义Maven项目的基本坐标信息 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 定义项目的groupId，artifactId和version -->
    <groupId>com.easyjava</groupId>
    <artifactId>easyJava-Demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- 定义项目的父项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
    </parent>

    <!-- 定义项目的属性 -->
    <properties>
        <springboot.version>2.2.6.RELEASE</springboot.version>
        <mybatis.version>1.3.2</mybatis.version>
        <mysql.version>8.0.17</mysql.version>

        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- 定义项目的依赖 -->
    <dependencies>

        <!-- Spring Boot Web Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${springboot.version}</version>
        </dependency>
        <!-- MyBatis Spring Boot Starter -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- MySQL Connector Java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
    </dependencies>
</project>

3. 添加easyjava/RunDemoApplication.java

// 导入包com.easyjava
package com.easyjava;

// 导入Spring Boot相关的类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// 使用@SpringBootApplication注解标记这是一个Spring Boot应用
@SpringBootApplication
public class RunDemoApplication {
    // 主方法，程序的入口
    public static void main(String[] args) {
        // 使用SpringApplication的run方法启动Spring Boot应用
        SpringApplication.run(RunDemoApplication.class, args);
    }
}

sql

CREATE TABLE tb_product_info (
    id int(11) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
    company_id varchar(30) DEFAULT NULL COMMENT '公司ID',
    code varchar(11) DEFAULT NULL COMMENT '商品编号',
    product_name varchar(200) DEFAULT NULL COMMENT '商品名称',
    price decimal(15,2) DEFAULT NULL COMMENT '价格',
    sku_type tinyint(4) DEFAULT NULL COMMENT 'sku类型',
    color_type tinyint(4) DEFAULT NULL COMMENT '颜色类型',
    create_time datetime DEFAULT NULL COMMENT '创建时间',
    create_date date DEFAULT NULL COMMENT '创建日期',
    stock bigint(20) DEFAULT NULL COMMENT '库存',
    staus tinyint(4) DEFAULT NULL COMMENT '状态',
    PRIMARY KEY (id),
    UNIQUE KEY idx_code (code) USING BTREE,
    UNIQUE KEY idx_sku_color (sku_type,color_type)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8 COMMENT='商品信息'

读取表结构_读取表

添加easyjava/utils/PropertiesUtils.java

添加workspace-easyjava/easyJava/src/main/java/com/easyjava/utils/PropertiesUtils.java

package com.easyjava.utils; // 定义包名为com.easyjava.utils

import java.io.IOException; // 导入IOException类，用于处理输入输出异常
import java.io.InputStream; // 导入InputStream类，用于读取字节流
import java.util.Iterator; // 导入Iterator类，用于遍历集合
import java.util.Map; // 导入Map接口，用于存储键值对
import java.util.Objects; // 导入Objects类，用于处理对象相关操作
import java.util.Properties; // 导入Properties类，用于处理属性文件
import java.util.concurrent.ConcurrentHashMap; // 导入ConcurrentHashMap类，用于存储线程安全的键值对

public class PropertiesUtils { // 定义一个名为PropertiesUtils的公共类
    private static Properties props = new Properties(); // 定义一个私有静态的Properties对象
    private static Map<String, String> PROPER_MAP = new ConcurrentHashMap(); // 定义一个私有静态的ConcurrentHashMap对象，用于存储键值对

    static { // 静态代码块，在类加载时执行
        InputStream is = null; // 定义一个InputStream对象，初始化为null
        try {
            is = PropertiesUtils.class.getClassLoader().getResourceAsStream("application.properties"); // 通过类加载器获取名为application.properties的资源文件的输入流
            props.load(is); // 将输入流中的属性加载到props对象中

            Iterator<Object> iterator = props.keySet().iterator(); // 获取props对象的键集合的迭代器
            while (iterator.hasNext()) { // 遍历迭代器
                String key = (String) iterator.next(); // 获取当前迭代器的下一个元素，并将其转换为字符串类型
                PROPER_MAP.put(key, props.getProperty(key)); // 将键和对应的值存入PROPER_MAP对象中
            }
        } catch (Exception e) { // 捕获异常

        } finally { // finally代码块，无论是否发生异常都会执行
            if (is != null) { // 如果输入流不为空
                try {
                    is.close(); // 关闭输入流
                } catch (IOException e) { // 捕获关闭输入流时的异常
                    e.printStackTrace(); // 打印异常堆栈信息
                }
            }
        }
    }

    public static String getString(String key) { // 定义一个公共静态方法，接收一个字符串类型的参数key，返回一个字符串类型的值
        return PROPER_MAP.get(key); // 从PROPER_MAP对象中获取key对应的值并返回
    }

    public static void main(String[] args) { // 定义主方法
        System.out.println(getString("db.driver.name")); // 调用getString方法，传入"db.driver.name"作为参数，并打印返回的结果
    }
}

添加easyjava/builder/BuildTable.java

添加workspace-easyjava/easyJava/src/main/java/com/easyjava/builder/BuildTable.java

package com.easyjava.builder; // 定义包名为com.easyjava.builder

import com.easyjava.utils.PropertiesUtils; // 导入PropertiesUtils工具类
import org.slf4j.Logger; // 导入日志接口
import org.slf4j.LoggerFactory; // 导入日志工厂类

import java.sql.*; // 导入java.sql包下的所有类

public class BuildTable { // 定义一个名为BuildTable的公共类
    private static final Logger logger = LoggerFactory.getLogger(BuildTable.class); // 定义一个静态的日志对象
    private static Connection conn = null; // 定义一个静态的数据库连接对象

    private static String SQL_SHOW_TABLE_STATUS = "show table status"; // 定义一个静态的SQL查询语句字符串
    static { // 静态代码块，用于初始化数据库连接
        String dirverName = PropertiesUtils.getString("db.driver.name"); // 从配置文件中获取数据库驱动名称
        String url = PropertiesUtils.getString("db.url"); // 从配置文件中获取数据库连接URL
        String user = PropertiesUtils.getString("db.username"); // 从配置文件中获取数据库用户名
        String password = PropertiesUtils.getString("db.password"); // 从配置文件中获取数据库密码
        try {
            Class.forName(dirverName); // 加载数据库驱动
            conn = DriverManager.getConnection(url, user, password); // 获取数据库连接
        } catch (Exception e) {
            logger.error("数据库连接失败", e); // 如果连接失败，记录错误日志
        }
    }
    public static void getTables(){ // 定义一个公共的静态方法，用于获取数据库表信息
        PreparedStatement ps =null; // 定义一个预处理语句对象
        ResultSet tableResult = null; // 定义一个结果集对象
        try {
            ps = conn.prepareStatement(SQL_SHOW_TABLE_STATUS); // 使用预处理语句执行SQL查询
            tableResult = ps.executeQuery(); // 执行查询并获取结果集
            while(tableResult.next()){ // 遍历结果集
                String tableName = tableResult.getString("name"); // 获取表名
                String comment = tableResult.getString("comment"); // 获取表注释
                logger.info("tableName:{},comment:{}", tableName, comment); // 记录日志
            }
        } catch (Exception e) {
            logger.error("读取表失败", e); // 如果查询失败，记录错误日志
        }finally { // finally代码块，用于关闭资源
            if (tableResult != null) { // 如果结果集不为空
                try {
                    tableResult.close(); // 关闭结果集
                } catch (SQLException e) {
                    logger.error("关闭ResultSet失败", e); // 如果关闭失败，记录错误日志
                }
            }
            if(ps != null) { // 如果预处理语句不为空
                try {
                    ps.close(); // 关闭预处理语句
                } catch (SQLException e) {
                    logger.error("关闭PreparedStatement失败", e); // 如果关闭失败，记录错误日志
                }
            }
            if (conn != null) { // 如果数据库连接不为空
                try {
                    conn.close(); // 关闭数据库连接
                } catch (SQLException e) {
                    logger.error("关闭Connection失败", e); // 如果关闭失败，记录错误日志
                }
            }
        }
    }
}

添加RunApplication.java

添加workspace-easyjava/easyJava/src/main/java/com/easyjava/RunApplication.java

// 导入包com.easyjava
package com.easyjava;

// 导入BuildTable类，用于构建表格
import com.easyjava.builder.BuildTable;

// 定义一个名为RunApplication的公共类
public class RunApplication {
    // 主方法，程序的入口
    public static void main(String[] args) {
        // 调用BuildTable类的getTables()方法，用于获取表格数据
        BuildTable.getTables();
    }
}

读取表结构——读取表基本信息

添加com/easyjava/bean/TableInfo.java

easyJava/src/main/java/com/easyjava/bean/TableInfo.java

package com.easyjava.bean; // 定义包名为com.easyjava.bean

import java.util.LinkedHashMap; // 导入LinkedHashMap类
import java.util.List; // 导入List接口
import java.util.Map; // 导入Map接口

public class TableInfo { // 定义一个名为TableInfo的公共类
    // 表名
    private String tableName;
    // bean名称
    private String beanName;
    // 参数名称
    private String beanParamName;
    // 表注释
    private String comment;
    // 字段信息
    private List<FieldInfo> fieldList;
    // 唯一索引集合
    private Map<String, List<FieldInfo>> keyIndexmap = new LinkedHashMap();
    // 是否有date类型
    private Boolean haveDate;
    // 是否有时间类型
    private Boolean haveDateTime;
    // 是否有 bigdecimal类型
    private Boolean haveBigDecimal;

    // 获取表名的方法
    public String getTableName() {
        return tableName;
    }

    // 设置表名的方法
    public void setTableName(String tableName) {
        this.tableName = tableName;
    }

    // 获取bean名称的方法
    public String getBeanName() {
        return beanName;
    }

    // 设置bean名称的方法
    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }

    // 获取参数名称的方法
    public String getBeanParamName() {
        return beanParamName;
    }

    // 设置参数名称的方法
    public void setBeanParamName(String beanParamName) {
        this.beanParamName = beanParamName;
    }

    // 获取表注释的方法
    public String getComment() {
        return comment;
    }

    // 设置表注释的方法
    public void setComment(String comment) {
        this.comment = comment;
    }

    // 获取字段信息的方法
    public List<FieldInfo> getFieldList() {
        return fieldList;
    }

    // 设置字段信息的方法
    public void setFieldList(List<FieldInfo> fieldList) {
        this.fieldList = fieldList;
    }

    // 获取唯一索引集合的方法
    public Map<String, List<FieldInfo>> getKeyIndexmap() {
        return keyIndexmap;
    }

    // 设置唯一索引集合的方法
    public void setKeyIndexmap(Map<String, List<FieldInfo>> keyIndexmap) {
        this.keyIndexmap = keyIndexmap;
    }

    // 获取是否有date类型的方法
    public Boolean getHaveDate() {
        return haveDate;
    }

    // 设置是否有date类型的方法
    public void setHaveDate(Boolean haveDate) {
        this.haveDate = haveDate;
    }

    // 获取是否有时间类型的方法
    public Boolean getHaveDateTime() {
        return haveDateTime;
    }

    // 设置是否有时间类型的方法
    public void setHaveDateTime(Boolean haveDateTime) {
        this.haveDateTime = haveDateTime;
    }

    // 获取是否有bigdecimal类型的方法
    public Boolean getHaveBigDecimal() {
        return haveBigDecimal;
    }

    // 设置是否有bigdecimal类型的方法
    public void setHaveBigDecimal(Boolean haveBigDecimal) {
        this.haveBigDecimal = haveBigDecimal;
    }
}

添加com/easyjava/bean/FieldInfo.java

easyJava/src/main/java/com/easyjava/bean/FieldInfo.java

package com.easyjava.bean;

import com.sun.org.apache.xpath.internal.operations.Bool;

public class FieldInfo {
    // 字段名称
    private String FieldName;
    // bean属性名称
    private String propertyName;

    private String sqlType;
    // 字段类型
    private String javaType;
    // 字段备注
    private String comment;
    // 字段是否自增长
    private Boolean isAutoIncrement;

    // 获取字段名称
    public String getFieldName() {
        return FieldName;
    }

    // 设置字段名称
    public void setFieldName(String fieldName) {
        FieldName = fieldName;
    }

    // 获取bean属性名称
    public String getPropertyName() {
        return propertyName;
    }

    // 设置bean属性名称
    public void setPropertyName(String propertyName) {
        this.propertyName = propertyName;
    }

    // 获取SQL类型
    public String getSqlType() {
        return sqlType;
    }

    // 设置SQL类型
    public void setSqlType(String sqlType) {
        this.sqlType = sqlType;
    }

    // 获取Java类型
    public String getJavaType() {
        return javaType;
    }

    // 设置Java类型
    public void setJavaType(String javaType) {
        this.javaType = javaType;
    }

    // 获取字段备注
    public String getComment() {
        return comment;
    }

    // 设置字段备注
    public void setComment(String comment) {
        this.comment = comment;
    }

    // 获取字段是否自增长
    public Boolean getAutoIncrement() {
        return isAutoIncrement;
    }

    // 设置字段是否自增长
    public void setAutoIncrement(Boolean autoIncrement) {
        isAutoIncrement = autoIncrement;
    }
}

添加com/easyjava/bean/Constants.java

easyJava/src/main/java/com/easyjava/bean/Constants.java

package com.easyjava.bean; // 定义包名为com.easyjava.bean

import com.easyjava.utils.PropertiesUtils; // 导入com.easyjava.utils包下的PropertiesUtils类

public class Constants { // 定义一个公共类Constants
    public static boolean IGNORE_TABLE_PERFIX; // 定义一个公共静态布尔变量IGNORE_TABLE_PERFIX

    public static String SUFFIX_BEAN_PARAM; // 定义一个公共静态字符串变量SUFFIX_BEAN_PARAM

    static { // 静态代码块，在类加载时执行一次
        IGNORE_TABLE_PERFIX = Boolean.valueOf(PropertiesUtils.getString("ignore.table.prefix")); // 从配置文件中获取"ignore.table.prefix"的值，并将其转换为布尔值赋给IGNORE_TABLE_PERFIX
        SUFFIX_BEAN_PARAM = PropertiesUtils.getString("suffix.bean.param"); // 从配置文件中获取"suffix.bean.param"的值，并赋给SUFFIX_BEAN_PARAM
    }
}

修改BuildTable

package com.easyjava.builder; // 定义包名

import com.easyjava.bean.Constants; // 导入常量类
import com.easyjava.bean.TableInfo; // 导入表信息类
import com.easyjava.utils.PropertiesUtils; // 导入属性工具类
import com.easyjava.utils.StringUtils; // 导入字符串工具类
import org.slf4j.Logger; // 导入日志接口
import org.slf4j.LoggerFactory; // 导入日志工厂类

import java.sql.*; // 导入SQL相关类
import java.util.ArrayList; // 导入列表类
import java.util.List; // 导入列表接口

public class BuildTable { // 定义构建表类
    private static final Logger logger = LoggerFactory.getLogger(BuildTable.class); // 定义日志对象
    private static Connection conn = null; // 定义数据库连接对象

    private static String SQL_SHOW_TABLE_STATUS = "show table status"; // 定义查询表状态的SQL语句
    static { // 静态代码块，用于初始化数据库连接
        String dirverName = PropertiesUtils.getString("db.driver.name"); // 获取数据库驱动名称
        String url = PropertiesUtils.getString("db.url"); // 获取数据库连接地址
        String user = PropertiesUtils.getString("db.username"); // 获取数据库用户名
        String password = PropertiesUtils.getString("db.password"); // 获取数据库密码
        try {
            Class.forName(dirverName); // 加载数据库驱动
            conn = DriverManager.getConnection(url, user, password); // 获取数据库连接
        } catch (Exception e) {
            logger.error("数据库连接失败", e); // 记录错误日志
        }
    }
    public static void getTables(){ // 定义获取表信息的方法
        PreparedStatement ps =null; // 定义预处理语句对象
        ResultSet tableResult = null; // 定义结果集对象

        List<TableInfo> tableInfoList = new ArrayList<>(); // 定义表信息列表

        try {
            ps = conn.prepareStatement(SQL_SHOW_TABLE_STATUS); // 准备查询表状态的SQL语句
            tableResult = ps.executeQuery(); // 执行查询，获取结果集
            while(tableResult.next()){ // 遍历结果集
                String tableName = tableResult.getString("name"); // 获取表名
                String comment = tableResult.getString("comment"); // 获取表注释
                //logger.info("tableName:{},comment:{}", tableName, comment);

                String beanName = tableName; // 定义JavaBean名称
                if (Constants.IGNORE_TABLE_PERFIX) { // 如果忽略表前缀
                    beanName = tableName.substring(beanName.indexOf("_") + 1); // 截取表名中下划线后面的部分作为JavaBean名称
                }
                beanName = processField(beanName, true); // 处理JavaBean名称

                TableInfo tableInfo = new TableInfo(); // 创建表信息对象
                tableInfo.setTableName(tableName); // 设置表名
                tableInfo.setBeanName(beanName); // 设置JavaBean名称
                tableInfo.setComment(comment); // 设置表注释
                tableInfo.setBeanParamName(beanName + Constants.SUFFIX_BEAN_PARAM); // 设置JavaBean参数名

                logger.info("表：{},备注：{},Javabean:{},JavaParamBean:{}",tableInfo.getTableName(),tableInfo.getComment(),tableInfo.getBeanName(),tableInfo.getBeanParamName()); // 记录日志
            }
        } catch (Exception e) {
            logger.error("读取表失败", e); // 记录错误日志
        }finally { // finally代码块，用于关闭资源
            if (tableResult != null) { // 如果结果集不为空
                try {
                    tableResult.close(); // 关闭结果集
                } catch (SQLException e) {
                    logger.error("关闭ResultSet失败", e); // 记录错误日志
                }
            }
            if(ps != null) { // 如果预处理语句对象不为空
                try {
                    ps.close(); // 关闭预处理语句对象
                } catch (SQLException e) {
                    logger.error("关闭PreparedStatement失败", e); // 记录错误日志
                }
            }
            if (conn != null) { // 如果数据库连接对象不为空
                try {
                    conn.close(); // 关闭数据库连接对象
                } catch (SQLException e) {
                    logger.error("关闭Connection失败", e); // 记录错误日志
                }
            }
        }
    }
    private static String processField(String field,Boolean uperCaseFirstLetter) { // 定义处理字段名的方法
        StringBuffer sb = new StringBuffer(); // 定义字符串缓冲区对象
        String[] fields = field.split("_"); // 将字段名按照下划线分割成数组
        sb.append(uperCaseFirstLetter ? StringUtils.uperCaseFirstLetter(fields[0]) : fields[0]); // 如果首字母大写，则将第一个字段首字母大写，否则保持不变
        for (int i =1,len= fields.length;i < len;i++) { // 遍历剩余字段
            sb.append(StringUtils.uperCaseFirstLetter(fields[i])); // 将每个字段首字母大写
        }
        return sb.toString(); // 返回处理后的字段名

    }
}

添加com/easyjava/utils/StringUtils.java

easyJava/src/main/java/com/easyjava/utils/StringUtils.java

package com.easyjava.utils;

public class StringUtils {
    // 将输入字符串的首字母大写
    public static String uperCaseFirstLetter(String field) {
        // 如果输入字符串为空或者长度为0，直接返回原字符串
        if(org.apache.commons.lang3.StringUtils.isEmpty(field)) {
            return field;
        }
        // 将首字母大写，然后拼接上剩余的字符串
        return field.substring(0, 1).toUpperCase() + field.substring(1);
    }

    // 将输入字符串的首字母小写
    public static String lowerCaseFirstLetter(String field) {
        // 如果输入字符串为空或者长度为0，直接返回原字符串
        if(org.apache.commons.lang3.StringUtils.isEmpty(field)) {
            return field;
        }
        // 将首字母小写，然后拼接上剩余的字符串
        return field.substring(0, 1).toLowerCase() + field.substring(1);
    }

    // 主函数，用于测试lowerCaseFirstLetter方法
    public static void main(String[] args) {
        System.out.println(lowerCaseFirstLetter("Company")); // 输出：company
    }
}

读取表结构，读取表字段

修改BuildTable.java

修改Constants.java

读取表结构_读取表索引

报错原因

idea导入java项目时包名路径报错解决:https://blog.csdn.net/qq_39324871/article/details/90748577

解决Could not find artifact org.springframework.boot:spring-boot-starter-parent:pom:3.1.1 in alimave问题:
https://blog.csdn.net/weixin_64280364/article/details/131380587

Navicat连接MySQL8.0报客户端不支持请求认证协议，要升级mysql服务器:https://blog.csdn.net/bai500/article/details/105045796