Canal的简单实用

一、背景
二、canal的工作原理
三、安装canal
四、客户端消费canal数据
五、消费的binlog不存在
- 1、单机部署
- 2、集群部署
六、完整代码
七、参考链接

一、背景

工作中有个需求，当数据库的数据变更时，另外一个系统中的数据要能及时感应到，通过调研知道，监听数据库的binlog可以做到一个准实时的通知，而canal主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费，正好满足需求，此处记录一下canal的简单使用。

二、canal的工作原理

步骤：

canal模拟mysql slave的交互协议，伪装自己为mysql slave，向mysql master发送dump协议
mysql master收到dump请求，开始推送binary log给slave(也就是canal)
canal解析binary log对象(原始为byte流)

三、安装canal

1、mysql配置相关

1、检测binlog是否开启

mysql> show variables like 'log_bin';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| log_bin       | ON    |
+---------------+-------+
1 row in set (0.00 sec)

log_bin的值为ON说明打开了。

2、mysql开启binlog

[mysqld]
#binlog日志的基本文件名，需要注意的是启动mysql的用户需要对这个目录(/usr/local/var/mysql/binlog)有写入的权限
log_bin=/usr/local/var/mysql/binlog/mysql-bin
# 配置binlog日志的格式
binlog_format = ROW
# 配置 MySQL replaction 需要定义，不能和 canal 的 slaveId 重复
server-id=1
# 设置中继日志的路径
relay_log=/usr/local/var/mysql/relaylog/mysql-relay

3、创建canal用户

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

2、canal配置相关

1、下载canal

 # 1.下载 deployer
 $ wget https://github.com/alibaba/canal/releases/download/canal-1.1.5/canal.deployer-1.1.5.tar.gz
 # 下载适配器，不是必须的
 $ wget https://github.com/alibaba/canal/releases/download/canal-1.1.5/canal.adapter-1.1.5.tar.gz
 # 下载管理台，不是必须的
 $ wget https://github.com/alibaba/canal/releases/download/canal-1.1.5/canal.admin-1.1.5.tar.gz
 # 下载示例程序
 $ wget https://github.com/alibaba/canal/releases/download/canal-1.1.5/canal.example-1.1.5.tar.gz
 # 2.解压 deployer (解压后的目录要存在)
 tar -zxvf canal.deployer-1.1.5.tar.gz -C /Users/huan/soft/canal/deployer/
 # 3. 查看 conf 目录结构
 $ tree conf
 conf
 ├── canal.properties
 ├── canal_local.properties
 ├── example
 │   └── instance.properties
 ├── logback.xml
 ├── metrics
 │   └── Canal_instances_tmpl.json
 └── spring
    ├── base-instance.xml
    ├── default-instance.xml
    ├── file-instance.xml
    ├── group-instance.xml
    ├── memory-instance.xml
    └── tsdb
        ├── h2-tsdb.xml
        ├── mysql-tsdb.xml
        ├── sql
        │   └── create_table.sql
        └── sql-map
            ├── sqlmap-config.xml
            ├── sqlmap_history.xml
            └── sqlmap_snapshot.xml

2、配置一个instance

instance：一个instance就是一个消息队列，每个instance通道都有各自的一份配置，因为每个mysql的ip，帐号，密码等信息各不相同。

一个canal server可以存在多个instance。

1、复制`conf/example`文件夹

cp -r conf/example conf/customer

customer可以简单理解为此处我需要链接customer数据库，因此命名为这个。

2、修改instance的配置

vim conf/customer/instance.properties

# mysql集群配置中的serverId概念，需要保证和当前mysql集群中id唯一 (v1.1.x版本之后canal会自动生成，不需要手工指定)
# canal.instance.mysql.slaveId=0
# mysql主库链接地址
canal.instance.master.address=127.0.0.1:3306
# mysql主库链接时起始的binlog文件
canal.instance.master.journal.name=
# mysql主库链接时起始的binlog偏移量
canal.instance.master.position=
# mysql主库链接时起始的binlog的时间戳
canal.instance.master.timestamp=
# mysql数据库帐号(此处的用户名和密码为 安装canal#mysql配置相关#创建canal用户 这一步创建的用户名和密码)
canal.instance.dbUsername=canal
# mysql数据库密码
canal.instance.dbPassword=canal
# mysql 数据解析编码
canal.instance.connectionCharset = UTF-8
# mysql 数据解析关注的表，Perl正则表达式，即我们需要关注那些库和那些表的binlog数据，也可以在canal client api中手动覆盖
canal.instance.filter.regex=.*\\..*
# table black regex
# mysql 数据解析表的黑名单，表达式规则见白名单的规则
canal.instance.filter.black.regex=mysql\\.slave_.*

