canal 嵌入式部署 监听binlog

已于 2023-08-09 16:36:09 修改
阅读量614 收藏 1
点赞数 1
分类专栏： mysql 文章标签： java mysql binlog canal 嵌入式
于 2023-08-09 16:32:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Em_dark/article/details/132189382
版权

canal 嵌入式部署

背景

最近发现一个需求,需要监听mysql 数据库里的数据变动, 但由于架构方面的原因, 只能做成单体嵌入式的方向,嵌入进应用中,不用单独部署

技术选型

我对监控binlog 监控工具进行了了解,包括

  1. mysql-binlog-connector-java1
  2. canal2
  3. open-replicator3

canal

本篇博文主讲cannal 的嵌入模式

原理

在这里插入图片描述

用途

要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费

基于日志增量订阅和消费的业务包括

  • 数据库镜像
  • 数据库实时备份
  • 索引构建和实时维护(拆分异构索引、倒排索引等)
  • 业务 cache 刷新
  • 带业务逻辑的增量数据处理

嵌入式代码实现

引入pom

         <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
            <version>1.1.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.common</artifactId>
            <version>1.1.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.protocol</artifactId>
            <version>1.1.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.deployer</artifactId>
            <version>1.1.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.server</artifactId>
            <version>1.1.4</version>
        </dependency>

引入工具pom

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>

main方法

public static void main(String[] args) {
        EmbeddedCanalListener embeddedCanalListener = new EmbeddedCanalListener();
        //安装实体
        embeddedCanalListener.install();
        //拉取消息
        embeddedCanalListener.pull();
    }

引入

import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.instance.manager.CanalInstanceWithManager;
import com.alibaba.otter.canal.instance.manager.model.Canal;
import com.alibaba.otter.canal.instance.manager.model.CanalParameter;
import com.alibaba.otter.canal.instance.manager.model.CanalParameter.IndexMode;
import com.alibaba.otter.canal.instance.manager.model.CanalParameter.SourcingType;
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.CanalEntry.EntryType;
import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
import com.alibaba.otter.canal.protocol.CanalEntry.Pair;
import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
import com.alibaba.otter.canal.protocol.CanalEntry.TransactionBegin;
import com.alibaba.otter.canal.protocol.CanalEntry.TransactionEnd;
import com.alibaba.otter.canal.protocol.ClientIdentity;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.server.embedded.CanalServerWithEmbedded;
import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.SystemUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

常量定义


    //日志
    public static final Logger logger = LoggerFactory.getLogger(EmbeddedCanalListener.class);
    //随意命名
    protected static final String DESTINATION = "example";
    //测试sql
    protected static final String DETECTING_SQL = "select 1 from dual;";
    //MSQL配置
    protected static final String MYSQL_ADDRESS = "xxxx";
    protected static final int MYSQL_PORT = xxx;
    protected static final String USERNAME = "xxx";
    protected static final String PASSWORD = "xxx";
    //使用ORACLE 未实现
    protected static final String ORACLE_ADDRESS = "xx.xx.xx.xx";
    protected static final int ORACLE_PORT = xxx;
    protected static final String ORACLE_USERNAME = "xxx";
    protected static final String ORACLE_PASSWORD = "xxx";
    /**
     * 表筛选 , 这里默认全部
     * 多个正则之间以逗号(,)分隔，转义符需要双斜杠(\\)
     * <p>
     * <p>
     * 常见例子：
     * <p>
     * 1.  所有表：.*   or  .*\\..* 2.  canal schema下所有表： canal\\..* 3.  canal下的以canal打头的表：canal\\.canal.* 4.  canal schema下的一张表：canal\\.test1
     * <p>
     * 5.  多个规则组合使用：canal\\..*,mysql.test1,mysql.test2 (逗号分隔)
     */
    protected static final String FILTER = ".*";
    //定义一个server
    private CanalServerWithEmbedded server;
    //定义一个client
    private ClientIdentity clientIdentity = new ClientIdentity(DESTINATION, (short) 1);
    
