总阅读量:次

⭐⭐⭐ Spring Boot 项目实战 ⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 blog.csdn.net/weixin_46902396/article/details/121904705 「愿许浪尽天涯」欢迎转载，保留摘要，谢谢！

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
  4. 新的源码解析文章实时收到通知。每周更新一篇左右。
  5. 认真的源码交流微信群。

DataX 使用介绍

前言

或者我们公司将项目的数据报告并存储到最高五，但是因为那块数据准确，业务库和报告库又是库操作，所以不能同时使用 SQL 来进行。当时的打算是mysqldump通过的方式来进行同步，但尝试后发现这些方案都不切实际：

mysqldump：备份时间时间，同步，而且在备份的时间也需要，可能还有数据需要同步（不需要同步）

存储方式：效率太慢了，这个数据量少了还好，我们用这个方式的时候，三个才每小时同步两千条数据……

后面在网上快之后，发现DataX这个工具用同步速度查看，而且同步的数据量基本也无几。

一、DataX简介

DataX是阿里云DataWorks的各种数据集成的开源版本，就是实现数据间的离线同步。DataX主要实现关系数据库（MySQL、Oracle等）、HDFS、Hive、ODPS、HBase、FTP等**构数据源（即不同的数据库）**间稳定的数据同步功能。

为了解决数据源X的数据源同步，数据源将复杂的星网状网络问题同步形成数据类型，DataX作为数据源之间的载体连接；

当需要接入一个新的数据源时，只需将一个新的数据源对X个数据源进行同步，就可以将现有的数据源作为源数据。

1.DataX3.0框架设计

DataX采用架构，将数据源读取和写入称为框架+读写器插件，加入到整个同步框架中。

角色 作用
阅读器（采集模块） 负责采集数据源的数据，将其发送给Framework。
Writer（写入模块） 负责不断向Framework中取数据，并将数据写入到目的端。
框架（中间商） 负责连接Reader和Writer，作为另一个数据传输通道，并处理缓冲，流控，同时，数据等技术问题。

2.DataX3.0核心架构

DataX 完成数据同步的作业，称为 Job，DataX 接收到一个 Job 后，启动整个流程完成作业同步 DataX Job 模块是单个作业的中枢管理节点，承担了数据采集、子任务切割分、任务组管理等功能。

1、 DataX启动后，会根据不同源端的分工策略，将工作切分任务（子任务），以便于同时执行。

2、 会调用Data Job模块，根据配置的调度任务数量，将分解成的任务重新组合，组合成任务组（Task Group）

3、 每一个Task都由TaskGroup负责启动，Task启动后，会固定启动Reader --> Channel -->Writer线程来完成任务同步工作。

4、 DataX作业运行启动后，Job监控后未结束TaskGroup时完成操作，Job就会成功完成（等待所有TaskGroup结束时）

DataX调度过程：

1、 DataX会根据分库分表分配：分配好模块运行个任务，然后根据用户配置多少个数，来计算需要的任务组； **2、**计算过程Task/Channel=TaskGroup中，由任务组根据任务组来计算数量（任务）；

二、使用DataX实现数据同步

准备工作：

  • JDK（1.8以上，推荐1.8）
  • Python（2，3版本都可以）
  • Apache Maven 3.x（Compile DataX）（手动打包使用，使用tar包方式无需安装）
主机名 操作系统 IP地址 餐食
MySQL-1 CentOS 7.4 192.168.1.1 jdk-8u181-linux-x64.tar.gz datax.tar.gz
MySQL-2 CentOS 7.4 192.168.1.2

安装JDK：下载地址（需要创建Oracle账号）

[root@MySQL-1 ~]# ls
anaconda-ks.cfg  jdk-8u181-linux-x64.tar.gz
[root@MySQL-1 ~]# tar zxf jdk-8u181-linux-x64.tar.gz 
[root@DataX ~]# ls
anaconda-ks.cfg  jdk1.8.0_181  jdk-8u181-linux-x64.tar.gz
[root@MySQL-1 ~]# mv jdk1.8.0_181 /usr/local/java
[root@MySQL-1 ~]# cat <<END >> /etc/profile
export JAVA_HOME=/usr/local/java
export PATH=$PATH:"$JAVA_HOME/bin"
END
[root@MySQL-1 ~]# source /etc/profile
[root@MySQL-1 ~]# java -version

因为 Cent 7 上自带 Python 2.7 的软件包，所以不需要安装。

