前言，本次记录重点在读取数据库表结构，及解析转换成java实体类需要字段。

主要包含，表 列名、类型、注释的读取解析

至于代码生成，可以基于已有的代码生成模板 整合进去即可

pom：

<!-- Mysql Connector -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

<!--//驼峰转换-->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>21.0</version>
        </dependency>
<!-- Beetl代码生成使用 -->
        <dependency>
            <groupId>com.ibeetl</groupId>
            <artifactId>beetl</artifactId>
            <version>2.9.10</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.10</version>
        </dependency>

一、从mysql读取实体类相关信息实现

1、数据库-java数据结构对应map

/**
 * @Author: WXM
 * @Description: mysql数据结构对应
 * @Date: create in 2020/11/4 19:03
 */

public class DataTypeUtil {

    public static Map<String ,String> map = new HashMap<>();
    static {
        map.put("smallint","java.lang.Integer");
        map.put("mediumint","java.lang.Integer");
        map.put("integer","java.lang.Integer");
        map.put("tinyint","java.lang.Short");
        map.put("int","java.lang.Integer");
        map.put("bigint","java.lang.Long");
        map.put("float","java.lang.Float");
        map.put("double","java.lang.Double");
        map.put("decimal","java.math.BigDecimal");
        map.put("date","java.util.Date");
        map.put("datetime","java.util.Date");
        map.put("timestamp","java.util.Date");
        map.put("time","java.util.Date");
        map.put("year","java.util.Date");
        map.put("char","java.lang.String");
        map.put("varchar","java.lang.String");
        map.put("binary","byte[]");
        map.put("varbinary","byte[]");
        map.put("tinyblob","byte[]");
        map.put("tinytext","java.lang.String");
        map.put("blob","byte[]");
        map.put("text","java.lang.String");
        map.put("mediumblob","byte[]");
        map.put("mediumtext","java.lang.String");
        map.put("longblob","byte[]");
        map.put("longtext","java.lang.String");
        map.put("enum","java.lang.String");
        map.put("set","java.lang.String");
        map.put("bit","java.lang.Boolean");
    }
}

2、表结构存储实体类

/**
 * @Author: WXM
 * @Description: 表结构信息
 * @Date: create in 2020/11/4 17:03
 */

public class TableRowInfo {

    private String columnName;
    private String columnType;
    private String columnComment;

    public String getColumnName() {
        return columnName;
    }

    public void setColumnName(String columnName) {
        this.columnName = columnName;
    }

    public String getColumnType() {
        return columnType;
    }

    public void setColumnType(String columnType) {
        this.columnType = columnType;
    }

    public String getColumnComment() {
        return columnComment;
    }

    public void setColumnComment(String columnComment) {
        this.columnComment = columnComment;
    }
}

3、数据库连接配置及获取表结构

/**
 * @Author: WXM
 * @Description: mysql获取表结构
 * @Date: create in 2020/11/4 16:27
 */

public class MysqlConnectUtil {

    private String driverClass;
    private String url;
    private String userName;
    private String passWord;
    private String tableName;

    public List<TableRowInfo> creat(){
        List<TableRowInfo> tableRowInfos = new ArrayList<>();
        if(StringUtils.isNotBlank(driverClass) && StringUtils.isNotBlank(url) && StringUtils.isNotBlank(userName) && StringUtils.isNotBlank(passWord)
                && StringUtils.isNotBlank(tableName)){
            try {

                Class.forName(driverClass);
                Connection con = DriverManager.getConnection(url, userName, passWord);
                String sql = "show full columns from  "+tableName;
                Statement st = con.createStatement();
                ResultSet res = st.executeQuery(sql);
                while (res.next()){
                    TableRowInfo tri = new TableRowInfo();
                    tri.setColumnName(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, res.getString("Field")));
                    tri.setColumnType(DataTypeUtil.map.get(res.getString("Type").split("\\(")[0]));
                    tri.setColumnComment(res.getString("Comment"));
                    tableRowInfos.add(tri);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }else {
            throw new RuntimeException("请填写完整mysql连接所需参数");
        }

        return tableRowInfos;
    }

    public MysqlConnectUtil setDriverClass(String driverClass) {
        this.driverClass = driverClass;
        return this;
    }

    public MysqlConnectUtil setUrl(String url) {
        this.url = url;
        return this;
    }

    public MysqlConnectUtil setUserName(String userName) {
        this.userName = userName;
        return this;
    }

    public MysqlConnectUtil setPassWord(String passWord) {
        this.passWord = passWord;
        return this;
    }

    public MysqlConnectUtil setTableName(String tableName) {
        this.tableName = tableName;
        return this;
    }
}

4、实际测试