3、instance注意事项

1、配置需要关注那个库和那个表的binlog

修改 instance.properties文件的这个属性canal.instance.filter.regex,规则如下：

所有表：.* or .*\\..*
canal schema下所有表： canal\\…*
canal下的以canal打头的表：canal\\.canal.*
canal schema下的一张表：canal\\.test1
多个规则组合使用：canal\\..*,mysql.test1,mysql.test2 (逗号分隔)

2、mysql链接时的起始位置

canal.instance.master.journal.name + canal.instance.master.position : 精确指定一个binlog位点，进行启动
canal.instance.master.timestamp : 指定一个时间戳，canal会自动遍历mysql binlog，找到对应时间戳的binlog位点后，进行启动
不指定任何信息：默认从当前数据库的位点，进行启动。(show master status)

3、mysql解析关注表定义

标准的Perl正则，注意转义时需要双斜杠：\

4、mysql链接的编码

目前canal版本仅支持一个数据库只有一种编码，如果一个库存在多个编码，需要通过filter.regex配置，将其拆分为多个canal instance，为每个instance指定不同的编码

5、instance.properties配置参考链接：

https://github.com/alibaba/canal/wiki/AdminGuide

3、canal.properties配置相关

vim conf/canal.properties

# canal server绑定的本地IP信息，如果不配置，默认选择一个本机IP进行启动服务
canal.ip = 127.0.0.1
# canal server提供socket服务的端口
canal.port = 1111
# metrics 端口
canal.metrics.pull.port = 11112
# canal 服务的用户名（客户端连接的时候需要这个用户名和密码，也可以不配置）
canal.user = canal
# canal 服务的密码
canal.passwd = 123456
# tcp, kafka, rocketMQ, rabbitMQ（如果我们要将数据发送到kafka中，则此处写kafka，然后配置kafka的配置，此处以tcp演示）
canal.serverMode = tcp
# 当前server上部署的instance列表,此处写 customer ,则和 conf 目录同级下必须要有一个 customer 文件夹，即上一步我们创建的，如果有多个instance说，则以英文的逗号隔开
canal.destinations = customer
# 如果系统是1个cpu，那么需要将这个并行设置成false
canal.instance.parser.parallel = true

注意事项：

1、canal.destinations配置

在canal.properties定义了canal.destinations后，需要在canal.conf.dir对应的目录下建立同名的文件

比如：

canal.destinations = example1,example2

这时需要创建example1和example2两个目录，每个目录里各自有一份instance.properties.

ps. canal自带了一份instance.properties demo，可直接复制conf/example目录进行配置修改

cp -R example example1/
cp -R example example2/

2、canal.auto.scan配置

如果canal.properties未定义instance列表，但开启了canal.auto.scan时

server第一次启动时，会自动扫描conf目录下，将文件名做为instance name，启动对应的instance
server运行过程中，会根据canal.auto.scan.interval定义的频率，进行扫描
1. 发现目录有新增，启动新的instance
2. 发现目录有删除，关闭老的instance
3. 发现对应目录的instance.properties有变化，重启instance

3、参考链接

参考链接：https://github.com/alibaba/canal/wiki/AdminGuide

4、启动canal

1、启动canal

# 启动canal server
sh bin/startup.sh

2、查看日志

# canal查看日志
tail -f -n200 logs/canal/canal.log
# 如果canal启动失败则需要查看此日志
tail -f -n200 logs/canal/canal_stdout.log
# 查看instance日志,由上面的配置可知，我们的instance的名字是customer,所以看这个日志.
tail -f -n200 logs/customer/customer.log

3、jdk版本

启动的时候需要注意一下本地JDK的版本，测试时发现使用jdk11不能启动，使用jdk8可以启动。

四、客户端消费canal数据

1、引入依赖

<dependencies>
  <dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.client</artifactId>
    <version>1.1.5</version>
  </dependency>
  <dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.protocol</artifactId>
    <version>1.1.5</version>
  </dependency>
  <dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.common</artifactId>
    <version>1.1.5</version>
  </dependency>
</dependencies>