1.Linux上安装DataX软件

[root@MySQL-1 ~]# wget http://datax-opensource.oss-cn-hangzhou.aliyuncs.com/datax.tar.gz
[root@MySQL-1 ~]# tar zxf datax.tar.gz -C /usr/local/
[root@MySQL-1 ~]# rm -rf /usr/local/datax/plugin/*/._*      # 需要删除隐藏文件 (重要)

当未删除时，可能会输出：[/usr/local/datax/plugin/reader/._drdsreader/plugin.json] 不存在。请检查您的配置文件。

验证：

[root@MySQL-1 ~]# cd /usr/local/datax/bin
[root@MySQL-1 ~]# python datax.py ../job/job.json       # 用来验证是否安装成功

输出：

2021-12-13 19:26:28.828 [job-0] INFO  JobContainer - PerfTrace not enable!
2021-12-13 19:26:28.829 [job-0] INFO  StandAloneJobContainerCommunicator - Total 100000 records, 2600000 bytes | Speed 253.91KB/s, 10000 records/s | Error 0 records, 0 bytes |  All Task WaitWriterTime 0.060s |  All Task WaitReaderTime 0.068s | Percentage 100.00%
2021-12-13 19:26:28.829 [job-0] INFO  JobContainer - 
任务启动时刻                    : 2021-12-13 19:26:18
任务结束时刻                    : 2021-12-13 19:26:28
任务总计耗时                    :                 10s
任务平均流量                    :          253.91KB/s
记录写入速度                    :          10000rec/s
读出记录总数                    :              100000
读写失败总数                    :                   0

2.DataX基本使用

查看streamreader --> streamwriter的模板：

[root@MySQL-1 ~]# python /usr/local/datax/bin/datax.py -r streamreader -w streamwriter

输出：

DataX (DATAX-OPENSOURCE-3.0), From Alibaba !
Copyright (C) 2010-2017, Alibaba Group. All Rights Reserved.
Please refer to the streamreader document:
     https://github.com/alibaba/DataX/blob/master/streamreader/doc/streamreader.md 

Please refer to the streamwriter document:
     https://github.com/alibaba/DataX/blob/master/streamwriter/doc/streamwriter.md 
 
Please save the following configuration as a json file and  use
     python {
   
     DATAX_HOME}/bin/datax.py {
   
     JSON_FILE_NAME}.json 
to run the job.

{
   
     
    "job": {
   
     
        "content": [
            {
   
     
                "reader": {
   
     
                    "name": "streamreader", 
                    "parameter": {
   
     
                        "column": [], 
                        "sliceRecordCount": ""
                    }
                }, 
                "writer": {
   
     
                    "name": "streamwriter", 
                    "parameter": {
   
     
                        "encoding": "", 
                        "print": true
                    }
                }
            }
        ], 
        "setting": {
   
     
            "speed": {
   
     
                "channel": ""
            }
        }
    }
}

可以编写模板json文件

[root@MySQL-1 ~]# cat <<END > test.json
{
   
     
    "job": {
   
     
        "content": [
            {
   
     
                "reader": {
   
     
                    "name": "streamreader", 
                    "parameter": {
   
     
                        "column": [        # 同步的列名 (* 表示所有)
       {
   
     
           "type":"string",
    "value":"Hello."
       },
       {
   
     
           "type":"string",
    "value":"河北彭于晏"
       },
   ], 
                        "sliceRecordCount": "3"     # 打印数量
                    }
                }, 
                "writer": {
   
     
                    "name": "streamwriter", 
                    "parameter": {
   
     
                        "encoding": "utf-8",     # 编码
                        "print": true
                    }
                }
            }
        ], 
        "setting": {
   
     
            "speed": {
   
     
                "channel": "2"         # 并发 (即 sliceRecordCount * channel = 结果)
            }
        }
    }
}

输出：（要复制我的内容，需要把#带的内容去掉）

3.安装MySQL数据库

分别在两台主机上安装：

[root@MySQL-1 ~]# yum -y install mariadb mariadb-server mariadb-libs mariadb-devel   
[root@MySQL-1 ~]# systemctl start mariadb            # 安装 MariaDB 数据库
[root@MySQL-1 ~]# mysql_secure_installation            # 初始化 
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
      SERVERS IN PRODUCTION USE!  PLEASE READ EACH STEP CAREFULLY!