static {
        context_format = SEP + "****************************************************" + SEP;
        context_format += "* Batch Id: [{}] ,count : [{}] , memsize : [{}] , Time : {}" + SEP;
        context_format += "* Start : [{}] " + SEP;
        context_format += "* End : [{}] " + SEP;
        context_format += "****************************************************" + SEP;

        row_format = SEP
            + "----------------> binlog[{}:{}] , name[{},{}] , eventType : {} , executeTime : {}({}) , gtid : ({}) , delay : {} ms"
            + SEP;

        transaction_format = SEP + "================> binlog[{}:{}] , executeTime : {}({}) , gtid : ({}) , delay : {}ms"
            + SEP;

    }

install方法

        //获取一个instance
        server = CanalServerWithEmbedded.instance();
        //设置一个gennertor去生成
        server.setCanalInstanceGenerator(destination -> {
        	//构建cannal 把上面的参数设置进去
            Canal canal = buildCanal();
            //返回一个Manager
            return new CanalInstanceWithManager(canal, FILTER);
        });
        //启动
        server.start();
        //启动这个实例
        server.start(DESTINATION);

buildCanal方法

		Canal canal = new Canal();
		//ID无意义 随便设置
        canal.setId(12L);
        canal.setName(DESTINATION);
        canal.setDesc("my standalone server test ");

        CanalParameter parameter = new CanalParameter();
        //parameter.setDataDir("./conf");
        //索引的模式, 嵌入式选择内存
        parameter.setIndexMode(IndexMode.MEMORY);
        //存储buffsize 具体看canal 官方的介绍
        parameter.setMemoryStorageBufferSize(32 * 1024);
        //设置Mysql的配置 包括模式,地址,默认scheme,用户名,密码,slaveId(查看mysql的My.conf),链接编码格式,缓存设置(看官方介绍)
        parameter.setSourcingType(SourcingType.MYSQL);
        parameter.setDbAddresses(Arrays.asList(new InetSocketAddress(MYSQL_ADDRESS, MYSQL_PORT)));
        parameter.setDefaultDatabaseName("XXXX");
        parameter.setDbUsername(MYSQL_USERNAME);
        parameter.setDbPassword(MYSQL_PASSWORD);
        //可以指定binlog 和起始位置 或者其实timestamp
//        parameter.setPositions(Arrays.asList("{\"journalName\":\"mysql-bin.000001\",\"position\":332L,\"timestamp\":\"1505998863000\"}",
//                "{\"journalName\":\"mysql-bin.000001\",\"position\":332L,\"timestamp\":\"1505998863000\"}"));

        parameter.setSlaveId(2L);

        parameter.setDefaultConnectionTimeoutInSeconds(30);
        parameter.setConnectionCharset("GBK");
        parameter.setConnectionCharsetNumber((byte) 33);
        parameter.setReceiveBufferSize(8 * 1024);
        parameter.setSendBufferSize(8 * 1024);
       //测试链接设置 ,这里是false 无意义
        parameter.setDetectingEnable(false);
        parameter.setDetectingIntervalInSeconds(10);
        parameter.setDetectingRetryTimes(3);
        parameter.setDetectingSQL(DETECTING_SQL);
        parameter.setGtidEnable(true);
        canal.setCanalParameter(parameter);
        return canal;

