基于Canal的数据同步

已于 2023-03-03 22:19:22 修改
阅读量1.3k 收藏 1
点赞数
分类专栏： springboot 文章标签： 数据库 java spring
于 2023-03-03 22:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43778515/article/details/129328121
版权

基于Canal的数据同步

一、 系统结构

该数据同步系统由Spring Boot和Canal共同组成。
Spring Boot 是一个流行的 Java Web 框架，而 Canal 则是阿里巴巴开源的 MySQL 数据库的数据变更监听框架。结合 Spring Boot 和 Canal，可以实现 MySQL 数据库的实时数据同步到其他系统中。

  1. canal.deployer-1.1.7-SNAPSHOT.tar.gz为Canal软件压缩包，需要安装在服务器上，并根据下文进行配置文件的修改。
  2. CanalClient.rar为用Spring Boot框架编写的数据库监听同步项目

二、. Canal配置

在解压Canal文件夹后，需要配置两个文件。
在配置Canal前，需要确保Mysql的Binlog已经开启，并且模式为ROW，找到当前binlog的文件名和position。

1） 配置文件路径：canal/conf/canal.properties

在这里插入图片描述

2） 配置文件路径：

canal/conf/example/instance.properties

在这里插入图片描述
在这里插入图片描述

三、 Spring Boot配置

1. 项目结构

在这里插入图片描述

2. Canal账号密码配置

进入到Config下的CanalClient类文件。

注意密码是通过MD5加密的，图中这这段字符应替换为canal。

在这里插入图片描述

3. 目标数据库配置

在yml中配置数据同步目标数据库即可
在这里插入图片描述

源代码:

package com.canal.canalclient.config;

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.CanalEntry.Column;
import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
import com.alibaba.otter.canal.protocol.Message;
import com.google.protobuf.InvalidProtocolBufferException;
import org.springframework.jdbc.core.JdbcTemplate;

import java.net.InetSocketAddress;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
 * @Auther: fzl
 * @Date: 2020/4/20 01:21
 * @Description:
 */
public class CanalClient {

    private static Queue<String> SQL_QUEUE = new ConcurrentLinkedQueue<>();

    public static void startCanal() {
        //获取canalServer连接：本机地址,端口号
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("IP地址"
                , "端口号"), "example", "canal", "canal");