    /**
     * 根据数据库表生成实体类
     */
    private static String driverClass = "com.mysql.jdbc.Driver";
    private static String url = "jdbc:mysql://127.0.0.1:3306/zhzf_xingzhengfuyi?useUnicode=true&characterEncoding=utf-8";
    private static String userName = "root";
    private static String passWord = "123456";
    private static String tableName = "b_anjianxinxi";
    private static List<TableRowInfo> tableRowInfos = new ArrayList<>();

    public void getTableRowInfo(){
        tableRowInfos = new MysqlConnectUtil()
                .setDriverClass(driverClass)
                .setUrl(url)
                .setUserName(userName)
                .setPassWord(passWord)
                .setTableName(tableName)
                .creat();
    }

二、生成代码实现

1、新建blt后缀的文件，到资源文件夹下，把整合好的 tableRowInfos 写入模板生成文件中即可，类似下面

package ${entity.entityPackage};

import java.util.Date;
import lombok.Data;

@Data
public class ${entity.className} {

    private static final long serialVersionUID = 1L;

    <%
        for(var tableRowInfo in entity.tableRowInfos){
    %>
    // ${tableRowInfo.columnComment}
    private ${tableRowInfo.columnType} ${tableRowInfo.columnName};
    <%
        }
    %>

}

2、编写生成代码

import org.beetl.core.Configuration;
import org.beetl.core.GroupTemplate;
import org.beetl.core.Template;
import org.beetl.core.resource.ClasspathResourceLoader;



    /**
     * 主键类型
     */
    private static final String primaryKeyType = "String";

    /**
     * 实体类对应包
     * (文件自动生成至该包下)
     */
    private static final String entityPackage = "com.budongfeng.tboot.modules.your.entity";
    /**
     * 实体类名
     * 建议仅需修改
     */
    private static final String className = "JuedingshuTemp";

    /**
     * 根据数据库表生成实体类
     */
    private static String driverClass = "com.mysql.jdbc.Driver";
    private static String url = "jdbc:mysql://127.0.0.1:3306/zhzf_xingzhengfuyi?useUnicode=true&characterEncoding=utf-8";
    private static String userName = "root";
    private static String passWord = "123456";
    private static String tableName = "juedingshu_temp";
    private static List<TableRowInfo> tableRowInfos = new ArrayList<>();

public static void main(String[] args) throws Exception {
        //读取表格信息
        TbootMPGenerator tb = new TbootMPGenerator();
        tb.getTableRowInfo();

        // 模板路径
        ClasspathResourceLoader resourceLoader = new ClasspathResourceLoader("/btl/");
        Configuration cfg = Configuration.defaultConfiguration();
        GroupTemplate gt = new GroupTemplate(resourceLoader, cfg);

        // 生成代码
        generateCode(gt);

        // 读取你的实体类中的字段，补充生成条件构造分页查询代码【需自行复制控制台打印输出的代码自行覆盖】
//        generatePlus(gt);

        // 根据类名删除生成的代码
//         deleteCode(className);
    }

private static void generateCode(GroupTemplate gt) throws IOException {

        //读取资源文件夹下刚创建的blt文件
        Template entityTemplate = gt.getTemplate("entity.btl");

        OutputStream out = null;
        //生成实体类代码,将上面生成的table信息赋值到下面创建的类中
        Entity entity = new Entity();
        entity.setTableRowInfos(tableRowInfos);
        entity.setClassName(className);
        entity.setTableName(tableName);
        entity.setEntityPackage(entityPackage);
        String entityResult = entityTemplate.render();
        System.out.println(entityResult);
        entityTemplate.binding("entity", entity);
        //创建输出文件
        String entityFileUrl = System.getProperty("user.dir") + "/src/main/java/" + dotToLine(entityPackage) + "/" + className + ".java";
        File entityFile = new File(entityFileUrl);
        File entityDir = entityFile.getParentFile();
        if (!entityDir.exists()) {
            entityDir.mkdirs();
        }
        if (!entityFile.exists()) {
            // 若文件存在则不重新生成
            entityFile.createNewFile();
            out = new FileOutputStream(entityFile);
            entityTemplate.renderTo(out);
        }
    }
    /**
     * 点转斜线
     * @param str
     * @return
     */
    public static String dotToLine(String str){
        return str.replace(".", "/");
    }

public void getTableRowInfo(){
        tableRowInfos = new MysqlConnectUtil()
                .setDriverClass(driverClass)
                .setUrl(url)
                .setUserName(userName)
                .setPassWord(passWord)
                .setTableName(tableName)
                .creat();
    }

@Data
public class Entity {

