java根据数据库自动生成JavaBean或pojo

之前写了根据实体类生成sql语句和根据结果集封装实体类，现在写下根据数据库生成实体类的小工具。

程序和jar包我已经放在我的github上了：https://github.com/Renhongqiang/JavaGeneratingModel

可以根据数据连接 Connection  生成pojo或者Bean，pojo只包含属性和getter、setter方法，Bean实现可序列化接口并添加一个无参构造器。

使用 Connection 的 getMetaData() 方法可以获取包含数据库的所有表信息的 DatabaseMetaData

使用 ResultSet 的 getMetaData() 方法可以获取表的所有字段信息 ResultSetMetaData

 通过对上面DatabaseMetaData与ResultSetMetaData的操作生成java文件，使用了我定义的Table与Colum两个模型

Table.java: https://github.com/Renhongqiang/JavaGeneratingModel/blob/master/src/com/ren/model/Table.java

Colum: https://github.com/Renhongqiang/JavaGeneratingModel/blob/master/src/com/ren/model/Column.java

关于数据库数据类型与java数据类型的转换：

https://blog.csdn.net/qq_35562664/article/details/56012826

https://blog.csdn.net/zs520ct/article/details/78326204

使用实例：

public static void main(String[] args) throws SQLException, ClassNotFoundException {
        String url = "jdbc:mysql://localhost:3306/databsename?useSSL=false";
        String user = "username";
        String pass = "password";
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn  =  DriverManager.getConnection(url,  user,  pass);
        //java文件输出路径
        String path = "H:\\pojo";
        GetModel getModel  = new GetModel(conn);
        /*
        使用：
            pojo: 包含属性与getter、setter
            bean: 包含属性与getter、setter与无参构造器，并实现Serializable接口
         */
        //生成pojo到path
        //getModel.generatePojo(path);
        //生成pojo到path，在pojo中添加包信息"package com.ren.model"
        //getModel.generatePojo(path, "com.ren.model");
        //生成Bean到path
        //getModel.generateBean(path);
        //生成Bean到path，在Bean中添加包信息"package com.ren.bean"
        //getModel.generateBean(path, "com.ren.bean");
    }

 

代码：

public class GetModel {
    private Connection connection;
    private List<Table> tables;

    public GetModel() {
    }

    public GetModel(Connection connection) throws SQLException {
        this.connection = connection;
        this.tables = getTableList();
    }

    public Connection getConnection() {
        return connection;
    }

    public void setConnection(Connection connection) {
        this.connection = connection;
    }

    /**
     * 获取数据库中所有表信息封装到List<Table> tables
     * @return List<Table> 包含数据库中所有的表
     * @throws SQLException
     */
    private List<Table> getTableList() throws SQLException {
        List<Table> tableList = new ArrayList<>();
        DatabaseMetaData dbMetaData = connection.getMetaData();
        ResultSet rs = dbMetaData.getTables(null, null, null, new String[] { "TABLE" });
        while (rs.next()) {
            Table table = new Table();
            String tableName = rs.getString("TABLE_NAME");
            table.setTableName(tableName);
            table.setDatabaseName(rs.getString("TABLE_CAT"));
            table.setColumns(getTableColumnList(tableName));
            tableList.add(table);
        }
        return tableList;
    }

    /**
     * 获取某表的所有column信息封装到List<Column> columnList中
     */
    private List<Column> getTableColumnList(String tableName) throws SQLException {
        List<Column> columnList = new ArrayList<>();
        String  sql  =  "select  *  from " + tableName;
        PreparedStatement  stmt;
        try  {
            stmt  =  connection.prepareStatement(sql);
            ResultSet  rs  =  stmt.executeQuery(sql);
            ResultSetMetaData  data  =  rs.getMetaData();
            for  (int  i  =  1; i  <=  data.getColumnCount(); i++)  {
                Column column = new Column();
                //  获得所有列的数目及实际列数
                int  columnCount  =  data.getColumnCount();
                //  获得指定列的列名
                String  columnName  =  data.getColumnName(i);
                //  获得指定列的数据类型名
                String  columnTypeName  =  data.getColumnTypeName(i);
                //  对应数据类型的类
                String  columnClassName  =  data.getColumnClassName(i);
                //  在数据库中类型的最大字符个数
                int  columnDisplaySize  =  data.getColumnDisplaySize(i);
                //  某列类型的精确度(类型的长度)
                int  precision  =  data.getPrecision(i);
                //  小数点后的位数
                int  scale  =  data.getScale(i);
                //  是否自动递增
                Boolean  isAutoInctement  =  data.isAutoIncrement(i);
                //  是否为空
                int  isNullable  =  data.isNullable(i);
                column.setColumnName(columnName);
                column.setColumnTypeName(columnTypeName);
                column.setColumnClassName(columnClassName);
                column.setTableName(tableName);
                column.setColumnDisplaySize(columnDisplaySize);
                column.setPrecision(precision);
                column.setScale(scale);
                column.setAutoInctement(isAutoInctement);
                columnList.add(column);
            }
        }
        catch  (SQLException  e)  {
            e.printStackTrace();
        }
        return columnList;
    }

