MySql自动同步主库数据（Canal）

最新推荐文章于 2025-07-16 22:28:06 发布
原创 最新推荐文章于 2025-07-16 22:28:06 发布 · 680 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
架构

当前文章被收录于：

架构
38 篇文章 3 人学习
订阅专栏 查看详情
本文介绍了使用Canal实现MySql主从复制的原理和步骤。Canal模拟MySQL从库，通过接收主库的binlog并解析成SQL，实现实时数据同步。文中还涉及了Canal的配置启动以及简单的Java客户端示例。

MySql自动同步主库数据（Canal）

上篇文章介绍了MongoDB数据库模拟从库实现主从复制效果，不会影响线上数据，本文介绍MySql模拟从库实现主从复制。

  • Find Action Ctrl+Shift+A，在此对话框中输入想操作的英文立即出现想的操作

  • System.out.println输入sout即可

  • for循环N输入N.for即可

  • return n;输入n.return即可

  • 离线写博客

  • 导入导出Markdown文件

  • 丰富的快捷键

MySql主从复制原理

MySql主从复制指数据从一个MySql复制到一个或多个MySql服务器中，基于binlog采用异步复制直接IO，这样数据访问不用一直访问主库来完成，主库负责修改，从库负责读取，实现读写分离。

  • master会将变更数据存入binlog文件中。
  • slave连接主库时主库会开启一个dump线程发送binlog内容。
  • slave会启动一个I\O Thread请求主库发送binlog记录并保存到中继日志中。
  • 从库启动Sql Thread线程读取中继日志，本地重放，使得数据与主库保持一致，最后I/O Thread和SQL Thread将进入睡眠状态，等待下一次被唤醒。

总结：

  • 从库生成两个线程I/O Thread、Sql Thread。
  • I/O Thread请求主库binlog并写到中继日志（relay-log）中。
  • 主库生成一个dump线程，给从库传binlog。
  • Sql线程读取中继日志解析并执行成sql

在这里插入图片描述

Canal原理

canal 模拟 MySQL slave 的交互协议，伪装自己为 MySQL slave ，向 MySQL master 发送dump 协议，MySQL master 收到 dump 请求，开始推送 binary log 给 slave (即 canal )
canal 解析 binary log 对象(原始为 byte 流) —— [ 官网地址 ]

下载源码修改：conf/example/instance.properties文件

//设置主库IP和端口
canal.instance.master.address=IP:端口
//设置同步开始时间（毫秒），可忽略
canal.instance.master.timestamp=

启动canal：/bin/startup.sh

本文用的阿里云服务，不需要有多过设置，其它小伙伴参照官网配置一下即可。

代码

在这里插入图片描述

SimpleCanalClientExample.class

package canal;

import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.common.utils.AddressUtils;
import com.alibaba.otter.canal.protocol.CanalEntry;
import com.alibaba.otter.canal.protocol.CanalEntry.Column;
import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
import com.alibaba.otter.canal.protocol.Message;
import org.springframework.util.StringUtils;

import java.net.InetSocketAddress;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2021-01-04 11:53
 * @Modified By：
 */
public class SimpleCanalClientExample {

    static Statement statement = null;