Enter current password for root (enter for none):       # 直接回车
OK, successfully used password, moving on...
Set root password? [Y/n] y                            # 配置 root 密码
New password: 
Re-enter new password: 
Password updated successfully!
Reloading privilege tables..
 ... Success!
Remove anonymous users? [Y/n] y                     # 移除匿名用户
 ... skipping.
Disallow root login remotely? [Y/n] n                # 允许 root 远程登录
 ... skipping.
Remove test database and access to it? [Y/n] y         # 移除测试数据库
 ... skipping.
Reload privilege tables now? [Y/n] y                    # 重新加载表
 ... Success!

1 、准备同步数据（要同步的两台主机都有这个表）

MariaDB [(none)]>` create database course-study;
Query OK, 1 row affected (0.00 sec)

MariaDB [(none)]>` create table course-study.t_member(ID int,Name varchar(20),Email varchar(30));
Query OK, 0 rows affected (0.00 sec)

因为是使用DataX同步进行的，所以需要在程序双方的数据库上开放权限：

grant all privileges on *.* to root@'%' identified by '123123';
flush privileges;

2、创建存储过程：

DELIMITER $$
CREATE PROCEDURE test()
BEGIN
declare A int default 1;
while (A < 3000000)do
insert into course-study.t_member values(A,concat("LiSa",A),concat("LiSa",A,"@163.com"));
set A = A + 1;
END while;
END $$
DELIMITER ;

3 、调用存储过程（在数据源配置，验证同步使用)：

call test();

4.通过DataX实MySQL数据同步

1 、生成MySQL到MySQL同步的模板：

[root@MySQL-1 ~]# python /usr/local/datax/bin/datax.py -r mysqlreader -w mysqlwriter
{
   
     
    "job": {
   
     
        "content": [
            {
   
     
                "reader": {
   
     
                    "name": "mysqlreader",       # 读取端
                    "parameter": {
   
     
                        "column": [],         # 需要同步的列 (* 表示所有的列)
                        "connection": [
                            {
   
     
                                "jdbcUrl": [],       # 连接信息
                                "table": []       # 连接表
                            }
                        ], 
                        "password": "",        # 连接用户
                        "username": "",        # 连接密码
                        "where": ""         # 描述筛选条件
                    }
                }, 
                "writer": {
   
     
                    "name": "mysqlwriter",       # 写入端
                    "parameter": {
   
     
                        "column": [],         # 需要同步的列
                        "connection": [
                            {
   
     
                                "jdbcUrl": "",       # 连接信息
                                "table": []       # 连接表
                            }
                        ], 
                        "password": "",        # 连接密码
                        "preSql": [],         # 同步前. 要做的事
                        "session": [], 
                        "username": "",        # 连接用户 
                        "writeMode": ""        # 操作类型
                    }
                }
            }
        ], 
        "setting": {
   
     
            "speed": {
   
     
                "channel": ""          # 指定并发数
            }
        }
    }
}

2 、编写json文件：

[root@MySQL-1 ~]# vim install.json
{
   
     
    "job": {
   
     
        "content": [
            {
   
     
                "reader": {
   
     
                    "name": "mysqlreader", 
                    "parameter": {
   
     
                        "username": "root",
                        "password": "123123",
                        "column": ["*"],
                        "splitPk": "ID",
                        "connection": [
                            {
   
     
                                "jdbcUrl": [
                                    "jdbc:mysql://192.168.1.1:3306/course-study?useUnicode=true&characterEncoding=utf8"
                                ], 
                                "table": ["t_member"]
                            }
                        ]
                    }
                }, 
                "writer": {
   
     
                    "name": "mysqlwriter", 
                    "parameter": {
   
     
                        "column": ["*"], 
                        "connection": [
                            {
   
     
                                "jdbcUrl": "jdbc:mysql://192.168.1.2:3306/course-study?useUnicode=true&characterEncoding=utf8",
                                "table": ["t_member"]
                            }
                        ], 
                        "password": "123123",
                        "preSql": [
                            "truncate t_member"
                        ], 
                        "session": [
                            "set session sql_mode='ANSI'"
                        ], 
                        "username": "root", 
                        "writeMode": "insert"
                    }
                }
            }
        ], 
        "setting": {
   
     
            "speed": {
   
     
                "channel": "5"
            }
        }
    }
}

3 、验证

[root@MySQL-1 ~]# python /usr/local/datax/bin/datax.py install.json

输出：

