springboot集成canal 实现mysql增量同步mongodb

最新推荐文章于 2024-04-04 12:15:09 发布

qq_41369135

最新推荐文章于 2024-04-04 12:15:09 发布

阅读量1.7k

点赞数

分类专栏： Mysql 文章标签： canal mongodb mysql springboot Powered by 金山文档

本文链接：https://blog.csdn.net/qq_41369135/article/details/129323420

版权

Mysql 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、canal官网

https://kgithub.com/alibaba/canal/

二、下载地址

https://kgithub.com/alibaba/canal/releases

三、细节

1.6版本有bug（如果只是部署deployer，那没问题，如果你想部署admin模块来监控，那就会报错：java.nio.ByteBuffer.clear()Ljava/nio/ByteBuffer），这是因为这版本对jdk1.8不支持。

如果想监控，那就下载admin和deployer

如果想集成mq来消费（相当于canal收集到binlog日志后不作任何处理直接发给非关系型数据库），那就还需要下载adapter

四、集成步骤

如果不需要admin，只需要看这个就够了

https://kgithub.com/alibaba/canal/wiki/QuickStart

Springboot集成canal客户端消费

    <!--canal 增量订阅&消费组件  1.5以上client和protocol拆开了，需要导入两个jar-->
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
            <version>1.1.6</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.protocol</artifactId>
            <version>1.1.6</version>
        </dependency>

package com.ruoyi.mongodb.runner;

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 lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedDeque;

/**
 * @author yh
 */
@Slf4j
@Component
//public class CanalClientRunner {
public class CanalClientRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("===> start connect to canal-server......");
        CanalConnector connector = CanalConnectors.newSingleConnector(
                new InetSocketAddress("127.0.0.1", 11111),
                "example", "canal", "canal");
        int batchSize = 1000;
        int emptyCount = 0;
        try {
            // 连接
            connector.connect();
            log.info("===> connect to database success......");
            // 订阅所有数据库表
//            connector.subscribe(".*\\..*");
            connector.subscribe("inst_ops.test_plus");
            // 订阅指定数据库 例：订阅test_data数据库所有表
//            connector.subscribe("inst_ops\\..*");
            // 回滚
            connector.rollback();
            int totalEmptyCount = 200;
            while (emptyCount < totalEmptyCount) {
                // 尝试从master拉取数据batchSize条记录
                Message message = connector.getWithoutAck(batchSize);// 获取指定数量的数据
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    emptyCount++;
                    log.info("empty count : " + emptyCount);
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    log.info("===> " + String.format("message [batchId=%s,size=%s] ", batchId, size));
                } else {
                    emptyCount = 0;
                    dataHandle(message.getEntries());
                }
                connector.ack(batchId); // 提交确认
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }
            log.info("empty too many times, exit");
        } catch (Exception e) {
            connector.rollback(); // 处理失败, 回滚数据
            log.error("===> 服务异常,连接中断..." + e);
        } finally {
            connector.disconnect();
            log.info("===> 成功断开连接...");
        }
    }

    /**
     * 解析数据
     *
     * @param entries
     */
    private void dataHandle(List<CanalEntry.Entry> entries) {
        for (CanalEntry.Entry entry : entries) {
            if(entry.getHeader().getTableName().equals("test_plus")){
                System.err.println(entry.getHeader().getTableName()+ ":---------------------");
            }
            // 开启/关闭事务的实体类跳过
            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN
                    || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                continue;
            }
            // RowChange对象，包含了一行数据变化的所有特征
            CanalEntry.RowChange rowChange;
            try {
                rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
                // 获取数据的操作类型 update/insert/delete
                CanalEntry.EventType eventType = rowChange.getEventType();
                log.info("===> " + String.format("binlog[%s:%s] , schemaName[%s] , tableName[%s] , eventType : %s",
                        entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                        entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                        eventType));
                // 判断是否是DDL语句
                if (rowChange.getIsDdl()) {
                    log.info("===> execute DDL statement is true,sql:{}", rowChange.getSql());
                }
                // 获取RowChange对象里的每一行数据实现业务处理
                for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
                    // 删除语句
                    if (eventType == CanalEntry.EventType.DELETE) {
                        collectLog(rowData.getBeforeColumnsList());
                        // 新增语句
                    } else if (eventType == CanalEntry.EventType.INSERT) {
                        collectLog(rowData.getAfterColumnsList());
                        // 更新语句
                    } else {
                        log.info("===> update data before.....");
                        collectLog(rowData.getBeforeColumnsList());
                        log.info("===> update data after.....");
                        collectLog(rowData.getAfterColumnsList());
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * sql执行语句收集
     *
     * @param columns
     */
    private void collectLog(List<CanalEntry.Column> columns) {
        for (CanalEntry.Column column : columns) {
            log.info("===> columnName:{},columnValue:{},update:{}", column.getName(), column.getValue(), column.getUpdated());
        }
    }
}

没错，就这么简单、就集成完毕了！

如果想部署admin，直接看下面这个，第一步都没看的必要

https://github.com/alibaba/canal/wiki/Canal-Admin-QuickStart

admin启动成功后这里就讲解几个注意点

1、在修改admin模块下conf/application.yml时，框框圈起的地方一定改成有读写权限的用户，官方例子的canal用户如果我们没做修改，只有读的权限，不能写入。所以不改一般启动会报错

先启动admin、后启动deployer

deployer启动成功后登录http://127.0.0.1:8089/，状态是启动

启动instance（这玩意才是真正监听binlog的）

新建

导入配置

这里有个小细节，你填的instance名称一定要与客户端代码一致

比如我在admin页面新增实例【单节点实例1】，那我的代码就要改成一样的，不然你还是官网的【example】，就会一直报can't find destination:example

启动springboot项目

先启动项目，然后在navicat执行插入语句

可以看见已经监听到了，然后把他转成mongodb中的文档对象，实现数据增量同步了

qq_41369135

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
springboot集成canal 实现mysql增量同步mongodb

1. 1.6版本有bug（如果只是部署deployer，那没问题，如果你想部署admin模块来监控，那就会报错：java.nio.ByteBuffer.clear()Ljava/nio/ByteBuffer），这是因为这版本对jdk1.8不支持。报错：can't find destination:example
复制链接

扫一扫