2、编写客户端代码

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 java.net.InetSocketAddress;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
 * canal client api 的使用
 * https://github.com/alibaba/canal/wiki/ClientExample
 * 测试过程中发现，如果修改一个sql语句，但是修改的值没有发生变化，则此处不会监控到。
 * 同一个客户端启动多次，只有一个客户端可以获取到数据
 *
 * @author huan.fu 2021/5/31 - 上午10:31
 */
public class CanalClientApi {
    public static void main(String[] args) {
        String destination = "customer";
        // 创建一个 canal 链接
        CanalConnector canalConnector = CanalConnectors.newSingleConnector(new InetSocketAddress("127.0.0.1", 11111), destination, "admin", "admin");
        // 链接对应的canal server
        canalConnector.connect();
        // 订阅那个库的那个表等
        /**
         * 订阅规则
         * 1.  所有表：.*   or  .*\\..*
         * 2.  canal schema下所有表： canal\\..*
         * 3.  canal下的以canal打头的表：canal\\.canal.*
         * 4.  canal schema下的一张表：canal\\.test1
         * 5.  多个规则组合使用：canal\\..*,mysql.test1,mysql.test2 (逗号分隔)
         */
        canalConnector.subscribe("temp_work\\.customer");
        // 回滚到未进行 #ack 的地方，下次fetch的时候，可以从最后一个没有 #ack 的地方开始拿
        canalConnector.rollback();
        int batchSize = 1000;
        while (true) {
            // 获取一批数据，不一定会获取到 batchSize 条
            Message message = canalConnector.getWithoutAck(batchSize);
            // 获取批次id
            long batchId = message.getId();
            // 获取数据
            List<CanalEntry.Entry> entries = message.getEntries();
            if (batchId == -1 || entries.isEmpty()) {
                System.out.println("没有获取到数据");
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                continue;
            }
            for (CanalEntry.Entry entry : entries) {
                if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                    continue;
                }
                CanalEntry.RowChange rowChange;
                try {
                    rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
                } catch (Exception e) {
                    throw new RuntimeException("解析binlog数据出现异常 , data:" + entry.toString(), e);
                }
                CanalEntry.EventType eventType = rowChange.getEventType();
                System.out.println(String.format("================> binlog[%s:%s] , name[%s,%s] , eventType : %s",
                        entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                        entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                        eventType));
                if (eventType == CanalEntry.EventType.QUERY || rowChange.getIsDdl()) {
                    System.out.println("sql => " + rowChange.getSql());
                }
                for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
                    if (eventType == CanalEntry.EventType.DELETE) {
                        printColumn(rowData.getBeforeColumnsList());
                    } else if (eventType == CanalEntry.EventType.INSERT) {
                        printColumn(rowData.getAfterColumnsList());
                    } else {
                        System.out.println("-------> before");
                        printColumn(rowData.getBeforeColumnsList());
                        System.out.println("-------> after");
                        printColumn(rowData.getAfterColumnsList());
                    }
                }
            }
            canalConnector.ack(batchId);
        }
    }
    private static void printColumn(List<CanalEntry.Column> columns) {
        for (CanalEntry.Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }
}

注意️：

经测试，同一个客户端代码，启动多份，模拟多个客户端同时消费，只有一个客户端可以消费数据。

3、测试结果

没有获取到数据
没有获取到数据
================> binlog[mysql-bin.000014:5771] , name[temp_work,customer] , eventType : UPDATE
-------> before
id : 12    update=false
phone : 123    update=false
address : abcdefg    update=false
column_4 :     update=false
-------> after
id : 12    update=false
phone : 123    update=false
address : 数据改变    update=true
column_4 :     update=false
没有获取到数据
没有获取到数据

可以看到获取到了，改变后的数据。

五、消费的binlog不存在

1、单机部署

1、查看数据库中binlog文件的位置

show variables like 'log_bin_basename';

2、找到binlog文件和位置

# 查询 mysql-bin.000026 这个binlog文件，从pos点: 4 开始查起，一共查询查询5条
show binlog events in 'mysql-bin.000026' from 4 limit 5;

3、停止canal-server

4、修改instance下的 instance.properties下的如下配置

# mysql主库链接时起始的binlog文件
canal.instance.master.journal.name=mysql-bin.000026
# mysql主库链接时起始的binlog偏移量
canal.instance.master.position=4
# mysql主库链接时起始的binlog的时间戳
canal.instance.master.timestamp=

5、删除meta.data文件。