java实现mysql两个数据库对比表结构是否一致

已于 2023-05-08 17:22:49 修改
阅读量2.7k 收藏 10
点赞数 4
文章标签： 数据库 mysql
于 2023-05-08 17:20:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqnbsp/article/details/130563342
版权

【使用场景】

本地开发完后，增加或者删除了字段，或者修改了字段属性。

如何判定现场环境和本地环境的数据表结构一致性？ 肉眼看的话，实在是一个大的工作量，所以开发了此工具。

【类存放路径】

CompareDbMain是主函数。

【具体代码】

public class ColumnEntity {
    private String tableName;
    private String columnName;
    private String columnTypeName;
    private Integer columnDisplaySize;
    private Integer scale;

    public String getTableName() {
        return tableName;
    }

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

    public String getColumnName() {
        return columnName;
    }

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

    public String getColumnTypeName() {
        return columnTypeName;
    }

    public void setColumnTypeName(String columnTypeName) {
        this.columnTypeName = columnTypeName;
    }

    public Integer getColumnDisplaySize() {
        return columnDisplaySize;
    }

    public void setColumnDisplaySize(Integer columnDisplaySize) {
        this.columnDisplaySize = columnDisplaySize;
    }

    public Integer getScale() {
        return scale;
    }

    public void setScale(Integer scale) {
        this.scale = scale;
    }
}

public class TableEntity {
    private String tableName; //表名
    private String tableType; //表类型
    private String tableCat; //表所属数据库
    private String tableSchem; //表所属用户名
    private String remarks; //表备注

    public String getTableName() {
        return tableName;
    }

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

    public String getTableType() {
        return tableType;
    }

    public void setTableType(String tableType) {
        this.tableType = tableType;
    }

    public String getTableCat() {
        return tableCat;
    }

    public void setTableCat(String tableCat) {
        this.tableCat = tableCat;
    }

    public String getTableSchem() {
        return tableSchem;
    }

    public void setTableSchem(String tableSchem) {
        this.tableSchem = tableSchem;
    }

    public String getRemarks() {
        return remarks;
    }

    public void setRemarks(String remarks) {
        this.remarks = remarks;
    }
}
import java.sql.*;

/**
 * JDBC工具类
 * 包含数据库连接及关闭数据库资源
 */
public class MysqlDBTools {
    static Connection connection = null;
    static PreparedStatement preparedStatement = null;
    static ResultSet resultSet = null;
    static String DB_URL = "";
    static String DB_USER = "";
    static String DB_PWD = "";

    public MysqlDBTools(String dbUrl, String dbUser, String dbPwd){
        this.DB_URL = dbUrl;
        this.DB_USER = dbUser;
        this.DB_PWD = dbPwd;
    }

    public static Connection getConnection(){
        try{
            Class.forName("com.mysql.cj.jdbc.Driver");
            connection = DriverManager.getConnection(DB_URL, DB_USER, DB_PWD);
        }catch (Exception e){
            System.out.println("连接失败！");
            e.printStackTrace();
        }
        return connection;
    }


