用Java来比对两个数据库的所有表，输出表、字段、注解不同的地方到txt文件中

水深无声 2023-05-28 08:27 5阅读 0赞

## 需求背景： ##

我们工作中经常会用到多个环境下的数据库，因此需要经常同步开发、生产的数据库表结构，所以我这边用java开发了一个可以快速比对2个不同数据库的所有表结构的工具类。

### 使用方法： ###

依赖：JDK1.8、MySql8、lombok(作用是省掉get set方法，可以去掉自己写get set)

只需要在main方法中输入两个数据库的连接，需要比对的数据库名称，然后运行mian方法，然后结果就会默认生成一个txt的比对结果文档到C://根目录下。如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70]

## 工具代码： ##

只需要一个JAVA类：  
**TableCompareUtil：**

package com.jack.util;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    import java.sql.*;
    import java.util.*;
    
    import lombok.Data;
    
    /** * @program: 数据库比对工具 * @description: 比对2个数据库的所有表、结构、注解的不同之处 * @author: Jack.Fang * @date: 2020年3月27日 **/
    public class TableCompareUtil { 
    
        /** * 定义数据库连接参数 */
        public static String product_driverClassName;
        public static String product_url;
        public static String product_username;
        public static String product_password;
    
        public static String develop_driverClassName;
        public static String develop_url;
        public static String develop_username;
        public static String develop_password;
    
        /** * 封装提示信息 */
        public static StringBuffer[] sb = {  new StringBuffer(), new StringBuffer(),
                new StringBuffer(), new StringBuffer(), new StringBuffer(),
                new StringBuffer() };
    
        /** * 封装表属性 */
        @Data
        static class Table { 
            //表名称
            public String tableName;
            //字段名称+字段类型
            public HashMap<String,String> column;
            //字段名称+字段注解
            public HashMap<String,String> columnComment;
        }
    
        /** * 生产库 * @return * @throws Exception */
        public static Connection getTransaction_product() throws Exception { 
            Class.forName(product_driverClassName);
            Connection conn = DriverManager.getConnection(
                    product_url, product_username, product_password);
            if (conn != null)System.out.println("生产---数据库加载成功！");
            return conn;
        }
    
        /** * 开发库 * @return * @throws Exception */
        public static Connection getTransaction_develop() throws Exception { 
            Class.forName(develop_driverClassName);
            Connection conn = DriverManager.getConnection(
                    develop_url,develop_username,develop_password);
            if (conn != null)System.out.println("开发---数据库加载成功！");
            return conn;
        }
    
        /** * 初始化 比对文件提示信息 */
        public static void initSbString(){ 
            sb[0].append("1、生产存在，开发不存在的表：\r\n");
            sb[1].append("2、生产不存在，开发存在的表：\r\n");
            sb[2].append("3、生产存在，开发不存在的字段：\r\n");
            sb[3].append("4、生产不存在，开发存在的字段：\r\n");
            sb[4].append("5、表和字段都相同，但字段类型不同的内容：\r\n");
            sb[5].append("6、表和字段、字段类型都相同，但字段注解不同的内容：\r\n");
        }
    
        /** * 比较生产库和开发库的数据表，包括表名、字段名、字段类型、字段注解 * @param product_dbSchema 生产库 名称 * @param develop_dbSchema 开发库 名称 * @throws Exception */
        public static void compareTables(String product_dbSchema,String develop_dbSchema) throws Exception { 
    
            // 初始化SubString[]
            initSbString();
    
            // 生产数据库连接
            Connection connection_product = getTransaction_product();
            Map<String, Table> map_product = getTables(connection_product,product_dbSchema);
    
            // 开发数据库连接
            Connection connection_develop = getTransaction_develop();
            Map<String, Table> map_develop = getTables(connection_develop,develop_dbSchema);
    
            System.out.println("START----开始比对开发库");
            // 遍历开发库Map
            for (Iterator<String> iter_table = map_develop.keySet().iterator(); iter_table
                    .hasNext();) { 
                String key_table = (String) iter_table.next();
                Table table_develop = map_develop.get(key_table);// 获得开发库中的表
                Table table_product = map_product.get(key_table);// 尝试从生产库中获得同名表
                if (table_product == null) {  // 如果获得表为空，说明开发存在，生产不存在
                    append(table_develop, null, 2);
                } else {  // 表相同，判断字段、字段类型、字段注解
                    for (Iterator<String> column_develop = table_develop.column.keySet().iterator(); column_develop
                            .hasNext();) { 
                        String key_column = (String) column_develop.next();
                        String value_develop = table_develop.column.get(key_column);// 获得开发库中的列
                        String value_column = table_product.column.get(key_column);// 尝试从生产库中获得同名列
                        if (value_column == null) { // 如果列名为空，说明开发存在，生产不存在
                            append(table_develop, key_column, 4);
                        } else { // 说明两者都存在
                            if (!value_column.equals(value_develop))// 字段类型不一致
                                append(table_develop, key_column, 5);
    
                            String comment_product = table_product.columnComment.get(key_column);// 获得生产库中的字段注解
                            String develop_product = table_develop.columnComment.get(key_column);// 尝试从开发库中获得同名字段注解
                            if (!comment_product.equals(develop_product))// 字段注解不一致
                                append(table_develop, key_column, 6);
                        }
                    }
                }
            }
            System.out.println("END----结束比对开发库");
    
            System.out.println("START----开始比对生产库");
            // 遍历生产库Map
            for (Iterator<String> iter_table = map_product.keySet().iterator(); iter_table
                    .hasNext();) { 
                String key_table = (String) iter_table.next();
                Table table_product = map_product.get(key_table);// 从生产库中获得同名表
                Table table_develop = map_develop.get(key_table);// 尝试获得开发库中的表
                if (table_develop == null) {  // 如果获得表为空，说明生产存在，开发不存在
                    append(table_product, null, 1);
                } else {  // 表相同，判断字段、字段类型、字段注解
                    for (Iterator<String> column_product = table_product.getColumn().keySet().iterator(); column_product
                            .hasNext();) { 
                        String key_column = (String) column_product.next();
                        String value_column = table_product.column.get(key_column);// 获得生产库中的列
                        String value_develop = table_develop.column.get(key_column);// 尝试从开发库中获得同名列
                        if (value_develop == null) { // 如果列名为空，说明生产存在，开发不存在
                            append(table_develop, key_column, 3);
                        }
    
                        // 字段相等 类型或者注解不相等上一步已经比对过，这里无需重复比对。
                    }
                }
            }
            System.out.println("END----结束比对生产库");
        }
    
        /** * 封装TABLE数据 * @param connection * @param tableSchema * @return * @throws Exception */
        public static Map<String, Table> getTables(Connection connection,String tableSchema)
                throws Exception { 
    
            String sSql = "SELECT \n" +
                    " table_name AS tableName,\n" +
                    " GROUP_CONCAT(column_name) AS columnName,\n" +
                    " GROUP_CONCAT(column_type) AS columnType,\n" +
                    " GROUP_CONCAT(IF(column_comment=\"\",\"无\",column_comment)) AS columnComment\n" +
                    "FROM\n" +
                    " information_schema.`COLUMNS` \n" +
                    "WHERE table_schema = '"+tableSchema+"' \n" +
                    "GROUP BY tableName\n" +
                    "ORDER BY tableName;";
    
            Statement statement = connection.createStatement();//创建Statement对象
            ResultSet rs = statement.executeQuery(sSql);
    
            Map<String, Table> map = new HashMap<String, Table>();
            while (rs.next()) { 
                Table table = new Table();
                HashMap<String,String> columnMap = new HashMap<>();
                HashMap<String,String> columnCommentMap = new HashMap<>();
    
                    table.setTableName(rs.getString("tableName"));
                    String columnName = rs.getString("columnName");
                    String columnType = rs.getString("columnType");
                    String columnComment = rs.getString("columnComment");
                    String columnName_ [] = columnName.split(",");
                    String columnType_ [] = columnType.split(",");
                    String columnComment_ [] = columnComment.split(",");
    
                    for(int i=0;i<columnName_.length;i++){ 
                        columnMap.put(columnName_[i],columnType_[i]);
                        columnCommentMap.put(columnName_[i],columnComment_[i]);
                    }
                    table.setColumn(columnMap);
                    table.setColumnComment(columnCommentMap);
                    map.put(rs.getString("tableName"), table);
            }
            if (rs!=null)
                rs.close();
            connection.close();
            return map;
        }
    
        /** * 封装提示信息 （追加到满足条件的StringBuffer） * @param table * @param column * @param flag * @throws Exception */
        public static void append(Table table, String column, int flag)
                throws Exception { 
            switch (flag) { 
                case 1:
                    System.out.println("1、生产存在，开发不存在的表：" + table.getTableName()+ "\r\n");
                    sb[0].append(table.getTableName() + "\r\n");
                    break;
                case 2:
                    System.out.println("2、生产不存在，开发存在的表：" + table.getTableName()+ "\r\n");
                    sb[1].append(table.getTableName() + "\r\n");
                    break;
                case 3:
                    System.out.println("3、生产存在，开发不存在的字段：" + table.getTableName() + "["+ column+"]\r\n");
                    sb[2].append(table.getTableName() + "["+ column+"]\r\n");
                    break;
                case 4:
                    System.out.println("4、生产不存在，开发存在的字段：" + table.getTableName() + "["+ column+"]\r\n");
                    sb[3].append(table.getTableName() + "["+ column+"]\r\n");
                    break;
                case 5:
                    System.out.println("5、表和字段都相同，但字段类型不同的内容：" + "["+ column+"]["+table.column.get(column)+"]\r\n");
                    sb[4].append(table.getTableName() + "["+ column+"]["+table.column.get(column)+"]\r\n");
                    break;
                case 6:
                    System.out.println("6、表和字段、字段类型都相同，但字段注解不同的内容：" + table.getTableName() + "["+ column+"]["+table.columnComment.get(column)+"]\r\n");
                    sb[5].append(table.getTableName() + "["+ column+"]["+table.columnComment.get(column)+"]\r\n");
                    break;
            }
        }
    
        /** * 写出比对结果到文件 * 将StringBuffer中的值写入文件中 * @throws Exception */
        public static void writeFile() throws Exception { 
            // 合并输出到txt
            StringBuffer rs = new StringBuffer();
            rs.append(sb[0]+ "\r\n\r\n").append(sb[1]+ "\r\n\r\n").append(sb[2]+ "\r\n\r\n").append(sb[3]+ "\r\n\r\n").append(sb[4]+ "\r\n\r\n").append(sb[5]+ "\r\n\r\n");
    
            File file = new File("c://数据库比对结果.txt");
            OutputStream os = new FileOutputStream(file);
            os.write(rs.toString().getBytes());
            os.flush();
            os.close();
        }
    
        /** * 两个数据库比对步骤： * 1、修改 生产库 和 开发库 数据库连接地址 * 2、main方法中传入 生产库 和 开发库 需要比对的数据库名称 * 3、运行main方法 * 4、生成的比对文件默认在 C:盘根目录 * @param args * @throws Exception */
        public static void main(String[] args) throws Exception { 
    
            // 1、配置数据库
            // ~ 生产库
            product_driverClassName = "com.mysql.cj.jdbc.Driver";
            product_url = "jdbc:mysql://localhost:3306/db_test_product?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai";
            product_username = "root";
            product_password = "123456";
    
            // ~ 开发库
            develop_driverClassName = "com.mysql.cj.jdbc.Driver";
            develop_url = "jdbc:mysql://localhost:3306/db_test_develop?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai";
            develop_username = "root";
            develop_password = "123456";
    
            // 2、传入生产库 和开发库 数据库名称
            compareTables("db_test_product","db_test_develop");
    
            // 3、 写入文件
            writeFile();
        }
    }

## 执行结果： ##

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 1]  
生成的比对文件：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 3]

## 备注： ##

此工具类目前只适配**Mysql数据库**。其他数据库类型，可以自己按需修改下个别代码块。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70]: /images/20230528/a43ac2672f284930a2997a5d9b5e44e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/5c3fdc9686744b5ab421fa3a8224607d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/821ac651e265442a9c688968ec57b0d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZhbmdjaGFvMjAxMQ_size_16_color_FFFFFF_t_70 3]: /images/20230528/e8eeb9631dca491ebdeef464e7f9042f.png