微服务模块:canal数据同步工具,详解及代码演示

最新推荐文章于 2024-08-02 02:01:46 发布
最新推荐文章于 2024-08-02 02:01:46 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： canal 文章标签： canal
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42400763/article/details/108224200
版权

  从早期的服务,一库走天下,再到现在微服务的诞生,也能用一个数据库去存储所有的微服务中所需要的数据,
  但是如果说一个项目不只是你一个人在做,而是一个项目组做的,那如何去维护同一个数据库,如果说有可怕分子删库跑路,那是不是整个项目组都得受影响呢,所以我们需要在不同的微服务中建立不同的数据库.但随之而来的又是新的问题,数据库之间又是怎么联系的呢,
  假如说做注册功能的小组中数据库发生了变化,如何通知到做统计的小组的数据库呢?
所以这才有了canal数据同步工具的出现
一.应用场景
例如我们要统计每天注册与登录人数，我们只需把会员表同步到统计库中，实现本地统计就可以了，这样效率更高，耦合度更低，Canal就是一个很好的数据库同步工具。canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL。
在这里插入图片描述
同步过程的准备工作:
在这里插入图片描述

我们先要准备一个linux数据库,这里的服务器我们可以安装一个虚拟机,或者有服务器的同学可以在linux服务器上安装一个mysql.这里不做过多的深入.
我们在linux的mysql数据库中创建一个数据库名字为members,表中字段为
id.username,age.

create database guli;
create table members(
  id int primary key,
  username varchar(100),
  age int 
  );

在这里插入图片描述

同样的我们在本地的数据库中也创建一个相同名称相同字段的数据库.
在这里插入图片描述然后我们来演示一下我们在linux数据库中添加一条记录,在本地的windows数据库中也新增了一条数据
步骤:
第一步:修改linux系统的mysql数据库中的配置

canal的原理是基于mysql binlog技术，所以这里一定需要开启mysql的binlog写入功能

开启mysql服务： service mysql start
（1）检查binlog功能是否有开启
执行sql语句:
mysql> show variables like ‘log_bin’;
在这里插入图片描述2）如果显示状态为OFF表示该功能未开启，所以我们需要开启binlog功能

1，修改 mysql 的配置文件 my.cnf
vi /etc/my.cnf 
追加内容：
log-bin=mysql-bin     #binlog文件名
binlog_format=ROW     #选择row模式
server_id=1           #mysql实例id,不能和canal的slaveId重复

2，重启 mysql：
service mysql restart	

3，登录 mysql 客户端，查看 log_bin 变量
mysql> show variables like 'log_bin';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| log_bin       | ON|
+---------------+-------+
1 row in set (0.00 sec)
————————————————
如果显示状态为ON表示该功能已开启

3）在mysql里面添加以下的相关用户和权限

CREATE USER 'canal'@'%' IDENTIFIED BY 'canal';
GRANT SHOW VIEW, SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';
FLUSH PRIVILEGES;

在这里插入图片描述
接下来演示安装canal服务的步骤
首先从官网下载压缩包
地址:https://github.com/alibaba/canal/releases

（1）下载之后，放到目录中，解压文件

canal.deployer-1.1.4.tar.gz # 包的全名
你可以将其放在你想放的目录下,比如说我的位置是usr/local/canal
tar zxvf canal.deployer-1.1.4.tar.gz # 在其目录下解压

（2）修改配置文件

vi conf/example/instance.properties

#需要改成自己的数据库信息
canal.instance.master.address={你的主机ip}:3306

#需要改成自己的数据库用户名与密码

canal.instance.dbUsername=canal
canal.instance.dbPassword=canal

#需要改成同步的数据库表规则，例如只是同步一下表
#canal.instance.filter.regex=.*\\..*
canal.instance.filter.regex=guli_ucenter.ucenter_member

注：
mysql 数据解析关注的表，Perl正则表达式.
多个正则之间以逗号(,)分隔，转义符需要双斜杠(\)
常见例子：

  1. 所有表：.* or .\…
  2. canal schema下所有表： canal\…*
  3. canal下的以canal打头的表：canal\.canal.*
  4. canal schema下的一张表：canal.test1
  5. 多个规则组合使用：canal\…*,mysql.test1,mysql.test2 (逗号分隔)
    注意：此过滤条件只针对row模式的数据有效(ps. mixed/statement因为不解析sql，所以无法准确提取tableName进行过滤)

