canal 同步mysql数据

最新推荐文章于 2024-08-02 02:01:46 发布
最新推荐文章于 2024-08-02 02:01:46 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： canal 数据同步 文章标签： mysql 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33730616/article/details/132541689
版权
本文详细介绍了如何使用Canal这个开源工具从MySQL数据库同步数据，涉及安装配置、服务器监听、消费端应用程序开发以及处理binlog日志中的SQL操作。
摘要由CSDN通过智能技术生成

1、Canal 是一个开源的数据库数据同步工具，用于监控数据库变更并将变更数据传递到指定的消费端，通常用于将MySQL数据库的变更数据传递到其他系统进行处理

2、使用 Canal 同步 MySQL 数据的基本步骤：

  1. 安装和配置 Canal 服务器：

    • 下载 Canal 服务器安装包或从源代码构建。
    • 配置 Canal 服务器的参数，包括数据库连接信息、监听的数据表、认证配置等。这些配置通常在 canal.properties 文件中设置。

  2. 启动 Canal 服务器：

    • 启动已配置好的 Canal 服务器，它会连接到 MySQL 数据库，监控数据变更。

  3. 编写消费端应用程序：

    • 消费端应用程序可以是您自己编写的任何程序，它会从 Canal 服务器获取数据库变更数据并进行处理。
    • 使用 Canal 提供的客户端 SDK（如 Java 客户端）来连接 Canal 服务器，订阅特定的数据库和数据表。
    • 编写逻辑来处理接收到的变更数据，可以根据业务需求将数据写入其他系统、存储、消息队列等。
  4. 客户端连接canal-server，订阅mysql数据变更逻辑，以及将binglog日志解析成相应的sql语句，可以直接在mysql中执行
  5. 引入的pom 
    • <dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.client</artifactId>
    <version>1.1.4</version>
</dependency>
  6. package cn.liu.demo.canal;

import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.protocol.CanalEntry;
import com.alibaba.otter.canal.protocol.Message;
import com.google.protobuf.InvalidProtocolBufferException;

import java.net.InetSocketAddress;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

import static com.alibaba.otter.canal.protocol.CanalEntry.*;
import static com.alibaba.otter.canal.protocol.CanalEntry.EntryType.*;

/**
 * @Author：
 * @Date：2023/8/22 14:42
 * @Description：
 */
public class CanalClient {
    private static Queue<String> SQL_QUEUE = new ConcurrentLinkedQueue<>();

