• java 快速生成javaBean类

    1. package com.angen.util;
    2.  
    3. import java.io.FileWriter;
    4. import java.io.IOException;
    5. import java.sql.*;
    6. import java.util.ArrayList;
    7. import java.util.List;
    8.  
    9. /**
    10.  * @description: PojoUtil
    11.  * @date: 2022/7/20
    12.  */
    13. public class PojoUtil {
    14.     public static void main(String[] args) throws ClassNotFoundException, SQLException {
    15.         String url = "jdbc:mysql://localhost:3306/test_mybatis?useSSL=false";
    16.         String user = "root";
    17.         String pass = "root";
    18.         Class.forName("com.mysql.jdbc.Driver");
    19.         Connection conn  =  DriverManager.getConnection(url,  user,  pass);
    20.         //java文件输出路径
    21.         String path = "E:\\java重新学习\\mybatis_test\\src\\main\\java\\com\\angen\\pojo";
    22.         GetModel getModel  = new GetModel(conn);
    23.         /*
    24.         使用：
    25.             pojo: 包含属性与getter、setter
    26.             bean: 包含属性与getter、setter与无参构造器，并实现Serializable接口
    27.          */
    28.         //生成pojo到path
    29.         //getModel.generatePojo(path);
    30.         //生成pojo到path，在pojo中添加包信息"package com.ren.model"
    31.         //getModel.generatePojo(path, "com.ren.model");
    32.         //生成Bean到path
    33.         //getModel.generateBean(path);
    34.         //生成Bean到path，在Bean中添加包信息"package com.ren.bean"
    35.         //getModel.generateBean(path, "com.ren.bean");
    36.         getModel.generateBean(path);
    37.     }
    38. }
    39. class GetModel {
    40.     private Connection connection;
    41.     private List tables;
    42.  
    43.     public GetModel() {
    44.     }
    45.  
    46.     public GetModel(Connection connection) throws SQLException {
    47.         this.connection = connection;
    48.         this.tables = getTableList();
    49.     }
    50.  
    51.     public Connection getConnection() {
    52.         return connection;
    53.     }
    54.  
    55.     public void setConnection(Connection connection) {
    56.         this.connection = connection;
    57.     }
    58.  
    59.     /**
    60.      * 获取数据库中所有表信息封装到List
      61.  tables
    61.      * @return List
      62.  包含数据库中所有的表
    62.      * @throws SQLException
    63.      */
    64.     private List
      65. getTableList()throws SQLException {
    65.         List
      66.   
       tableList = newArrayList<>();
    66.         DatabaseMetaData dbMetaData = connection.getMetaData();
    67.         ResultSet rs = dbMetaData.getTables(null, null, null, new String[] { "TABLE" });
    68.         while (rs.next()) {
    69.             Table table = new Table();
    70.             String tableName = rs.getString("TABLE_NAME");
    71.             table.setTableName(tableName);
    72.             table.setDatabaseName(rs.getString("TABLE_CAT"));
    73.             table.setColumns(getTableColumnList(tableName));
    74.             tableList.add(table);
    75.         }
    76.         return tableList;
    77.     }
    78.  
    79.     /**
    80.      * 获取某表的所有column信息封装到List columnList中
    81.      */
    82.     private List getTableColumnList(String tableName) throws SQLException {
    83.         List columnList = new ArrayList<>();
    84.         String  sql  =  "select  *  from " + tableName;
    85.         PreparedStatement  stmt;
    86.         try  {
    87.             stmt  =  connection.prepareStatement(sql);
    88.             ResultSet  rs  =  stmt.executeQuery(sql);
    89.             ResultSetMetaData  data  =  rs.getMetaData();
    90.             for  (int  i  =  1; i  <=  data.getColumnCount(); i++)  {
    91.                 Column column = new Column();
    92.                 //  获得所有列的数目及实际列数
    93.                 int  columnCount  =  data.getColumnCount();
    94.                 //  获得指定列的列名
    95.                 String  columnName  =  data.getColumnName(i);
    96.                 //  获得指定列的数据类型名
    97.                 String  columnTypeName  =  data.getColumnTypeName(i);
    98.                 //  对应数据类型的类
    99.                 String  columnClassName  =  data.getColumnClassName(i);
    100.                 //  在数据库中类型的最大字符个数
    101.                 int  columnDisplaySize  =  data.getColumnDisplaySize(i);
    102.                 //  某列类型的精确度(类型的长度)
    103.                 int  precision  =  data.getPrecision(i);
    104.                 //  小数点后的位数
    105.                 int  scale  =  data.getScale(i);
    106.                 //  是否自动递增
    107.                 Boolean  isAutoInctement  =  data.isAutoIncrement(i);
    108.                 //  是否为空
    109.                 int  isNullable  =  data.isNullable(i);
    110.                 column.setColumnName(columnName);
    111.                 column.setColumnTypeName(columnTypeName);
    112.                 column.setColumnClassName(columnClassName);
    113.                 column.setTableName(tableName);
    114.                 column.setColumnDisplaySize(columnDisplaySize);
    115.                 column.setPrecision(precision);
    116.                 column.setScale(scale);
    117.                 column.setAutoInctement(isAutoInctement);
    118.                 columnList.add(column);
    119.             }
    120.         }
    121.         catch  (SQLException  e)  {
    122.             e.printStackTrace();
    123.         }
    124.         return columnList;
    125.     }
    126.  
    127.     /**
    128.      * 为table创建pojo
    129.      * @param table 表
    130.      * @param path 输出路径
    131.      */
    132.     private static void writeFilePojo(Table table, String path, String packagePath) {
    133.         String fileName = path + "\\" + upperCase(table.getTableName()) + ".java";
    134.         try {
    135.             FileWriter writer = new FileWriter(fileName);
    136.             StringBuilder  getterSetter = new StringBuilder();
    137.             //需要添加包路径
    138.             if (!packagePath.equals("0")) {
    139.                 writer.write("package " + packagePath + ";\n\n");
    140.             }
    141.             writer.write("public class " + upperCase(table.getTableName()) + " {\n");
    142.             for (Column column : table.getColumns()) {
    143.                 writer.write("    private " + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + ";\n");
    144.                 //getter()
    145.                 getterSetter.append("\n    public " + changeType(column.getColumnTypeName()) + " get" + upperCase(column.getColumnName()) + "() {\n");
    146.                 getterSetter.append("        return " + column.getColumnName() + ";\n");
    147.                 getterSetter.append("    }\n\n");
    148.                 //setter()
    149.                 getterSetter.append("    public void set" + upperCase(column.getColumnName()) + "(" + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + ") {\n");
    150.                 getterSetter.append("        this." + column.getColumnName() + " = " + column.getColumnName() + ";\n");
    151.                 getterSetter.append("    }\n");
    152.             }
    153.             writer.write(getterSetter.toString());
    154.             writer.write("}");
    155.             writer.close();
    156.         } catch (IOException e) {
    157.             e.printStackTrace();
    158.         }
    159.     }
    160.  
    161.     /**
    162.      * 为table创建Bean
    163.      * @param table 表
    164.      * @param path 输出路径
    165.      */
    166.     private static void writeFileBean(Table table, String path, String packagePath) {
    167.         String fileName = path + "\\" + upperCase(table.getTableName()) + ".java";
    168.         try {
    169.             FileWriter writer = new FileWriter(fileName);
    170.             StringBuilder  getterSetter = new StringBuilder();
    171.             //需要添加包路径
    172.             if (!packagePath.equals("0")) {
    173.                 writer.write("package " + packagePath + ";\n\n");
    174.             }
    175.             writer.write("import java.io.Serializable;\n\n");
    176.             writer.write("public class " + upperCase(table.getTableName()) + " implements Serializable {\n");
    177.             for (Column column : table.getColumns()) {
    178.                 writer.write("    private " + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + ";\n");
    179.                 //getter()
    180.                 getterSetter.append("\n    public " + changeType(column.getColumnTypeName()) + " get" + upperCase(column.getColumnName()) + "() {\n");
    181.                 getterSetter.append("        return " + column.getColumnName() + ";\n");
    182.                 getterSetter.append("    }\n\n");
    183.                 //setter()
    184.                 getterSetter.append("    public void set" + upperCase(column.getColumnName()) + "(" + changeType(column.getColumnTypeName()) + " " + column.getColumnName() + ") {\n");
    185.                 getterSetter.append("        this." + column.getColumnName() + " = " + column.getColumnName() + ";\n");
    186.                 getterSetter.append("    }\n");
    187.             }
    188.             //无参构造器
    189.             writer.write("\n    public " + upperCase(table.getTableName()) + "() { }\n");
    190.             writer.write(getterSetter.toString());
    191.             writer.write("}");
    192.             writer.close();
    193.         } catch (IOException e) {
    194.             e.printStackTrace();
    195.         }
    196.     }
    197.  
    198.     /**
    199.      * 将 str 首字母大写
    200.      * @param str
    201.      * @return
    202.      */
    203.     private static String upperCase(String str) {
    204.         return str.substring(0, 1).toUpperCase() + str.substring(1);
    205.     }
    206.  
    207.     /**
    208.      * 将数据库类型转换为java中合适的类型
    209.      * @param typeName
    210.      * @return
    211.      */
    212.     private static String changeType(String typeName) {
    213.         switch (typeName) {
    214.             case "VARCHAR":
    215.             case "CHAR":
    216.             case "TEXT":
    217.             case "TINYTEXT":
    218.             case "MEDIUMTEXT":
    219.             case "LONGTEXT":
    220.             case "ENUM":
    221.             case "SET":
    222.                 return "String";
    223.             case "BLOB":
    224.             case "BINARY":
    225.             case "VARBINARY":
    226.             case "TINYBLOB":
    227.             case "MEDIUMBLOB":
    228.             case "LONGBLOB":
    229.                 return "byte[]";
    230.             case "INTEGER":
    231.             case "ID":
    232.             case "BIGINT":
    233.                 return "Long";
    234.             case "TINYINT":
    235.             case "SMALLINT":
    236.             case "MEDIUMINT":
    237.             case "INT":
    238.                 return "Integer";
    239.             case "DECIMAL":
    240.                 return "BigDecimal";
    241.             case "BIT":
    242.                 return "Boolean";
    243.             case "FLOAT":
    244.                 return "Float";
    245.             case "DOUBLE":
    246.                 return "Double";
    247.             case "DATE":
    248.             case "YEAR":
    249.                 return "Date";
    250.             case "TIME":
    251.                 return "Time";
    252.         }
    253.         return "String";
    254.     }
    255.  
    256.     /**
    257.      * 根据tables生成pojo到path
    258.      * @param path 输出路径
    259.      */
    260.     public void generatePojo(String path) {
    261.         for (Table table : tables) {
    262.             writeFilePojo(table, path, "0");
    263.             System.out.println("已创建Pojo: " + path + "\\" + upperCase(table.getTableName()) + ".java");
    264.         }
    265.     }
    266.  
    267.     /**
    268.      * 根据tables生成Bean到path
    269.      * @param path 输出路径
    270.      */
    271.     public void generateBean(String path) {
    272.         for (Table table : tables) {
    273.             writeFileBean(table, path, "0");
    274.             System.out.println("已创建Bean: " + path + "\\" + upperCase(table.getTableName()) + ".java");
    275.         }
    276.     }
    277.  
    278.     /**
    279.      * 根据tables生成pojo到path
    280.      * @param path 输出路径
    281.      * @param packagePath 添加包路径
    282.      */
    283.     public void generatePojo(String path, String packagePath) {
    284.         for (Table table : tables) {
    285.             writeFilePojo(table, path, packagePath);
    286.             System.out.println("已创建Pojo: " + path + "\\" + upperCase(table.getTableName()) + ".java    包名：" + packagePath);
    287.         }
    288.     }
    289.  
    290.     /**
    291.      * 根据tables生成Bean到path
    292.      * @param path 输出路径
    293.      * @param packagePath 添加包路径
    294.      */
    295.     public void generateBean(String path, String packagePath) {
    296.         for (Table table : tables) {
    297.             writeFileBean(table, path, packagePath);
    298.             System.out.println("已创建Bean: " + path + "\\" + upperCase(table.getTableName()) + ".java    包名：" + packagePath);
    299.         }
    300.     }
    301. }
    302. class Table {
    303.     private String tableName;
    304.     private String databaseName;
    305.     private List columns;
    306.  
    307.     public String getTableName() {
    308.         return tableName;
    309.     }
    310.  
    311.     public void setTableName(String tableName) {
    312.         this.tableName = tableName;
    313.     }
    314.  
    315.     public String getDatabaseName() {
    316.         return databaseName;
    317.     }
    318.  
    319.     public void setDatabaseName(String databaseName) {
    320.         this.databaseName = databaseName;
    321.     }
    322.  
    323.     public List getColumns() {
    324.         return columns;
    325.     }
    326.  
    327.     public void setColumns(List columns) {
    328.         this.columns = columns;
    329.     }
    330.  
    331.     @Override
    332.     public String toString() {
    333.         return "Table{" +
    334.                 "\n     tableName='" + tableName + '\'' +
    335.                 "\n     databaseName='" + databaseName + '\'' +
    336.                 "\n     columns=" + columns +
    337.                 '}';
    338.     }
    339. }
    340. class Column {
    341.     //  列名
    342.     private String columnName;
    343.     // 列的数据类型名
    344.     private String columnTypeName;
    345.     //  对应数据类型的类
    346.     private String columnClassName;
    347.     //  在数据库中类型的最大字符个数
    348.     private int columnDisplaySize;
    349.     //  某列类型的精确度(类型的长度)
    350.     private int  precision;
    351.     //  小数点后的位数
    352.     private int  scale;
    353.     //  获取某列对应的表名
    354.     private String  tableName;
    355.     //  是否自动递增
    356.     private Boolean  isAutoInctement;
    357.  
    358.     public String getColumnName() {
    359.         return columnName;
    360.     }
    361.  
    362.     public void setColumnName(String columnName) {
    363.         this.columnName = columnName;
    364.     }
    365.  
    366.     public String getColumnTypeName() {
    367.         return columnTypeName;
    368.     }
    369.  
    370.     public void setColumnTypeName(String columnTypeName) {
    371.         this.columnTypeName = columnTypeName;
    372.     }
    373.  
    374.     public String getColumnClassName() {
    375.         return columnClassName;
    376.     }
    377.  
    378.     public void setColumnClassName(String columnClassName) {
    379.         this.columnClassName = columnClassName;
    380.     }
    381.  
    382.     public int getColumnDisplaySize() {
    383.         return columnDisplaySize;
    384.     }
    385.  
    386.     public void setColumnDisplaySize(int columnDisplaySize) {
    387.         this.columnDisplaySize = columnDisplaySize;
    388.     }
    389.  
    390.     public int getPrecision() {
    391.         return precision;
    392.     }
    393.  
    394.     public void setPrecision(int precision) {
    395.         this.precision = precision;
    396.     }
    397.  
    398.     public int getScale() {
    399.         return scale;
    400.     }
    401.  
    402.     public void setScale(int scale) {
    403.         this.scale = scale;
    404.     }
    405.  
    406.     public String getTableName() {
    407.         return tableName;
    408.     }
    409.  
    410.     public void setTableName(String tableName) {
    411.         this.tableName = tableName;
    412.     }
    413.  
    414.     public Boolean getAutoInctement() {
    415.         return isAutoInctement;
    416.     }
    417.  
    418.     public void setAutoInctement(Boolean autoInctement) {
    419.         isAutoInctement = autoInctement;
    420.     }
    421.  
    422.     @Override
    423.     public String toString() {
    424.         return "\n      Column{" +
    425.                 "columnName='" + columnName + '\'' +
    426.                 ", columnTypeName='" + columnTypeName + '\'' +
    427.                 ", columnClassName='" + columnClassName + '\'' +
    428.                 ", columnDisplaySize=" + columnDisplaySize +
    429.                 ", precision=" + precision +
    430.                 ", scale=" + scale +
    431.                 ", tableName='" + tableName + '\'' +
    432.                 ", isAutoInctement=" + isAutoInctement +
    433.                 '}';
    434.     }
    435. }
      436. 
                
                    
                

                
    436. 

                    相关阅读:
      
                    
天谋科技 Timecho 完成近亿元人民币天使轮融资，打造工业物联网原生时序数据库                            
      
个人开发者轻松接入支付回调                            
      
软件测试面试题：黑盒测试、白盒测试以及单元测试、集成测试、系统测试、验收测试的区别与联系？                            
      
Kafka核心概念详解                            
      
java代码审计-某酒店管理系统                            
      
Day 62 数据结构（单向链表，单向循环链表，双向链表）                            
      
软考高级系统架构设计师系列之：深入理解设计模式                            
      
Java实现-跳跃游戏                            
      
磁环选型攻略及EMC整改技巧                            
      
STM32串口详解                            
      
                          
                
    437. 
                    原文地址：https://blog.csdn.net/qq_42572322/article/details/125897514
                
      438.