pull方法

		//定义拉取的大小
       int batchSize = 5 * 1024;
        while (running) {
            try {
            	//订阅当前设定的client
                server.subscribe(clientIdentity);
                //循环拉取
                while (running) {
                    Message message = server.getWithoutAck(clientIdentity, batchSize);
                    List<CanalEntry.Entry> entries;
                    //message如果是raw形式的需要去rawEntries去解析
                    if (message.isRaw()) {
                        List<ByteString> rawEntries = message.getRawEntries();
                        entries = new ArrayList<>(rawEntries.size());
                        for (ByteString byteString : rawEntries) {
                            CanalEntry.Entry entry;
                            try {
                                entry = CanalEntry.Entry.parseFrom(byteString);
                            } catch (InvalidProtocolBufferException e) {
                                throw new RuntimeException(e);
                            }
                            entries.add(entry);
                        }
                    } else {
                    //如果不是就直接拉取
                        entries = message.getEntries();
                    }

                    long batchId = message.getId();
                    int size = entries.size();
					//如果是batchId是负一或者无内容进行睡眠
                    if (batchId == -1 || size == 0) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                        }
                    } else {
                        //打印汇总信息
                        printSummary(message, batchId, size);
                        //打印实体信息
                        printEntry2(entries);
                        server.ack(clientIdentity, batchId); // 提交确认
                    }
                }
            } finally {
                 //取消订阅
                //server.unsubscribe(clientIdentity);
            }
        }

printSummary

//打印解读时间
//关注log的起始位置终止位置和时间延迟的可以关注这个类 如何取
 protected void printSummary(Message message, long batchId, int size) {
        long memsize = 0;
        for (Entry entry : message.getEntries()) {
            memsize += entry.getHeader().getEventLength();
        }

        String startPosition = null;
        String endPosition = null;
        if (!CollectionUtils.isEmpty(message.getEntries())) {
            startPosition = buildPositionForDump(message.getEntries().get(0));
            endPosition = buildPositionForDump(message.getEntries().get(message.getEntries().size() - 1));
        }

        SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
        logger.info(context_format,
            new Object[]{batchId, size, memsize, format.format(new Date()), startPosition, endPosition});
    }

    protected String buildPositionForDump(Entry entry) {
        long time = entry.getHeader().getExecuteTime();
        Date date = new Date(time);
        SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
        String position = entry.getHeader().getLogfileName() + ":" + entry.getHeader().getLogfileOffset() + ":"
            + entry.getHeader().getExecuteTime() + "(" + format.format(date) + ")";
        if (StringUtils.isNotEmpty(entry.getHeader().getGtid())) {
            position += " gtid(" + entry.getHeader().getGtid() + ")";
        }
        return position;
    }

printEntry2

//打印实体

   private void printEntry2(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) 		      {
            //如果需要监控事务的可以在这里进行实现
                continue;
            }

            RowChange rowChage = null;
            try {
                rowChage = RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
                    e);
            }
			//关注具体内容可以在这里实现
            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 (RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == EventType.DELETE) {
                    printColumn(rowData.getBeforeColumnsList());
                } else if (eventType == EventType.INSERT) {
                    printColumn(rowData.getAfterColumnsList());
                } else {
                    System.out.println("-------&gt; before");
                    printColumn(rowData.getBeforeColumnsList());
                    System.out.println("-------&gt; after");
                    printColumn(rowData.getAfterColumnsList());
                }
            }
        }
    }

//打印具体内容
protected void printColumn(List<Column> columns) {
        for (Column column : columns) {
            //如果column 是更新了的字段才打印
            if (column.getUpdated()) {
                StringBuilder builder = new StringBuilder();
                try {
                    if (StringUtils.containsIgnoreCase(column.getMysqlType(), "BLOB")
                        || StringUtils.containsIgnoreCase(column.getMysqlType(), "BINARY")) {
                        // get value bytes
                        builder.append(
                            column.getName() + " : " + new String(column.getValue().getBytes("ISO-8859-1"), "UTF-8"));
                    } else {
                        builder.append(column.getName() + " : " + column.getValue());
                    }
                } catch (UnsupportedEncodingException e) {
                }
                builder.append("    type=" + column.getMysqlType());
                if (column.getUpdated()) {
                    builder.append("    update=" + column.getUpdated());
                }
                builder.append(SEP);
                logger.info(builder.toString());
            }
        }

    }

总结

到这里 代码基本完成了, 然后根据自己的业务实现就好了
具体可以参考 canal java 客户端 的官方实现
还有他们的 AdminGuide 里面有详细的案例
推荐一份源码解析