    public static void main(String args[]) {

        //获得存储sqlStatement
        getStatement();

        // 创建Canal链接
        CanalConnector connector = getCanalConnector();
        int batchSize = 10000;
        while (true) {
            // 获取指定数量的数据
            Message message = connector.getWithoutAck(batchSize);

            long batchId = message.getId();
            int size = message.getEntries().size();
            if (batchId == -1 || size == 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ignored) {
                }
            } else {
                findEntry(message.getEntries());
            }

            connector.ack(batchId); // 提交确认
            // connector.rollback(batchId); // 处理失败, 回滚数据
        }
    }

    private static CanalConnector getCanalConnector() {
        // 创建链接
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress(canalIp,
                11111), "example", "", "");
        connector.connect();
        connector.subscribe(".*\\..*");
        connector.rollback();
        return connector;
    }

    private static void getStatement() {
        //驱动程序名
        String driver = "com.mysql.cj.jdbc.Driver";
        // URL指向要访问的数据库名scutcs
        String url = "jdbc:mysql://从库IP:3306/数据库名?useLegacyDatetimeCode=false&serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull";
        // MySQL配置时的用户名
        String user = "账号";
        // Java连接MySQL配置时的密码
        String password = "密码";

        try {
            // 加载驱动程序
            Class.forName(driver);

            // 连续数据库
            Connection conn = DriverManager.getConnection(url, user, password);
            if (!conn.isClosed()) {
                System.out.println("Succeeded connecting to the Database!");
            }

            // statement用来执行SQL语句
            statement = conn.createStatement();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }

    private static void findEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                continue;
            }

            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);
            }

            CanalEntry.EventType eventType = rowChage.getEventType();
            System.out.println(String.format("================&gt; binlog[%s:%s] , name[%s,%s] , eventType : %s",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                    eventType));

            for (CanalEntry.RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == CanalEntry.EventType.DELETE) {
                    String sql = "delete from " + entry.getHeader().getTableName();
                    sql += deleteSql(rowData.getBeforeColumnsList());
                    doSql(sql);
                } else if (eventType == CanalEntry.EventType.INSERT) {
                    String sql = "replace into " + entry.getHeader().getTableName();
                    sql += insertSql(rowData.getAfterColumnsList());
                    doSql(sql);
                } else {
                    String sql = "update " + entry.getHeader().getTableName();
                    sql += updateSql(rowData.getAfterColumnsList());
                    doSql(sql);
                }
            }
        }
    }

    private static String updateSql(List<Column> columns) {
        StringBuilder str = new StringBuilder(" set ");

        CanalField canalField = getField(columns);
        List<String> fields = canalField.getFields();
        List<String> values = canalField.getValues();

        for (int i = 0; i < fields.size(); i++) {
            str.append(fields.get(i)).append(" = ").append(values.get(i)).append(",");
        }

        str.deleteCharAt(str.length() - 1);
        //以主键为条件更新
        str.append(" where id = ").append(canalField.getId());
        return str.toString();
    }

    private static String insertSql(List<Column> columns) {
        StringBuilder str = new StringBuilder(" ( ");
        CanalField canalField = getField(columns);
        List<String> fields = canalField.getFields();
        List<String> values = canalField.getValues();

        str.append(String.join(",", fields))
                .append(") values (")
                .append(String.join(",", values))
                .append(" ) ");
        return str.toString();
    }

    private static String deleteSql(List<Column> columns) {
        StringBuilder str = new StringBuilder(" where id = ");
        String id = "";
        for (Column column : columns) {
            if ("id".equals(column.getName())) {
                id = column.getValue();
            }
        }
        str.append(id);
        return str.toString();
    }

    private static CanalField getField(List<Column> columns) {
        CanalField canalField = new CanalField();

        List<String> field = new ArrayList<>();
        List<String> value = new ArrayList<>();
        for (Column column : columns) {
            if (StringUtils.isEmpty(column.getValue())) {
                continue;
            }

            //获得id（主键）字段值
            if ("id".equals(column.getName())) {
                canalField.setId(column.getValue());
            }

            //获得字段和值
            int sqlType = column.getSqlType();
            if (sqlType <= 8 && sqlType >= 2 || sqlType <= -5 && sqlType >= -7) {
                field.add("`" + column.getName() + "`");
                value.add(column.getValue());
            } else {
                field.add("`" + column.getName() + "`");
                value.add("'" + column.getValue() + "'");
            }
        }

        canalField.setFields(field);
        canalField.setValues(value);
        return canalField;
    }

    private static void doSql(String sql) {
        try {
            // 要执行的SQL语句
            statement.executeUpdate(sql);
        } catch (Exception e) {
            System.out.println("执行失败：" + sql);
            e.printStackTrace();
        }
    }

}

CanalField.class

package canal;

import java.util.List;

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2021-01-05 14:03
 * @Modified By：
 */
public class CanalField {

    private String id;

    private List<String> fields;

    private List<String> values;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public List<String> getFields() {
        return fields;
    }

    public void setFields(List<String> fields) {
        this.fields = fields;
    }

    public List<String> getValues() {
        return values;
    }

    public void setValues(List<String> values) {
        this.values = values;
    }
}

需要先初始化从库表结构及数据，启动java程序实现自己同步。—— [ 源码地址 ]