    public static void main(String[] args) {
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("127.0.0.1", 11111), "instance1", "admin", "admin");
        try {
            connector.connect();
            // 监听的表，格式为数据库.表名,数据库.表名
            connector.subscribe("user.*");
            //回滚到未进行ack的地方，下次fetch的时候，可以从最后一个没有ack的地方开始拿
            connector.rollback();
            while (true){
                Message message = connector.getWithoutAck(100); // 获取指定数量的数据
                //获取批量ID
                long batchId = message.getId();
                //获取批量的数量
                int size = message.getEntries().size();

                //如果没有数据
                if (batchId == -1 || size == 0) {
                    try {
                        //线程休眠2秒
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    //如果有数据,处理数据
                    printEntry(message.getEntries());
                    dataHandle(message.getEntries());
                }
                //进行 batch id 的确认。确认之后，小于等于此 batchId 的 Message 都会被确认。
                connector.ack(batchId);


                //当队列里面堆积的sql大于一定数值的时候就模拟执行
                if (SQL_QUEUE.size() >= 1) {
                    executeQueueSql();
                }
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            connector.disconnect();
        }

    }

    /**
     * 模拟执行队列里面的sql语句
     */
    public static void executeQueueSql() {
        int size = SQL_QUEUE.size();
        for (int i = 0; i < size; i++) {
            String sql = SQL_QUEUE.poll();
            System.out.println("[sql]----> " + sql);
        }
    }


    /**
     * 打印canal server解析binlog获得的实体类信息
     */
    private static void printEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == TRANSACTIONBEGIN || entry.getEntryType() == TRANSACTIONEND) {
                //开启/关闭事务的实体类型，跳过
                continue;
            }
            //RowChange对象，包含了一行数据变化的所有特征
            //比如isDdl 是否是ddl变更操作 sql 具体的ddl sql beforeColumns afterColumns 变更前后的数据字段等等
            CanalEntry.RowChange rowChage;
            try {
                rowChage = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(), e);
            }
            //获取操作类型：insert/update/delete类型
            CanalEntry.EventType eventType = rowChage.getEventType();
            //打印Header信息
            System.out.println(String.format("================》; binlog[%s:%s] , name[%s,%s] , eventType : %s",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                    eventType));
            //判断是否是DDL语句
            if (rowChage.getIsDdl()) {
                System.out.println("================》;isDdl: true,sql:" + rowChage.getSql());
            }
            //获取RowChange对象里的每一行数据，打印出来
            for (CanalEntry.RowData rowData : rowChage.getRowDatasList()) {
                //如果是删除语句
                if (eventType == CanalEntry.EventType.DELETE) {
                    printColumn(rowData.getBeforeColumnsList());
                    //如果是新增语句
                } else if (eventType == CanalEntry.EventType.INSERT) {
                    printColumn(rowData.getAfterColumnsList());
                    //如果是更新的语句
                } else {
                    //变更前的数据
                    System.out.println("------->; before");
                    printColumn(rowData.getBeforeColumnsList());
                    //变更后的数据
                    System.out.println("------->; after");
                    printColumn(rowData.getAfterColumnsList());
                }
            }
        }
    }

    /**
     * 数据处理
     *
     * @param entrys
     */
    private static void dataHandle(List<Entry> entrys) throws InvalidProtocolBufferException {
        for (Entry entry : entrys) {
            if (ROWDATA == entry.getEntryType()) {
                CanalEntry.RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
                EventType eventType = rowChange.getEventType();
                if (eventType == EventType.DELETE) {
                    saveDeleteSql(entry);
                } else if (eventType == EventType.UPDATE) {
                    saveUpdateSql(entry);
                } else if (eventType == EventType.INSERT) {
                    saveInsertSql(entry);
                }
            }
        }
    }

    private static void saveUpdateSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> newColumnList = rowData.getAfterColumnsList();
                StringBuffer sql = new StringBuffer("update " + entry.getHeader().getSchemaName() + "." + entry.getHeader().getTableName() + " set ");
                for (int i = 0; i < newColumnList.size(); i++) {
                    sql.append(" " + newColumnList.get(i).getName()
                            + " = '" + newColumnList.get(i).getValue() + "'");
                    if (i != newColumnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(" where ");
                List<Column> oldColumnList = rowData.getBeforeColumnsList();
                for (Column column : oldColumnList) {
                    if (column.getIsKey()) {
                        //暂时只支持单一主键
                        sql.append(column.getName() + "=" + column.getValue());
                        break;
                    }
                }
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }

    /**
     * 保存删除语句
     *
     * @param entry
     */
    private static void saveDeleteSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> columnList = rowData.getBeforeColumnsList();
                StringBuffer sql = new StringBuffer("delete from " + entry.getHeader().getSchemaName() + "." + entry.getHeader().getTableName() + " where ");
                for (Column column : columnList) {
                    if (column.getIsKey()) {
                        //暂时只支持单一主键
                        sql.append(column.getName() + "=" + column.getValue());
                        break;
                    }
                }
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }

    /**
     * 保存插入语句
     *
     * @param entry
     */
    private static void saveInsertSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> columnList = rowData.getAfterColumnsList();
                StringBuffer sql = new StringBuffer("insert into " + entry.getHeader().getSchemaName() + "." + entry.getHeader().getTableName() + " (");
                for (int i = 0; i < columnList.size(); i++) {
                    sql.append(columnList.get(i).getName());
                    if (i != columnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(") VALUES (");
                for (int i = 0; i < columnList.size(); i++) {
                    sql.append("'" + columnList.get(i).getValue() + "'");
                    if (i != columnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(")");
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }


    private static void printColumn(List<CanalEntry.Column> columns) {
        for (CanalEntry.Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }



}

 总结：

总结起来，使用 Canal 同步 MySQL 数据的过程涉及到配置 Canal 服务器、编写消费端应用程序以及处理接收到的变更数据。这使您能够将 MySQL 数据库的变更同步到其他系统中，实现数据的实时传输和处理。具体的实现方式会根据您的业务需求和技术栈而有所不同

40°的夏天
关注
专栏目录
canal实现mysql数据同步
congge
01-27 1万+
canal实现mysql数据同步
大数据Canal（三）：使用Canal同步MySQL数据
Lansonli（蓝深李）的博客
03-10 3414
首先需要在Canal中配置CanalServer 对应的canal.properties，这个文件中主要配置Canal对应的同步数据实例(Canal Instance)位置信息及数据导出的模式，例如：我们需要将某个mysql中的数据同步到Kafka中，那么就可以创建一个“数据同步实例”，导出到Kafka就是一种模式。下面我们使用Canal同步MySQL数据到Kafka为例，学习下Canal如何同步MySQL数据。注意：“canal_topic”不需要提前创建，默认创建就是1个分区。
Canal实现MYSQL实时数据同步
水蓝
04-10 2549
访问 xxx.xxx.xxx.xxx:8089, 前面换成自己的服务器、虚拟机地址。为了兼容MYSQL8.0+， 我们需要拉取 v1.1.7的镜像。instance.properties 一共2处修改。canal.properties 一共1处修改。如果是服务器部署的话，记得开放对应的端口号。如果是服务器部署的话，记得开放对应的端口号。一般都是开启的, 可以通过下列命令在。，因为后面的文件都是在这个路径下。，所以我们可以制作对应的镜像。或其他数据库工具进行查看。作者并没有上传对应的镜像。
实战：MySQL数据同步神器之Canal
最新发布
为无为，事无事，味无味。
08-02 2756
canal [kə'næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。项目起源于阿里巴巴内部对于跨机房数据同步的需求，通过解析MySQL的二进制日志（Binary Log），Canal能够捕获并推送数据库的变更事件，满足了诸如数据库镜像、实时备份、索引实时维护等多种业务场景的需求。GitHub - alibaba/canal: 阿里巴巴 MySQL binlog 增量订阅&消费组件。
canal同步mysql
12-12
canal同步mysql,基于springboot2.0.6,使用undertow容器，可直接运行。
canal实现mysql到ES数据实时同步
07-11
Canal是一款由阿里巴巴开源的数据库增量日志抽取工具，它能够监听MySQL的数据变更，然后将这些变更实时地同步到其他系统，如Elasticsearch。在本篇中，我们将深入探讨如何利用Canal实现这一功能。 首先，我们要了解...
云讯健身管理系统-15--Canal数据同步
leo10_Barcelona的博客
10-21 361
一、Canal介绍 1、应用场景 在前面的统计分析功能中，我们采取了服务调用获取统计数据，这样耦合度高，效率相对较低，目前我采取另一种实现方式，通过实时同步数据库表的方式实现，例如我们要统计每天注册与登录人数，我们只需把会员表同步到统计库中，实现本地统计就可以了，这样效率更高，耦合度更低，Canal就是一个很好的数据库同步工具。canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL。 2、Canal环境搭建 canal的原理
canal mysql数据同步mysql
逗比爱好者
06-07 2524
mysql 数据同步mysql 多表同步需要创建多个rdb/yml文件
MySQL 数据同步——canal
堂哥码财的博客
09-22 991
1、Canal简介 使用阿里的开源工具canal，实现监听MySQL数据库变化，并推送到：Kafka、RabbitMQ、ElasticSeach或其他中间平台。 canal 1.1.4版本，迎来最重要的WebUI能力，引入canal-admin工程，支持面向WebUI的canal动态管理能力，支持配置、任务、日志等在线白屏运维能力 github地址： https://github.com/alibaba/canal Canal Kafka RocketMQ QuickStart https://gith
canal同步MySQL的数据
没有合适的昵称
09-08 1745
canal是什么? canal是阿里巴巴的一个开源项目,其作用就是:模拟MySQL的从节点,从而达到数据的同步作用 原理图如下: 这种方式对比flume和sqoop的优点是: 不影响源数据库 可以识别新增数据，也可以检测到删除或者更新的数据 不要求源数据库必须有用于表示增量的字段 ...
使用Canal实现MySQL主从同步
qq_42108331的博客
04-27 1937
使用Canal实现MySQL主从同步
使用canal同步mysql数据
qq_33816292的博客
04-04 1117
1.canal相当于mysql的一个连接的从库，canal监听指定库和指定表的数据变更，从而发出默认的广播模式mq，1. admin:canal的客户端控制台 2.deployer 是canal的服务器。2.然后业务端监听mq的交换机，去用队列去绑定交换机，来监听收到消息，来同步到es库上。二、然后通过java代码mq监听去处理对应表数据的事务操作增删改。1.使用策略模式处理对应的表数据变更业务。
使用Canal实现MySQL的数据实时同步
zhongbaolin的专栏
05-25 347
https://blog.csdn.net/qq_23329167/article/details/89873870 首先看上面一篇，我是参照他的，只是下面写一下自已注意的地方 1.安装zookeeper， 2.安装kafka, 3.打开mysql的big-log 这个流程是能过canal实时读取mysql的bin-log,然后发到kafka接收 其实我最后是把信息保存到hdfs的，而kafka可以传输给hdfs，下节再说 下面是instance的配置 主要是配一下master.add.
Canal进行mysql数据同步
gs_jy的博客
07-05 1646
场景 各个系统模块之间的数据库是独立的，而我开发的功能需要使用到业务库中员工和角色的信息，因此使用了cannal将业务库中的员工和角色表信息实时同步到自己的库中。 思路 canal监听数据库二进制日志（binlog）的变动 解析生成sql语句 通过目标库的数据库连接Connection，创建Statement 执行对应的sql语句，完成数据同步 步骤 安装mysql 首先需要安装好 mysql，用来作为数据提供方（muster），具体安装步骤网上很多，不再赘述。 部署Canal 下载Canal：Cana
全网最详细、最简单 canal同步mysql 监听单实例、监听多实例 配置
wonder_dog的博客
05-07 5757
下载 监听一个数据源到一个数据库 监听多个数据源到一个数据库
canal 之 mysql 主备同步 mysqlA同步数据到mysqlB
sszdzq的博客
04-09 1127
修改文件：canal.deployer-1.1.7\conf\example 下的instance.properties。修改文件：canal.adapter-1.1.7\conf\rdb\mytest_user.yml。修改文件：canal.adapter-1.1.7\conf\application.yml。canal.deployer-1.1.7\bin\startup.bat 双击。canal.adapter-1.1.7\bin\startup.bat 双击。开启主从同步配置（binlog）
canal同步mysql数据到es
04-04
有多种方式可以将Canal同步MySQL数据到Elasticsearch（ES）中，以下是其中一种常见的方式： 1. 安装Canal和ES 首先需要安装Canal和ES，并确保两者可以正常运行。 2. 配置Canal 在Canal的配置文件中，需要指定要同步的MySQL服务器的地址、用户名、密码等信息，同时配置ES的地址和端口号。此外，还需要指定需要同步的数据库和表的信息，以及一些其他的配置选项。 3. 配置ES 在ES中创建一个索引，用于存储从MySQL中同步过来的数据。可以根据需要设置索引的映射和设置，例如字段类型、分词器、副本数等。 4. 启动Canal 启动Canal服务，它将开始监控MySQL数据库中的更改，获取变更数据并将其发送到ES中。 5. 验证同步结果 可以通过ES的查询功能来验证数据是否已经成功同步到ES中。 以上是将Canal同步MySQL数据到ES的基本步骤，具体实现可以根据实际需求进行调整和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值