谢谢

  1. mysql-binlog-connector-java ↩︎

  2. canal ↩︎

  3. open-replicator ↩︎

Em_dark
关注
专栏目录
SpringBoot2.0与微服务实践系列教程（本专栏导航）
Nicky's blog
04-10 6438
本专栏基于Springboot2.0，配套自己写的代码例子和图例。内容涉及从基础入门到微服务架构的实践，包括基础的配置用法，web，数据库，Redis，日志使用，也涉及到企业级开发的消息队列，Mongodb，ElasticSearch、OAuth2.0、JWT、还有微服务系列Spring Cloud、Dubbo、Spring Cloud Aliaba，形成一个体系的博客，并有源码的简单分析，适合作为入门的教程 ......
网络安全方向相关课题和材料
学-> 思->用
10-30 1177
搜集大量网络安全行业开源项目一个是关注互联网企业/团队的安全开源项目，经企业内部实践，这些最佳实践值得借鉴。一个是来自企业安全能力建设的需求，根据需求分类，如WAF、HIDS、Git监控等。这个收集是一个长期的过程，我在GitHub创建了这个项目，专门用来收集一些优秀的甲方安全项目。还有很多很好的免费开源项目可供选择，下面列出的还只是其中很少的一部分，我将持续更新这个项目，欢迎Star。
canal数据库binlog监听-核心实现和event事件
weixin_71214276的博客
03-31 897
event类型编号说明012STOP_EVENT345LOAD_EVENT6789101112RAND_EVENT131415XID_EVENT1617181920212223242526272829303132333435363738394041。
Cannal监听binlog
qq_41810415的博客
09-01 3202
这个cannal与美团中的DTS比较类似，业务需求中可能监听表的插入、更新、删除的操作，然后发送mafka消息。
canal-gule-core多表数据处理与EasyES的使用
最新发布
qq_40688054的博客
08-06 657
上一节介绍了Elasticsearch的安装使用，以及使用Canal和RocketMQ同步Elasticsearch和MySQL数据库。在最后，还介绍了使用canal-glue-core框架处理RocketMQ中Canal监听的binlog日志，但是只是讲解了如何处理单个表格的日志，这篇文章分析了如何使用canal-glue-core处理多个表格的日志。
Canal监听binlog
LSDNH_123的博客
10-29 4269
MySQL binlog MySQL主从复制 mysql服务端修改配置并重启 1 2 3 4 5 6 7 8 9 10 11 12 $ vi /etc/my.cnf [mysqld] log-bin=mysql-bin binlog-format=ROW server_id=1 $ mysql -uroot CREATE USER canal IDENT...
Canal 监听mysql binlog
kaili_0230的博客
10-25 1429
cancl概述 canal是应阿里巴巴存在杭州和美国的双机房部署，存在跨机房同步的业务需求而提出的。 早期，阿里巴巴B2B公司因为存在杭州和美国双机房部署，存在跨机房同步的业务需求。不过早期的数据库同步业务，主要是基于trigger的方式获取增量变更，不过从2010年开始，阿里系公司开始逐步的尝试基于数据库的日志解析，获取增量变更进行同步，由此衍生出了增量订阅&消费的业务，从此开启了一段新纪元。ps. 目前内部使用的同步，已经支持mysql5.x和oracle部分版本的日志解析。 基于日志增量订阅&
使用canal配合rocketmq监听mysql的binlog日志
m0_51681531的博客
06-29 5649
使用canal配合rocketmq监听mysql的binlog日志
Canal增量同步MySQL数到Elasticsearch
admin1973的专栏
07-22 829
Canal增量同步MySQL数到Elasticsearch 调研背景 由于业务发展迅速,店铺商品分库越来越多(目前已有8个MySQL分库)且分库中表数据行数越来越大,大的表已经达到了5KW+,业务需要对商品模糊查询或根据其他字段查询,这些查询的字段很多在数据库中都没有索引,查询命中数据很慢(有些数据根本就查询不出来)且会给数据库库带来很大的压力.所以目前希望将MySQL中的商品数据实时同步到E...
使用Lua、OpenResty、Canal实现首页广告缓存与同步.docx
07-03
- **监听MySQL变更**：使用Lua脚本配合Canal监听MySQL的数据变化，当数据发生变化时，及时更新Redis缓存。 ##### 2. OpenResty配置 - **路由配置**：定义请求路径，将请求转发给Lua脚本处理。 - **缓存配置**：在...
一个程序员的成长之路
weixin_35713159的博客
04-13 1393
equals一般比较对象内容是否相等，而==比较两者的栈中保存的对象堆地址值是否相等，即是否指向同一个对象，equals在object中就存在，如不重写的话两者没有区别，重写时一般使用hashcode方法结合，比较相等首先判断hashcode是否相等，相等再进行真实值的比较，大大降低比较时间，最多两次即可判断。原因：在一个范围中的浮点数个数不是有限的，存在精度问题，如果要进行比较，使用BigDecimal并使用BigDecimal提供的对象方法进行计算，构造时使用String作为入参防止丢失精度。
详解监听MySQL的binlog日志工具分析：Canal
12-14
Canal是阿里巴巴旗下的一款开源项目，利用Java开发。主要用途是基于MySQL数据库增量日志解析，提供增量数据订阅和消费，目前主要支持MySQL。 GitHub地址：https://github.com/alibaba/canal 在介绍Canal内部原理之前，首先来了解一下MySQL Master/Slave同步原理： MySQL master启动binlog机制，将数据变更写入二进制日志（binary log, 其中记录叫做二进制日志事件binary log events，可以通过show binlog events进行查看）MySQL slave（I/O thread）将mast
Canal安装和配置，实现监听binlog日志
qq_45932382的博客
09-26 2454
canal监听binlog日志
Docker部署Canal监听MySQL binlog
m0_68681879的博客
09-12 1053
canal的工作原理就是把自己伪装成MySQL slave，模拟MySQL slave的交互协议向MySQL Mater发送 dump协议，MySQL mater收到canal发送过来的dump请求，开始推送binary log给canal，然后canal解析binary log，再发送到存储目的地。第一页长这样，这里我们就修改一下框中的部分，第一个是我们在mysql配置文件中设置的slaveId，下面的是数据库地址，IP:端口号。下面的是需要监听的库表，图中就是默认状态，监听全部，可根据实际需求改。
Canal+kafka实战（监听mysql binlog实现数据同步）
Emmien的博客
07-22 4509
Canal+kafka实战（监听mysql binlog实现数据同步）
Canal监听mysql的binlog日志实现数据同步
靖节先生的博客
08-08 7395
Canal监听mysql的binlog日志实现数据同步1. canal概述1.1 canal简介1.2 原理分析1.2.1 MySQL主备复制原理1.2.2 canal原理2. canal安装配置1.1 mysql环境准备1.2 canal下载1.3 canal配置启动3. 实现验证3.1 案例编码3.2 实现验证 1. canal概述 1.1 canal简介 canal [kə’næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。 早期阿里巴巴因为杭州
Canal监听MySQL binlog消费实战
htjx99的专栏
10-14 735
Canal mysql binlog 消费
基于canal监听MySQL binlog实现数据增量同步
weixin_43975276的博客
04-27 1689
canal的数据增量同步底层就是利用MySQL的主从同步机制实现的。将canal伪装成master的一个slave节点，向master节点发起dump协议，master节点在接收到dump协议之后，就会将binlog日志推送给canal，canal拿到binlog日志之后执行相应的操作从而实现数据同步。
Canal数据库监听
Zxb654614425的博客
02-16 2619
canal
canal监听binlog
04-16
Canal是一个开源的数据库复制和实时数据订阅系统，它可以监听MySQL或者MariaDB的binlog日志，并将变更数据传递给下游应用。通过监听binlog，Canal可以实时获取数据库的变更信息，包括插入、更新、删除等操作。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值