标签
#canal #Mysql伪装从库 #主从复制
canal 学习一：本地运行canal
菜鸟日常
11-21 4185
文章目录1. 介绍2. 基本环境配置3. canal 本地运行4. 配置文件解读5. 本地运行遇到的问题 1. 介绍 a. canal 是什么？ MySQL 数据库 Binlog 的增量订阅 &amp; 消费组件。简单来说，它可以监测 MySQL 的数据变化情况。 b. 用途 数据同步、主从复制、数据库镜像等业务场景。 主要内容： 本地运行 canal，对数据库进行数据变更，查看 cana...
Canal+Kafka实现mysql与redis数据准实时同步
热门推荐
yehongzhi1994的博客
08-16 1万+
Canal实战应用，canal+Kafka实现MySQL与Redis数据同步
Canal实现MySql和redis的数据同步
Alon的博客
02-25 2031
canal是阿里开源的数据同步工具，基于bin log可以将数据库同步到其他各类数据库中，目标数据库支持mysql,postgresql,oracle,redis,MQ,ES等。
Canal实现MySQL实时同步数据到ES
S&Y_shhy_QQ_1127833416
11-02 7339
一、canal简介 canal主要用途是对MySQL数据库增量日志进行解析，提供增量数据的订阅和消费，简单说就是可以对MySQL的增量数据进行实时同步，支持同步到MySQL、Elasticsearch、HBase等数据存储中去。 二、canal工作原理 canal会模拟MySQL主库和从库的交互协议，从而伪装成MySQL的从库，然后向MySQL主库发送dump协议，MySQL主库收到dump请求会向canal推送binlog，canal通过解析binlog将数据同步到其他存储中去。...
MySQL主从同步，及Canal实时数据库同步
向着高亮的地方
10-19 2754
1.简介 Linux下MySQL数据库的主从同步用来实现读写分离。主数据库进行数据的插入，删除与更新；从数据库专门用来查询操作，缓解数据库的压力。让运行海量数据的时候无论是从速度还是效率上都大大提高，Mysql的主从复制至少是需要两个Mysql的服务，当然Mysql的服务是可以分布在不同的服务器上，也可以在一台服务器上启动多个服务。 2.主从同步原理 Mysql服务器之间的主从同步是基于二进制日志机制，主服务器使用二进制日志来记录数据库的变动情况，从服务器通过读取和执行该日志文件来...
使用Canal实现MySQL主从同步
小何的博客
04-27 2680
使用Canal实现MySQL主从同步
spring boot集成canal实现数据库同步，且mysql主库宕机canal自动切换到从库
zks_4826的博客
09-15 2936
canal 简介：详情可查看：https://github.com/alibaba/canal canal [kə’næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费 早期阿里巴巴因为杭州和美国双机房部署，存在跨机房同步的业务需求，实现方式主要是基于业务 trigger 获取增量变更。从 2010 年开始，业务逐步尝试数据库日志解析获取增量变更进行同步，由此衍生出了大量的数据库增量订阅和消费业务。 基于日志增量订阅和消费的业务包括 数据库镜像 数据库
怎样实现mysql主库宕机后，自动将canal指向从库继续进行同步
雅冰石的专栏
04-02 1425
一
使用canal实时同步MySQL数据到Elasticsearch
zh1998wx的博客
02-24 1万+
使用canal实时同步MySQL数据到es软件版本信息安装 elasticsearch安装 kibana下载和安装canal1、下载canal2、配置MySQL3、配置 canal-server (canal-deploy)4、配置 canal-adapter5、配置canal-admin同步MySQL到es1、创建es索引 软件版本信息 由于不同版本的MySQL、Elasticsearch和canal会有兼容性问题，所以我们先对其使用版本做个约定。 软件 版本 操作系统 windows 1
大数据Canal（三）：使用Canal同步MySQL数据
Lansonli（蓝深李）的博客
03-10 3803
首先需要在Canal中配置CanalServer 对应的canal.properties，这个文件中主要配置Canal对应的同步数据实例(Canal Instance)位置信息及数据导出的模式，例如：我们需要将某个mysql中的数据同步到Kafka中，那么就可以创建一个“数据同步实例”，导出到Kafka就是一种模式。下面我们使用Canal同步MySQL数据到Kafka为例，学习下Canal如何同步MySQL数据。注意：“canal_topic”不需要提前创建，默认创建就是1个分区。
【canal】同步MySQL数据到Elasticsearch
goat的博客
07-19 1807
通过Canal监听MySQL数据变化，利用SpringBoot将数据同步到Elasticsearch，实现了MySQL到ES的无缝数据同步。这种方式适用于实时索引构建、数据备份等场景，简化了数据同步的复杂度，并且具有很强的灵活性。
【技术派后端篇】使用 Canal 实现 MySQL 与 ES 数据同步的技术实践
专注Java和MySQL领域知识分享
04-08 2315
通过本文，我们详细了解了使用 Canal 实现 MySQL 到 ES 数据同步的全过程，包括基础知识、软件安装、Canal 配置以及全量和增量数据同步实战。希望这些内容能为大家在实际项目中应用该技术提供帮助。如果项目中遇到类似场景，基本可以直接参考本文的方法进行操作。
Canal 实时同步 MySQL 增量数据至 ClickHouse 数据库
qq_40838014的博客
05-20 4204
【代码】Canal 实时同步 MySQL 增量数据至 ClickHouse 数据库。
基于Canal实现MySQL数据库数据同步
最新发布
gorgor在码农
07-16 1718
摘要：Canal是阿里巴巴开源的MySQL binlog增量订阅组件，通过伪装MySQL从库监听主库binlog变更实现实时数据同步。其核心架构包含服务端(canal.deployer)、客户端适配器(canal.adapter)和管理平台(canal.admin)，支持多种数据源同步。部署需配置MySQL开启binlog并创建专用账号，通过instance.properties定义监控规则。实战案例演示了基于Spring Boot的Canal客户端实现，包含数据变更监听、增删改事件处理及批量同步功能。适用
canal实现mysql同步到clickhouse
just love code
07-10 3601
canal同步mysql到clickhouse中
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值