2021-12-15 16:45:15.120 [job-0] INFO  JobContainer - PerfTrace not enable!
2021-12-15 16:45:15.120 [job-0] INFO  StandAloneJobContainerCommunicator - Total 2999999 records, 107666651 bytes | Speed 2.57MB/s, 74999 records/s | Error 0 records, 0 bytes |  All Task WaitWriterTime 82.173s |  All Task WaitReaderTime 75.722s | Percentage 100.00%
2021-12-15 16:45:15.124 [job-0] INFO  JobContainer - 
任务启动时刻                    : 2021-12-15 16:44:32
任务结束时刻                    : 2021-12-15 16:45:15
任务总计耗时                    :                 42s
任务平均流量                    :            2.57MB/s
记录写入速度                    :          74999rec/s
读出记录总数                    :             2999999
读写失败总数                    :                   0

你们可以在目标数据库中进行查看，是否同步完成。

全部的方式是完全同步的，但是当数据量测时，是同步的时间被中断的很安慰的事情；

所以在某种情况下，增量同步还是蛮重要的。

5.使用DataX进行增量同步

使用DataX全量同步和增量同步的唯一区别是：增量同步需要使用 where 进行条件筛选。（即，同步进行筛选后的SQL）

1 、编写json文件：

[root@MySQL-1 ~]# vim where.json
{
   
     
    "job": {
   
     
        "content": [
            {
   
     
                "reader": {
   
     
                    "name": "mysqlreader", 
                    "parameter": {
   
     
                        "username": "root",
                        "password": "123123",
                        "column": ["*"],
                        "splitPk": "ID",
                        "where": "ID <= 1888",
                        "connection": [
                            {
   
     
                                "jdbcUrl": [
                                    "jdbc:mysql://192.168.1.1:3306/course-study?useUnicode=true&characterEncoding=utf8"
                                ], 
                                "table": ["t_member"]
                            }
                        ]
                    }
                }, 
                "writer": {
   
     
                    "name": "mysqlwriter", 
                    "parameter": {
   
     
                        "column": ["*"], 
                        "connection": [
                            {
   
     
                                "jdbcUrl": "jdbc:mysql://192.168.1.2:3306/course-study?useUnicode=true&characterEncoding=utf8",
                                "table": ["t_member"]
                            }
                        ], 
                        "password": "123123",
                        "preSql": [
                            "truncate t_member"
                        ], 
                        "session": [
                            "set session sql_mode='ANSI'"
                        ], 
                        "username": "root", 
                        "writeMode": "insert"
                    }
                }
            }
        ], 
        "setting": {
   
     
            "speed": {
   
     
                "channel": "5"
            }
        }
    }
}

需要注意的就是：where（条件筛选）部分和preSql（同步前，做的事情）参数。

2 、验证：

[root@MySQL-1 ~]# python /usr/local/data/bin/data.py where.json

输出：

2021-12-16 17:34:38.534 [job-0] INFO  JobContainer - PerfTrace not enable!
2021-12-16 17:34:38.534 [job-0] INFO  StandAloneJobContainerCommunicator - Total 1888 records, 49543 bytes | Speed 1.61KB/s, 62 records/s | Error 0 records, 0 bytes |  All Task WaitWriterTime 0.002s |  All Task WaitReaderTime 100.570s | Percentage 100.00%
2021-12-16 17:34:38.537 [job-0] INFO  JobContainer - 
任务启动时刻                    : 2021-12-16 17:34:06
任务结束时刻                    : 2021-12-16 17:34:38
任务总计耗时                    :                 32s
任务平均流量                    :            1.61KB/s
记录写入速度                    :             62rec/s
读出记录总数                    :                1888
读写失败总数                    :                   0

数据库上： 3 、基于以上数据，再次进行增量同步：

主要是 where 配置："where": "ID > 1888 AND ID <= 2888"      # 通过条件筛选来进行增量同步
同时需要将我上面的 preSql 删除(因为我上面做的操作时 truncate 表)

文章目录
  1. 1. 前言
  2. 2. 一、DataX简介
    1. 2.1. 1.DataX3.0框架设计
    2. 2.2. 2.DataX3.0核心架构
  3. 3. 二、使用DataX实现数据同步
    1. 3.1. 1.Linux上安装DataX软件
    2. 3.2. 2.DataX基本使用
    3. 3.3. 3.安装MySQL数据库
    4. 3.4. 4.通过DataX实MySQL数据同步
    5. 3.5. 5.使用DataX进行增量同步