4.（3）进入bin目录下启动
在这里插入图片描述命令:./startup.sh
在这里插入图片描述表示启动完毕.

二:创建canal_client模块
1、在guliedu_parent下创建canal_client模块
在这里插入图片描述2、引入相关依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

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

3、创建application.properties配置文件

# 服务端口
server.port=10000
# 服务名
spring.application.name=canal-client

# 环境设置：dev、test、prod
spring.profiles.active=dev

# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/guli?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456

4、编写canal客户端类
在这里插入图片描述

package com.qiu.canal.client;
@Component
public class CanalClient {

    //sql队列
    private Queue<String> SQL_QUEUE = new ConcurrentLinkedQueue<>();

    @Resource
    private DataSource dataSource;

    /**
     * canal入库方法
     */
    public void run() {

        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.44.132",
                11111), "example", "", "");
        int batchSize = 1000;
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            try {
                while (true) {
                    //尝试从master那边拉去数据batchSize条记录，有多少取多少
                    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);

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

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

            this.execute(sql.toString());
        }
    }

    /**
     * 数据处理
     *
     * @param entrys
     */
    private void dataHandle(List<Entry> entrys) throws InvalidProtocolBufferException {
        for (Entry entry : entrys) {
            if (EntryType.ROWDATA == entry.getEntryType()) {
                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);
                }
            }
        }
    }

    /**
     * 保存更新语句
     *
     * @param entry
     */
    private 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().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 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().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 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().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();
        }
    }

    /**
     * 入库
     * @param sql
     */
    public void execute(String sql) {
        Connection con = null;
        try {
            if(null == sql) return;
            con = dataSource.getConnection();
            QueryRunner qr = new QueryRunner();
            int row = qr.execute(con, sql);
            System.out.println("update: "+ row);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(con);
        }
    }
}

为了保证linux数据库中修改数据本地也会修改数据,则我们需要修改canal启动类.

@SpringBootApplication
public class CanalApplication implements CommandLineRunner {
    @Resource
    private CanalClient canalClient;

    public static void main(String[] args) {
        SpringApplication.run(CanalApplication.class, args);
    }

    @Override
    public void run(String... strings) throws Exception {
        //项目启动，执行canal客户端监听
        canalClient.run();
    }
}

目的就是为了程序一直处于监听状态
在这里插入图片描述client中这里的hostname换成自己的ip
要这样的话就能实现两个不同数据库之间表的联动效果了