    public static void close(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet){
        if(resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if(preparedStatement != null){
            try {
                preparedStatement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }

        if(connection != null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}
import java.sql.*;
import java.util.*;

/**
 * 功能
 * 更新可能因为数据表结构发生变化导致程序启动失败
 * 此程序能查找对比两个数据库的表结构以及字段的差异
 * 方便查找问题所在
 */
public class CompareDbMain {

    private static String db_url1 = "jdbc:mysql://xx.xx.xx.xx:3306/udesign?useUnicode=true&characterEncoding=utf8&useSSL=false";
    private static String db_user1 = "root";
    private static String db_pwd1 = "xxx";

    private static String db_url2 = "jdbc:mysql://xx.xx.xx.xx:3306/udesign-v2?useUnicode=true&characterEncoding=utf8&useSSL=false";
    private static String db_user2 = "root";
    private static String db_pwd2 = "xxx";

    public static void main(String[] args) throws Exception{
        System.out.println("[结果说明]");
        System.out.println("1. ++表示A比B多，--表示A比B少，**表示有变化");
        System.out.println("");

        Connection conn1 = new MysqlDBTools(db_url1, db_user1, db_pwd1).getConnection();
        Connection conn2 = new MysqlDBTools(db_url2, db_user2, db_pwd2).getConnection();

        //对比表信息
        List<TableEntity> tables1 = getTables(conn1);
        List<TableEntity> tables2 = getTables(conn2);
        StringBuffer tableRes = compareTable(tables1, tables2);
        System.out.println("[表对比结果]");
        System.out.println(conn1.getCatalog() + " vs " + conn2.getCatalog());
        System.out.println(tableRes);

        StringBuffer columnRes = compareColumn(conn1, conn2, tables1, tables2);
        System.out.println("[表字段对比结果]");
        System.out.println(columnRes);
    }


    public static StringBuffer compareColumn(Connection conn1, Connection conn2, List<TableEntity> tables1, List<TableEntity> table2){
        StringBuffer sb = new StringBuffer();
        for(TableEntity t1: tables1){
            if(tableContains(table2, t1)){
                sb.append("["+ t1.getTableName() +"]"  + "\r\n");
                List<ColumnEntity> columnEntities1 = getColumns(conn1, t1);
                List<ColumnEntity> columnEntities2 = getColumns(conn2, t1);

                for(ColumnEntity c1: columnEntities1){
                    if(columnContains(columnEntities2, c1)){
                        ColumnEntity c2 = getColumnFromList(columnEntities2, c1);
                        if(!c2.getColumnDisplaySize().equals(c1.getColumnDisplaySize())
                        || !c2.getColumnTypeName().equals(c1.getColumnTypeName())
                        || !c2.getScale().equals(c1.getScale())){
                            sb.append("  **" + c2.getColumnName() + "\r\n");
                        }
                        //System.out.println("对比字段属性");
                        continue;
                    }
                }

                for(ColumnEntity c2: columnEntities2){
                    if(!columnContains(columnEntities1, c2)){
                        sb.append("  --" + c2.getColumnName() + "\r\n");
                        continue;
                    }
                }

                for(ColumnEntity c1: columnEntities1){
                    if(!columnContains(columnEntities2, c1)){
                        sb.append("  ++" + c1.getColumnName() + "\r\n");
                        continue;
                    }
                }
            }
        }
        return sb;
    }
    //对比表信息
    public static StringBuffer compareTable(List<TableEntity> tab1, List<TableEntity> tab2){
        StringBuffer sb = new StringBuffer();
        for(TableEntity t1: tab1){
            if(tableContains(tab2, t1)){
                sb.append("    " + t1.getTableName() + "\r\n");
                continue;
            }
        }

        for(TableEntity t2: tab2){
            if(!tableContains(tab1, t2)){
                sb.append("  --" + t2.getTableName() + "\r\n");
                continue;
            }
        }

        for(TableEntity t1: tab1){
            if(!tableContains(tab2, t1)){
                sb.append("  ++" + t1.getTableName() + "\r\n");
                continue;
            }
        }

        return sb;
    }
    //获取字段信息
    public static List<ColumnEntity> getColumns(Connection conn, TableEntity table){
        List<ColumnEntity> columnEntities = new LinkedList<>();
        String sql = "select * from " + table.getTableName();
        try {
            PreparedStatement ps = conn.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            ResultSetMetaData meta = rs.getMetaData();
            int columnCount = meta.getColumnCount();
            for (int i = 1; i < columnCount + 1; i++) {
                ColumnEntity columnEntity = new ColumnEntity();
                columnEntity.setColumnName(meta.getColumnName(i).toLowerCase());
                columnEntity.setColumnTypeName( meta.getColumnTypeName(i).toLowerCase());
                columnEntity.setColumnDisplaySize(meta.getColumnDisplaySize(i));
                columnEntity.setScale(meta.getScale(i));
                columnEntity.setTableName(meta.getTableName(i).toLowerCase());

                columnEntities.add(columnEntity);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return columnEntities;
    }

    //获取表信息
    public static List<TableEntity> getTables(Connection conn){
        List<TableEntity> tableEntities = new LinkedList<>();
        try {
            DatabaseMetaData dbMetaData = conn.getMetaData();
            ResultSet rs = dbMetaData.getTables(conn.getCatalog(), null, null,new String[] { "TABLE" });
            while (rs.next()) {// ///TABLE_TYPE/REMARKS
                TableEntity table = new TableEntity();
                table.setTableName(rs.getString("TABLE_NAME").toLowerCase());
                table.setTableType(rs.getString("TABLE_TYPE").toLowerCase());
                table.setTableCat(rs.getString("TABLE_CAT").toLowerCase());
                table.setTableSchem(rs.getString("TABLE_SCHEM")==null? "": rs.getString("TABLE_SCHEM").toLowerCase());
                table.setRemarks(rs.getString("REMARKS").toLowerCase());
                tableEntities.add(table);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return tableEntities;
    }

    //从list里面获取
    public static ColumnEntity getColumnFromList(List<ColumnEntity> columnEntities, ColumnEntity column){
        for(ColumnEntity c: columnEntities){
            if(c.getColumnName().equals(column.getColumnName())
                    && c.getTableName().equals(column.getTableName())){
                return c;
            }
        }

        return null;
    }

    public static boolean tableContains(List<TableEntity> tableEntities, TableEntity table){
        for(TableEntity tab: tableEntities){
            if(tab.getTableName().equals(table.getTableName())){
                return true;
            }
        }

        return  false;
    }

    public static boolean columnContains(List<ColumnEntity> columnEntities, ColumnEntity column){
        for(ColumnEntity tab: columnEntities){
            if(tab.getColumnName().equals(column.getColumnName())
                    && tab.getTableName().equals(column.getTableName())){
                return true;
            }
        }

        return false;
    }
}

结果展示：

[结果说明]
1. ++表示A比B多，--表示A比B少，**表示有变化

[表对比结果]
udesign vs udesign-v2
    b_busi_type
    b_busi_type_l2
    c_config_version
    c_datasource_attr
    c_datasource_attr_set
    c_datasource_change_plan
    c_datasource_corba
    c_datasource_ftp
    c_datasource_info
    c_datasource_jdbc
    c_datasource_kafka
    c_datasource_pipe
    c_datasource_sdtp
    c_datasource_snmp
    c_datasource_socket
    c_datasource_subscribe
    c_dict_data_version
    c_dict_devicetype
    c_dict_net_type
    c_dict_protocol
    c_dict_region
    c_dict_specility
    c_dict_specility_level
    c_dict_vendor
    c_image
    c_image_env
    c_kafka_send_log
    c_omc_device_type
    c_omc_info
    c_omc_ne
    c_omc_net_type
    c_redis_monitor
    c_specility_topic
    collect_schedule_file_log
    collect_schedule_ftp_log
    collect_schedule_ftp_log_d
    collect_schedule_ftp_wait
    collect_schedule_time_log
    collect_stage
    collect_stage_log
    collect_stage_rel
    collect_task
    collect_task_log
    group_info
    pars_data_class
    s_protocoltype
    sys_dict
    sys_dict_item
    ue_component
    ue_component_class
    ue_dir
    ue_dir_type
    ue_etl_task_publish
    ue_stage
    ue_stage_meta_rel
    ue_task
    ue_task_publish
    ue_template
    ue_template_stage
    ue_workspace
  ++kafka

[表字段对比结果]
[b_busi_type]
[b_busi_type_l2]
[c_config_version]
[c_datasource_attr]
[c_datasource_attr_set]
[c_datasource_change_plan]
[c_datasource_corba]
[c_datasource_ftp]
[c_datasource_info]
[c_datasource_jdbc]
[c_datasource_kafka]
[c_datasource_pipe]
[c_datasource_sdtp]
[c_datasource_snmp]
[c_datasource_socket]
[c_datasource_subscribe]
[c_dict_data_version]
[c_dict_devicetype]
[c_dict_net_type]
[c_dict_protocol]
[c_dict_region]
  **county_name
[c_dict_specility]
[c_dict_specility_level]
[c_dict_vendor]
[c_image]
[c_image_env]
[c_kafka_send_log]
[c_omc_device_type]
[c_omc_info]
[c_omc_ne]
[c_omc_net_type]
[c_redis_monitor]
[c_specility_topic]
[collect_schedule_file_log]
[collect_schedule_ftp_log]
[collect_schedule_ftp_log_d]
[collect_schedule_ftp_wait]
[collect_schedule_time_log]
[collect_stage]
[collect_stage_log]
[collect_stage_rel]
[collect_task]
  ++group_names
[collect_task_log]
[group_info]
[pars_data_class]
[s_protocoltype]
[sys_dict]
[sys_dict_item]
[ue_component]
[ue_component_class]
[ue_dir]
[ue_dir_type]
[ue_etl_task_publish]
[ue_stage]
[ue_stage_meta_rel]
[ue_task]
[ue_task_publish]
  --group_names
[ue_template]
[ue_template_stage]
[ue_workspace]

1.多了kafka表

2.c_dict_region county_name字段属性不一致

3. collect_task多了group_names字段

4.ue_task_publish少了group_names字段

早退的程序员
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
对比两个数据库的表结构
weixin_43776272的博客
12-19 3815
测试数据库和实际数据库的表结构查缺补漏 可以比较数据库表结构、视图、存储过程、触发器的不同。 比较两个数据库全部表结构的差异， 包括表名、存储引擎、字符集、注释的不同， 以及每张表中的字段名、数据类型、字符集、默认值、注释的不同， 还有索引的不同、字段顺序的不同。 比较两个数据库全部视图的差异。 比较两个数据库全部存储过程的差异。 比较两个数据库全部触发器的差异。 支持MySQL、MS SQL S...
mysql表结构比对工具，数据库结构对比工具
oTimecom的博客
04-20 590
然后在设置中按照下图操作即可，操作简单方便，对于迭代升级程序数据结构不二之选。
mysql 不同库之间的表结构对比
你走过的路 风都是暖的
09-15 537
五步轻松搞定再也不用担心正式库缺失字段了。
Mysql 升级如何对比表结构差异
最新发布
qq_34831192的博客
05-09 316
最近在升级公司的一个项目时，由于需要升级的版本与现场版本的时间跨度过大，研发在进行开发的时候没有记录sql变更，导致一时间难以弄清楚，需要做哪些sql调整，梳理下怎么比较处数据库结构的差异。
推荐：apgdiff - 快速比较与生成数据库差异脚本
gitblog_00095的博客
03-17 394
推荐：apgdiff - 快速比较与生成数据库差异脚本 什么是apgdiff？ apgdiff 是一个开源的 Java 库，用于比较两个数据库之间的结构差异，并自动生成 SQL 脚本来更新旧的数据库以匹配新的结构。 https://gitcode.com/fordfrog/apgdiff?utm_source=artical_gitcode apgdiff 可以用来做什么？ 比较数据库版本间的结...
比较两个数据库之间的差异
lanzongjie198200的专栏
12-28 497
import java.sql.Connection; import java.sql.Driver; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.Ha...
对比两个数据库表结构(支持sql2008)
03-26
在项目做好后实施了以后,可能因为需求等原因需要升级, 这时候一般都是在测试系统改好后在更新到正式系统. 存储过程,视图等可以直接通过全部删除在创建进行更新,但是表因为正式系统里已有数据所以无法通过该方式进行更新.只能更改表结构,而这时有可能因为更改的表结构比较多,而出现有的表忘了更新. 改程序可以对比两个数据库下所有表的表结构的不同.并显示 同时也有源程序 改代码已支持sql2008
mysql 数据库表结构对比java工具
08-05
mysql 数据库结构对比工具 java 1.配置好两个数据库的账号密码数据库名称等信息 DbComparator db1 = new DbComparator("ip", null, "user", "password", "dbname", "47" ); ...
Java比较两个mysql数据库表结构的差异
03-17
一个简单JAVA 小工程进行两个MYSQL数据库对象的比较，导入eclipse中,修改jdbc.properties文件中的JDBC信息，然后直接运行action包类中的main方法，生成EXCEL，excel中包含表，表中列，索引，函数过程差异比对结果。...
Oracle数据库结构比对工具
04-10
【程序说明】 1、本程序用来对Oracle数据库进行结构比较，支持在线数据库比较和 离线数据库比较方式； 2、连接数据库无须在本地配置数据库连接，直接通过IP和端口以及相 应的数据库名称进行连接； 3、纯绿色软件，无须安装，拷贝即可使用，不修改注册表等； 4、在WinXP SP3 及Win2003 SP2 环境下进行过测试，对于其他版本 Windows操作系统没有进行过测试，欢迎您将测试结果告诉我； 5、如果在运行的过程中发现异常，欢迎您将程序运行目录下自动产生 的OraDBCompPro.LOG发送给我
mysql数据库表结构及数据
08-31
mysql数据库表结构及数据,departmentinfo 与 employeeinfo
对比2个数据库的差异
01-25
对比2个数据库表差异，字段差异，对比字段的维度为表名，字段名，字段属性，字段长度，是否为空，到处到excel中。
java比较两个mysql数据库中的表信息差异
03-17
一个简单JAVA 小工程进行两个MYSQL数据库对象的比较，导入eclipse中,修改jdbc.properties文件中的JDBC信息，然后直接运行action包类中的main方法，生成EXCEL，excel中包含表，表中列，索引，函数过程差异比对结果。...
mysql如何比对两个数据库表结构的方法
12-16
例如同一套代码，在开发环境正常，在测试环境出现问题，这时除了检查服务器设置，还需要比对开发环境与测试环境的数据库表结构是否存在差异。找到差异后需要更新测试环境数据库表结构直到开发与测试环境的数据库表...
java实现两个mysql同步主库的数据
07-29
两个mysql数据库之间实现同步,通过定时任务实现从主库到从库的同步,java代码实现,所有java项目包括配置都有,数据结构可以跟据自己的特定情况去改
数据库间表结构对比和数据对比
热门推荐
swordmanli的专栏
02-13 3万+
概述        对于企业软件开发或实施人员，在软件实施过程中，经常会遇到了这么一个问题，我们在客户那边安装了整个ERP程序并且向数据库中导入了客户提供给我的基础资料，程序进入试运行阶段，在试运行期间，客户反映出程序的各种问题，需要提交给公司去纠正这些问题，在纠正问题的时候伴随的问题的解决，程序开发人员向数据库中添加了数据库表或者向已有表中添加了字段，这个时候开发员没有一个良好的习惯用SQL语...
mysql比对实例_mysql快速比对数据库对象结构差异工具-java版
weixin_33568172的博客
02-02 573
【实例简介】!!!!!!!基于JDK1.8编写的java代码相比之前的比对工具性能更加快速，直接运行java工程中的代码即可比对1. 两个 MYSQL 数据库对象结构比对工具 (比如：本地测试库、远程运维库表结构、表中列等对比)2. 比对结果导出EXCEL 存放于 “工程根目录”/export/ 目录下3. 比对的对象包括 表、表列、表索引、表分区差异、触发器代码差异、存储过程代码差异，函数代码差...
java对比两个数据库的表数据是否一样
06-01
可以使用Java Database Connectivity（JDBC） API和SQL语句来比较两个数据库的表数据是否一致。以下是一个简单的示例： 1. 首先，使用JDBC连接到两个数据库。 2. 通过执行SELECT语句从第一个数据库中检索表数据，并将结果存储在List或HashMap中。 3. 通过执行SELECT语句从第二个数据库中检索表数据，并将结果存储在List或HashMap中。 4. 比较两个数据结构是否相同。如果两个数据库中的表数据相同，则这两个数据结构应该是一样的。 下面是一个示例代码： ```java import java.sql.*; import java.util.*; public class DatabaseComparator { private static String url1 = "jdbc:mysql://localhost:3306/database1"; private static String url2 = "jdbc:mysql://localhost:3306/database2"; private static String user = "username"; private static String password = "password"; public static void main(String[] args) { try { // Connect to first database Connection conn1 = DriverManager.getConnection(url1, user, password); Statement stmt1 = conn1.createStatement(); // Retrieve data from first database ResultSet rs1 = stmt1.executeQuery("SELECT * FROM table1"); List<Map<String, Object>> data1 = new ArrayList<>(); while (rs1.next()) { Map<String, Object> row = new HashMap<>(); row.put("column1", rs1.getObject("column1")); row.put("column2", rs1.getObject("column2")); data1.add(row); } // Connect to second database Connection conn2 = DriverManager.getConnection(url2, user, password); Statement stmt2 = conn2.createStatement(); // Retrieve data from second database ResultSet rs2 = stmt2.executeQuery("SELECT * FROM table1"); List<Map<String, Object>> data2 = new ArrayList<>(); while (rs2.next()) { Map<String, Object> row = new HashMap<>(); row.put("column1", rs2.getObject("column1")); row.put("column2", rs2.getObject("column2")); data2.add(row); } // Compare data from both databases if (data1.equals(data2)) { System.out.println("Table data is the same in both databases."); } else { System.out.println("Table data is different in both databases."); } // Close connections rs1.close(); stmt1.close(); conn1.close(); rs2.close(); stmt2.close(); conn2.close(); } catch (SQLException e) { e.printStackTrace(); } } } ``` 请注意，此示例仅比较单个表中的数据。如果要比较多个表或整个数据库的数据，请编写相应的代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

早退的程序员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值