        int batchSize = 1000;
        try {
            //连接canalServer
            connector.connect();
            //订阅Desctinstion
            connector.subscribe();
            connector.rollback();
            try {
                while (true) {
                    //尝试从master那边拉去数据batchSize条记录，有多少取多少
                    //轮询拉取数据   上面的where
                    Message message = connector.getWithoutAck(batchSize);
                    long batchId = message.getId();
                    int size = message.getEntries().size();
                    if (batchId == -1 || size == 0) {
                        //睡眠
                        Thread.sleep(1000);
                    } else {
                        dataHandle(message.getEntries());
                    }
                    connector.ack(batchId);
                    System.out.println("aa"+size);
                    //当队列里面堆积的sql大于一定数值的时候就模拟执行
                    if (SQL_QUEUE.size() >= 10) {
                        executeQueueSql();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (InvalidProtocolBufferException e) {
                e.printStackTrace();
            }
        } finally {
            connector.disconnect();
        }
    }

    public static JdbcTemplate jdbcTemplate;

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

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

    /**
     * 保存更新语句
     *
     * @param entry
     */
    private static void saveUpdateSql(CanalEntry.Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<CanalEntry.RowData> rowDatasList = rowChange.getRowDatasList();
            for (CanalEntry.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(CanalEntry.Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<CanalEntry.RowData> rowDatasList = rowChange.getRowDatasList();
            for (CanalEntry.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(CanalEntry.Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<CanalEntry.RowData> rowDatasList = rowChange.getRowDatasList();
            for (CanalEntry.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();
        }
    }
}

package com.canal.canalclient;

import com.canal.canalclient.config.CanalClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;


@Component
@Slf4j
public class StartedFunction implements ApplicationRunner {

    @Autowired
    @Qualifier("test_master_energy") //有多个数据源的，需要名称区分
    private static JdbcTemplate jdbcTemplate;


    @Override
    public void run(ApplicationArguments args)  throws Exception{
        log.info("开始监听同步数据库");

        CanalClient.jdbcTemplate = jdbcTemplate;
        CanalClient.startCanal();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.canal</groupId>
    <artifactId>CanalClient</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>CanalClient</name>
    <description>CanalClient</description>
    <properties>
        <java.version>19</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
            <version>1.1.4</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.9</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 打包时跳过测试 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.12.4</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>

    </build>

</project>
大可iii
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Canal——数据同步
weixin_43241803的博客
03-15 4385
Canal——数据同步
深入理解Canal
RuiKe的博客
09-22 3606
Canal是一款基于数据库增量日志订阅和消费的开源产品，它能够捕获数据库的变更数据，并把这些变更数据传递给其他系统。（官网目前只支持mysql，支持pg等得用插件）它的作用是实时监控数据库变更，并将变更数据传输给其他系统，用于数据同步、数据分析等场景。
SpringBoot整合Canal实现数据同步
最新发布
MMF博客园
05-21 346
SpringBoot整合Canal实现数据同步
了解canal，看这个就够了
八荒六合唯我独尊
04-21 1722
https://blog.csdn.net/zhouyan8603/article/details/108612575 一. canal概述 canal是Alibaba旗下的一款开源项目,纯Java开发.它是基于数据库增量日志解析,提供增量数据订阅&消费,目前主要支持mysql。 应用场景： 1.数据同步，比如：做在线、离线数据库之间的数据同步操作； 2.数据消费，比如：需要根据关注的数据库表的变化，做搜索增量； 3.数据脱敏，比如：需要将线上动态数据导入到其他地方，做数据脱敏。 二.
【Linux】canal1.1.7同步MySQL8.0.3和Redis
dreambyday
03-06 1141
自MySQL 8.0.3开始，身份验证插件默认使用caching_sha2_password。按照官网的文档执行，在启动时会报错。本文写了下大致的步骤。
SpringBoot整合Canal实现数据同步到ElasticSearch
西风小焦的博客
07-26 1883
SpringBoot+Canal+Mq整合实现数据同步
canal数据同步工具
04-24
《Canal数据同步工具详解及应用实践》 在大数据领域，数据同步是一个至关重要的环节，尤其是在分布式系统中，数据的一致性和实时性是系统稳定运行的基础。Canal，由阿里巴巴开源，是一个轻量级的数据变更捕获与同步...
canal数据binlog同步demo
04-07
6. **数据同步**：同步过程可以是全量同步（首次同步）和增量同步（基于binlog事件的持续同步）。全量同步通常在系统初始化时进行，而增量同步则持续进行，确保源数据库和目标数据库保持一致。 7. **应用场景**：...
canal数据异构组件包
12-27
总的来说，“Canal数据异构组件包”是一个强大且灵活的数据库变更数据同步工具，对于需要实时数据处理和分析的IT系统来说，是一个不可或缺的组件。通过熟练掌握Canal的使用，开发者可以高效地解决数据异构和实时同步...
基于Canal的MySQL数据同步中间件.zip
02-17
【项目资源】： 包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。 ... 【项目质量】： 所有源码都经过严格测试，...
基于canal的Mysql数据同步实验手册.pdf
12-23
【基于Canal的Mysql数据同步实验】 在大数据领域，数据采集是至关重要的第一步，而实时数据同步则是保障数据一致性、提升系统效率的关键技术。Canal是阿里巴巴开源的一款针对MySQL数据库的数据变更订阅与推送组件，...
【Canal】从原理、配置出发，从0到1完成Canal搭建
阿Q的小窝
07-03 9646
前几天在网上冲浪的时候发现了一个比较成熟的开源中间件——Canal。在了解了它的工作原理和使用场景后，顿时产生了浓厚的兴趣。今天，就让我们跟随阿Q的脚步，一起来揭开它神秘的面纱吧。
centos7 部署 canal 1.1.7 MySQL 同步数据到 MySQL
qq_37084490的博客
03-19 1249
创建 adapter 文件夹， 上传canal.adapter-1.1.7-SNAPSHOT.tar.gz 文件到 /usr/local/canal# 解压# 配置 Instance# 配置 bootstrap.yml， canal_manager 数据库canal:manager:jdbc:### 配置目标数据库, 重要参数 report， 要跟上一步创建Instances 名称相同groups:# 配置rdb。
elasticsearch+canal增量、全量同步
baidu_36124158的博客
11-16 1406
进入 es plugins 文件夹下的 ik 文件夹，进入 config 目录，创建 custom.dic文件，比如我要`弗雷尔卓德`不分词，就把`弗雷尔卓德`写到custom.dic里边，使用回车换行，区分。解压/data/soft/elasticsearch-analysis-ik-7.9.0.zip到每一台集群机器/data/es-cluster/elasticsearch-7.9.0-nodexx/plugins下。访问xxx.xxx.xxx.xxx:5601输入账号密码即可访问。
Canal同步数据
qq_43409401的博客
01-10 2015
Canal可以用来监控数据库数据的变化，从而获得新增数据，或者修改的数据。
云讯健身管理系统-15--Canal数据同步
leo10_Barcelona的博客
10-21 314
一、Canal介绍 1、应用场景 在前面的统计分析功能中，我们采取了服务调用获取统计数据，这样耦合度高，效率相对较低，目前我采取另一种实现方式，通过实时同步数据库表的方式实现，例如我们要统计每天注册与登录人数，我们只需把会员表同步到统计库中，实现本地统计就可以了，这样效率更高，耦合度更低，Canal就是一个很好的数据库同步工具。canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL。 2、Canal环境搭建 canal的原理
Canal
m0_46659255的博客
12-13 291
1.1 环境部署 1.1.1 mysql开启binlog模式 （1）查看当前mysql是否开启binlog模式。 SHOW VARIABLES LIKE '%log_bin%' 如果log_bin的值为OFF是未开启，为ON是已开启。 （2）修改/etc/my.cnf 需要开启binlog模式。 [mysqld] log-bin=mysql-bin binlog-format=ROW server_id=1 修改完成之后，重启mysqld的服务。 (3) 进入mysql mysql -h localho
阿里开源数据同步组件Canal
progammer10086的博客
02-26 3681
一.简介 canal是阿里开源的数据同步组件 这个是是git地址 二.使用步骤 1.安装配置mysql 安装一个数据库（这个数据库是被监听的对象，我这里用的是mysql5.7） 创建一个用户专门用于数据同步（这里也可以直接用root用户） ①创建用户 用户名：canal 密码：canal create user 'canal'@'%' identified by 'canal'; ②授予外部访问权限 grant SELECT, REPLICATION SLAVE, REPLICATION CLIENT
Java开发 - Canal的基本用法
CodingFire的博客
06-30 3854
译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。下面这张图可以代表Canal的用途，就染我们来一起瞻仰一下：基于日志增量订阅和消费的业务包括数据库镜像数据库实时备份索引构建和实时维护(拆分异构索引、倒排索引等)业务 cache 刷新带业务逻辑的增量数据处理当前的 canal 支持源端 MySQL 版本包括 5.1.x , 5.5.x , 5.6.x , 5.7.x , 8.0.x。
canal培训.pptx
03-06
Canal 培训.pptx 文件提供了关于 Canal 服务在数据库增量数据同步和数据订阅方面的详细信息。这份培训材料涵盖了 Canal binlog 同步和 Canal 服务的培训内容，旨在帮助用户了解和掌握如何使用 Canal 实现数据库增量...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大可iii

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

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

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

打赏作者

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

抵扣说明：

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

余额充值