    private String entityPackage;

    private String daoPackage;

    private String servicePackage;

    private String serviceImplPackage;

    private String controllerPackage;

    private String author;

    private String className;

    private String classNameLowerCase;

    private String tableName;

    private String description;

    private String primaryKeyType;

    private Boolean activiti;

    private Boolean isTree;

    private List<TableRowInfo> tableRowInfos;
}

在一些程序中，实体类是数据不可缺少的一部分，简单点说就是属性类，通常定义在model层里面。一般的实体类对应一个数据表，其中的属性对应数据表中的字段。属性可以对字段定义和状态进行判断和过滤，把相关信息用一个实体类封装后，在程序中可以把实体类作为参数传递，更加方便。然而，当数据表中字段过多时，就不好写了，需要一个一个地封装，显得有点麻烦，而且浪费时间，所以，弄了一个工具类，根据表名去查询该表的字段生成实体类，代码如下：

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;

public class TableToPo {
	private String tablename = "SYS_MaterType";// 表名
	private String[] colnames; // 列名数组
	private String[] colTypes; // 列名类型数组
	private int[] colSizes; // 列名大小数组
	private boolean f_util = false; // 是否需要导入包java.util.*
	private boolean f_sql = false; // 是否需要导入包java.sql.*
	private boolean f_math = false;// 是否需要导入包java.math.*
	public TableToPo() {
		Connection con = Dbutil.getConnection();
		PreparedStatement ps = null;
		ResultSetMetaData rs = null;
		String strsql = "select * from " + tablename;
		try {
			ps = con.prepareStatement(strsql);
			rs = ps.getMetaData();
			int size = rs.getColumnCount();
			colnames = new String[size];
			colTypes = new String[size];
			colSizes = new int[size];
			for (int i = 0; i < rs.getColumnCount(); i++) {
				colnames[i] = rs.getColumnName(i + 1);
				colTypes[i] = rs.getColumnTypeName(i + 1);
				if (colTypes[i].equalsIgnoreCase("datetime")
						|| colTypes[i].equalsIgnoreCase("date")
						|| colTypes[i].equalsIgnoreCase("smalldatetime")
						|| colTypes[i].equalsIgnoreCase("time")) {
					f_sql = true;
				}
				if (colTypes[i].equalsIgnoreCase("money")
						|| colTypes[i].equalsIgnoreCase("decimal")
						|| colTypes[i].equalsIgnoreCase("smallmoney")
						|| colTypes[i].equalsIgnoreCase("numeric")) {
					f_math = true;
				}
				colSizes[i] = rs.getColumnDisplaySize(i + 1);
			}
			String content = parse(colnames, colTypes, colSizes);
			FileWriter fileWriter = new FileWriter(initcap(tablename) + ".java");
			PrintWriter pw = new PrintWriter(fileWriter);
			pw.println(content);
			pw.flush();
			pw.close();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			try {
				ps.close();
				con.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
	}
	/**
	 * 解析处理(生成实体类主体代码)
	 */
	private String parse(String[] colNames, String[] colTypes, int[] colSizes) {
		StringBuffer sb = new StringBuffer();
		if (f_util) {
			sb.append("import java.util.Date;\r\n");
		}
		if (f_sql) {
			sb.append("import java.sql.*;\r\n");
		}
		if (f_math) {
			sb.append("import java.math.BigDecimal;\r\n\r\n\r\n");
		}
		sb.append("public class " + initcap(tablename) + " {\r\n");
		processAllAttrs(sb);
		processAllMethod(sb);
		sb.append("}\r\n");
		System.out.println(sb.toString());
		return sb.toString();
	}
	/**
	 * 生成所有的方法
	 * 
	 * @param sb
	 */
	private void processAllMethod(StringBuffer sb) {
		for (int i = 0; i < colnames.length; i++) {
			sb.append("\tpublic " + sqlType2JavaType(colTypes[i]) + " get"
					+ initcap(colnames[i]) + "(){\r\n");
			sb.append("\t\treturn " + colnames[i] + ";\r\n");
			sb.append("\t}\r\n");
			sb.append("\tpublic void set" + initcap(colnames[i]) + "("
					+ sqlType2JavaType(colTypes[i]) + " " + colnames[i]
					+ "){\r\n");
			sb.append("\t\tthis." + colnames[i] + "=" + colnames[i] + ";\r\n");
			sb.append("\t}\r\n");

		}
	}
	/**
	 * 解析输出属性
	 * 
	 * @return
	 */
	private void processAllAttrs(StringBuffer sb) {
		for (int i = 0; i < colnames.length; i++) {
			sb.append("\tprivate " + sqlType2JavaType(colTypes[i]) + " "
					+ colnames[i] + ";\r\n");
		}
	}
	/**
	 * 把输入字符串的首字母改成大写
	 * 
	 * @param str
	 * @return
	 */
	private String initcap(String str) {
		char[] ch = str.toCharArray();
		if (ch[0] >= 'a' && ch[0] <= 'z') {
			ch[0] = (char) (ch[0] - 32);
		}
		return new String(ch);
	}

	private String sqlType2JavaType(String sqlType) {
		if (sqlType.equalsIgnoreCase("bit")) {
			return "Boolean";
		} else if (sqlType.equalsIgnoreCase("timestamp")
				|| sqlType.equalsIgnoreCase("binary")
				|| sqlType.equalsIgnoreCase("image")
				|| sqlType.equalsIgnoreCase("varbinary")) {
			return "byte[]";
		} else if (sqlType.equalsIgnoreCase("smallint")
				|| sqlType.equalsIgnoreCase("tinyint")) {
			return "short";
		} else if (sqlType.equalsIgnoreCase("int")) {
			return "Integer";
		} else if (sqlType.equalsIgnoreCase("bigint")) {
			return "long";
		} else if (sqlType.equalsIgnoreCase("real")) {
			return "float";
		} else if (sqlType.equalsIgnoreCase("real")
				|| sqlType.equalsIgnoreCase("float")) {
			return "double";
		} else if (sqlType.equalsIgnoreCase("money")
				|| sqlType.equalsIgnoreCase("decimal")
				|| sqlType.equalsIgnoreCase("smallmoney")
				|| sqlType.equalsIgnoreCase("numeric")) {
			return "BigDecimal";
		} else if (sqlType.equalsIgnoreCase("varchar")
				|| sqlType.equalsIgnoreCase("char")
				|| sqlType.equalsIgnoreCase("nvarchar")
				|| sqlType.equalsIgnoreCase("nchar")
				|| sqlType.equalsIgnoreCase("text")
				|| sqlType.equalsIgnoreCase("ntext")
				|| sqlType.equalsIgnoreCase("uniqueidentifier")) {
			return "String";
		} else if (sqlType.equalsIgnoreCase("date")) {
			return "Date";//Date
		} else if (sqlType.equalsIgnoreCase("smalldatetime")
				|| sqlType.equalsIgnoreCase("datetime")) {
			return "Timestamp";
		} else if (sqlType.equalsIgnoreCase("time")) {
			return "Time";
		}
		return null;
	}
	public static void main(String[] args) {
		new TableToPo();
	}
}

工具类执行效果：