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

爱被打了一巴掌 2022-01-27 11:19 434阅读 0赞

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

程序和jar包我已经放在我的github上了：[https://github.com/Renhongqiang/JavaGeneratingModel][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][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][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_qq_35562664_article_details_56012826]

[https://blog.csdn.net/zs520ct/article/details/78326204][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);
            }
        }
    }

[https_github.com_Renhongqiang_JavaGeneratingModel]: https://github.com/Renhongqiang/JavaGeneratingModel
[https_github.com_Renhongqiang_JavaGeneratingModel_blob_master_src_com_ren_model_Table.java]: https://github.com/Renhongqiang/JavaGeneratingModel/blob/master/src/com/ren/model/Table.java
[https_github.com_Renhongqiang_JavaGeneratingModel_blob_master_src_com_ren_model_Column.java]: https://github.com/Renhongqiang/JavaGeneratingModel/blob/master/src/com/ren/model/Column.java
[https_blog.csdn.net_qq_35562664_article_details_56012826]: https://blog.csdn.net/qq_35562664/article/details/56012826
[https_blog.csdn.net_zs520ct_article_details_78326204]: https://blog.csdn.net/zs520ct/article/details/78326204