安装Canal1.1.5 并监控mysql8的binlog

创建canal用户

这只是为了安全，只让这个用户有读数据库的权限

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

#将用户root的host修改为%实现IP登录 update user set host = '%' where user ='canal';

#刷新权限数据表

flush privileges;

查看是不是开启了bin

show variables like 'log_bin';

先查下镜像版本： Docker Hub

拉取镜像

docker pull canal/canal-server:v1.1.6

启动镜像

docker run --name canal -d canal/canal-server:v1.1.5

进docker 查看文件： docker exec -it 370cd2adf99c /bin/bash

对照是否有下面要拷贝的目录：/home/admin/canal-server/conf/

查看docker 里的日志 tail -100f /home/admin/canal-server/logs/example/example.log

将容器内部配置文件拷贝到外部

docker cp [容器索引]:[内部路径] [外部路径]

docker cp canal:/home/admin/canal-server/conf/canal.properties /usr/local/canal docker cp canal:/home/admin/canal-server/conf/example/instance.properties /usr/local/canal/example

修改：instance.properties

关闭移除容器

#关闭容器 docker stop canal

#移除容器 docker rm canal

#启动新的 这里-v是将外部的文件挂载到容器内部 这样就不用每次启动都要配置参数了

docker run --restart=always --name canal -p 11111:11111 -d -v /usr/local/canal/example/instance.properties:/home/admin/canal-server/conf/example/instance.properties -v /usr/local/canal/canal.properties:/home/admin/canal-server/conf/canal.properties canal/canal-server:v1.1.5

为什么没有取到数据：

查所有表

这样才是对的。

不知道为什么用本地mysql8可以，用112上的mysql8就不行。

多mysql

注意

当启动两个一样的Test单元测试， 当修改数据库测试，同一时间只会有一个程序会接受数据，不会两个程序同时接受数据，所以可以分布式部署来监控bin_log， 经测试，基本上是轮训。

代码

 
		<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>
		<dependency>
			<groupId>com.alibaba.otter</groupId>
			<artifactId>canal.common</artifactId>
			<version>1.1.6</version>
		</dependency>

package com.lm.demo.test;
 
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 org.junit.Test;
 
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 CanalClientApiTest {
 
 
    @Test
    public  void test2( ) {
        test();
 
    }
    @Test
    public  void test( ) {
 
        String destination = "example";
        // 创建一个 canal 链接
        CanalConnector canalConnector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.112.112", 11111), destination, "admin", "4ACFE3202A5FF5CF467898FC58AAB1D615029441");
        // 链接对应的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");
        canalConnector.subscribe(".*\\..*"); //test库下所有表
        // 回滚到未进行 #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());
        }
    }
}