风中有朵雨做的云yi
关注
专栏目录
1.5 Canal 数据同步工具详细教程
在路上的专栏
07-01 1297
Canal是一款开源的MySQL binlog增量订阅和消费中间件，由阿里巴巴开发。它通过模拟MySQL Slave与Master的交互，实现实时数据同步和监控。Canal的架构包括Canal Server、Canal Client和Zookeeper等组件，工作流程涵盖连接MySQL、拉取和解析binlog、推送数据等步骤。其主要应用场景包括数据同步、数据监控和缓存更新。尽管Canal配置复杂且依赖MySQL复制机制，但其高效、实时的数据处理能力使其在多种场景下具有广泛应用。
主流数据同步工具对比详解
program哲学
06-26 1483
数据同步工具是企业常用的中间件，如何从众多工具中正确选型是个问题，本文详细介绍了主流工具的优缺点、应用场景和各个维度的对比。
canal 历史数据如何处理_开源数据同步神器——canal
weixin_39724009的博客
11-26 1264
前言如今大型的IT系统中，都会使用分布式的方式，同时会有非常多的中间件，如redis、消息队列、大数据存储等，但是实际核心的数据存储依然是存储在数据库，作为使用最广泛的数据库，如何将mysql的数据与中间件的数据进行同步，既能确保数据的一致性、及时性，也能做到代码无侵入的方式呢？如果有这样的一个需求，数据修改后，需要及时的将mysql中的数据更新到elasticsearch,我们会怎么进行实现呢？...
canal 数据同步工具
雨声学java
06-01 181
概念： canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL应用场景Feign远程调用（之前用远程调用来获取）canal 把远程库里面的内容同步到本地库中实现流程：
实战：MySQL数据同步神器之Canal
最新发布
为无为，事无事，味无味。
08-02 2475
canal [kə'næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。项目起源于阿里巴巴内部对于跨机房数据同步的需求，通过解析MySQL的二进制日志（Binary Log），Canal能够捕获并推送数据库的变更事件，满足了诸如数据库镜像、实时备份、索引实时维护等多种业务场景的需求。GitHub - alibaba/canal: 阿里巴巴 MySQL binlog 增量订阅&消费组件。
canal数据同步
追梦赤子的博客
10-31 177
canal同步过程 linux系统： 本地windows系统： 检查binlog是否开启： 开启binlog： 安装canal及其修改配置：
Canal数据同步
weixin_44735933的博客
09-11 360
一.介绍canal canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL。 二.准备环境 一台linux系统 , 一台windows系统 , 两台系统均安装有mysql数据库 两台系统有一个同名数据库 , 且有一张同结构的表 create database cpdkedu; use cpdkedu; create table members( id int primary key, username varchar(10
canal数据同步工具
04-24
《Canal数据同步工具详解及应用实践》 在大数据领域，数据同步是一个至关重要的环节，尤其是在分布式系统中，数据的一致性和实时性是系统稳定运行的基础。Canal，由阿里巴巴开源，是一个轻量级的数据变更捕获与同步...
详解监听MySQL的binlog日志工具分析：Canal
12-14
Canal是阿里巴巴开源的一款用于MySQL数据库增量数据订阅与消费的工具，主要基于MySQL的binlog日志解析。MySQL的binlog日志记录了所有对数据库的更改操作，这对于数据同步和备份至关重要。Canal通过模拟MySQL slave的...
canal数据同步工具的使用.zip
08-21
3. **微服务数据同步**：在微服务架构中，各个服务可能需要共享部分数据库数据，Canal可实现实时同步。 4. **数据迁移**：在数据库升级、迁移过程中，Canal可以平滑地将数据迁移到新的数据库系统。 **使用Canal进行...
最新版Canal数据同步中间件（包含canal.deployer和canal.adapter）
12-01
最新版阿里开源中间件canal实现mysql数据库同步，零侵入不写代码实现，也可以通过整合到项目程序实现更加灵活的控制。详细使用方法：https://blog.csdn.net/u014374009/category_9409106.html
一篇文章让你上手Canal数据同步神技~
langfeiyes的博客
05-16 3423
从0开始讲解Canal基本使用，教程中包含：canal概念， canal原理，canal操作步骤，canal数据编程，canal运用场景，结合Springboot 实现canal集成，最后以面试题方式回顾整个canal使用
Canal——数据同步
weixin_43241803的博客
03-15 4681
Canal——数据同步
Canal同步数据
qq_43409401的博客
01-10 2081
Canal可以用来监控数据库数据的变化，从而获得新增数据，或者修改的数据。
canal 同步数据
jasion_zhang的博客
04-10 295
功能：在 MySQL 的配置文件 my.cnf 中修改相关参数，如设置 binlog 文件名、binlog 格式（例如 ROW），并确保 server_id 设置正确，以避免与 Canal 的 slaveId 冲突。Canal 的使用场景包括但不限于统计分析、数据迁移、数据复制等，它通过解析 MySQL 的二进制日志（binlog）来实现数据同步，具有高效率和低耦合的特点。同步全量数据：如果需要同步 MySQL 的全量数据，可以手动调用 Client-Adapter 服务的方法来触发同步任务。
Canal实现数据同步
YIYIYI
10-02 3244
Canal实现数据同步
数据同步 canal
煎蛋的梦
05-04 782
在公司负责中间件一段时间了！对于作为应届生的我，非常荣幸！谢谢！下面将全面分析 canal 运行的内部机制！同时，我整理的笔记，将放在 GitHub 上面！大概一个月之后吧！有点乱！感谢开源！还是阿里好！哈哈哈！！！
阿里开源Canal：数据库增量数据同步工具详解
Canal是一个由阿里巴巴开源的数据库增量数据同步工具，它的名称来源于英文单词“canal”，意为水道或管道，象征着它在数据库和其它存储应用之间起到数据传输的桥梁作用。Canal的主要功能是解析MySQL的增量日志...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值