    /**
     * 为table创建pojo
     * @param table 表
     * @param path 输出路径
     */
    private static void writeFilePojo(Table table, String path, String packagePath) {
        String fileName = path + "\\" + upperCase(table.getTableName()) + ".java";
        try {
            FileWriter writer = new FileWriter(fileName);
            StringBuilder  getterSetter = new StringBuilder();
            //需要添加包路径
            if (!packagePath.equals("0")) {
                writer.write("package " + packagePath + ";\n\n");
            }
            writer.write("public class " + upperCase(table.getTableName()) + " {\n");
            for (Column column : table.getColumns()) {
                writer.write("    private " + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + "\n");
                //getter()
                getterSetter.append("\n    public " + changeType(column.getColumnTypeName()) + " get" + upperCase(column.getColumnName()) + "() {\n");
                getterSetter.append("        return " + column.getColumnName() + ";\n");
                getterSetter.append("    }\n\n");
                //setter()
                getterSetter.append("    public void set" + upperCase(column.getColumnName()) + "(" + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + ") {\n");
                getterSetter.append("        this." + column.getColumnName() + " = " + column.getColumnName() + ";\n");
                getterSetter.append("    }\n");
            }
            writer.write(getterSetter.toString());
            writer.write("}");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 为table创建Bean
     * @param table 表
     * @param path 输出路径
     */
    private static void writeFileBean(Table table, String path, String packagePath) {
        String fileName = path + "\\" + upperCase(table.getTableName()) + ".java";
        try {
            FileWriter writer = new FileWriter(fileName);
            StringBuilder  getterSetter = new StringBuilder();
            //需要添加包路径
            if (!packagePath.equals("0")) {
                writer.write("package " + packagePath + ";\n\n");
            }
            writer.write("import java.io.Serializable;\n\n");
            writer.write("public class " + upperCase(table.getTableName()) + " implements Serializable {\n");
            for (Column column : table.getColumns()) {
                writer.write("    private " + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + "\n");
                //getter()
                getterSetter.append("\n    public " + changeType(column.getColumnTypeName()) + " get" + upperCase(column.getColumnName()) + "() {\n");
                getterSetter.append("        return " + column.getColumnName() + ";\n");
                getterSetter.append("    }\n\n");
                //setter()
                getterSetter.append("    public void set" + upperCase(column.getColumnName()) + "(" + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + ") {\n");
                getterSetter.append("        this." + column.getColumnName() + " = " + column.getColumnName() + ";\n");
                getterSetter.append("    }\n");
            }
            //无参构造器
            writer.write("\n    public " + upperCase(table.getTableName()) + "() { }\n");
            writer.write(getterSetter.toString());
            writer.write("}");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 将 str 首字母大写
     * @param str
     * @return
     */
    private static String upperCase(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }

    /**
     * 将数据库类型转换为java中合适的类型
     * @param typeName
     * @return
     */
    private static String changeType(String typeName) {
        switch (typeName) {
            case "VARCHAR":
            case "CHAR":
            case "TEXT":
            case "TINYTEXT":
            case "MEDIUMTEXT":
            case "LONGTEXT":
            case "ENUM":
            case "SET":
                return "String";
            case "BLOB":
            case "BINARY":
            case "VARBINARY":
            case "TINYBLOB":
            case "MEDIUMBLOB":
            case "LONGBLOB":
                return "byte[]";
            case "INTEGER":
            case "ID":
            case "BIGINT":
                return "Long";
            case "TINYINT":
            case "SMALLINT":
            case "MEDIUMINT":
            case "INT":
                return "Integer";
            case "DECIMAL":
                return "BigDecimal";
            case "BIT":
                return "Boolean";
            case "FLOAT":
                return "Float";
            case "DOUBLE":
                return "Double";
            case "DATE":
            case "YEAR":
                return "Date";
            case "TIME":
                return "Time";
        }
        return "String";
    }

    /**
     * 根据tables生成pojo到path
     * @param path 输出路径
     */
    public void generatePojo(String path) {
        for (Table table : tables) {
            writeFilePojo(table, path, "0");
            System.out.println("已创建Pojo: " + path + "\\" + upperCase(table.getTableName()) + ".java");
        }
    }

    /**
     * 根据tables生成Bean到path
     * @param path 输出路径
     */
    public void generateBean(String path) {
        for (Table table : tables) {
            writeFileBean(table, path, "0");
            System.out.println("已创建Bean: " + path + "\\" + upperCase(table.getTableName()) + ".java");
        }
    }

    /**
     * 根据tables生成pojo到path
     * @param path 输出路径
     * @param packagePath 添加包路径
     */
    public void generatePojo(String path, String packagePath) {
        for (Table table : tables) {
            writeFilePojo(table, path, packagePath);
            System.out.println("已创建Pojo: " + path + "\\" + upperCase(table.getTableName()) + ".java    包名：" + packagePath);
        }
    }

    /**
     * 根据tables生成Bean到path
     * @param path 输出路径
     * @param packagePath 添加包路径
     */
    public void generateBean(String path, String packagePath) {
        for (Table table : tables) {
            writeFileBean(table, path, packagePath);
            System.out.println("已创建Bean: " + path + "\\" + upperCase(table.getTableName()) + ".java    包名：" + packagePath);
        }
    }
}