Redis：中间件Canal

目录

canal工作原理

canal搭建

mysql配置

mysql授权

canal安装

canal集成

---

目的：当mysql有改动后立即同步反应到redis。

canal主要用于MySQL 数据库增量日志数据的订阅、消费和解析，具有构建数据库镜像、实时备份数据库、索引构建和实时维护、业务cache刷新等功能。

本文中将使用canal来实现将数据库改动同步到redis，整篇包含canal构建、canal工作原理讲解、canal使用方面的内容。

canal工作原理

在了解canal工作原理之前，我们需要先了解MySQL的主从复制是如何实现的：

1. 当 master 主服务器上的数据发生改变时，则将其改变写入二进制事件日志文件Binary log中。
2. salve 从服务器会在一定时间间隔内对 master 主服务器上的二进制日志进行探测，探测其是否发生过改变， 如果探测到 master 主服务器的二进制事件日志发生了改变，则开始一个 I/O Thread 请求 master 二进制事件日志。
3. master 主服务器为每个 I/O Thread 启动一个dump Thread，用于向其发送二进制事件日志。
4. slave 从服务器将接收到的二进制事件日志保存至自己本地的中继日志文件中。
5. salve 从服务器将启动 SQL Thread 从中继日志中读取二进制日志，在本地重放，使得其数据和主服务器保持一致。
6. 最后 I/O Thread 和 SQL Thread 将进入睡眠状态，等待下一次被唤醒。

canal就是将自身伪装成了MySQL的slave机，向MySQL的master发送dump协议请求，然后接收mysql发送过来的binarylog对象。

canal搭建

mysql配置

使用canal之前需要先将mysql中的配置更改一下，使用SHOW VARIABLES LIKE 'log_bin'查询一下binlog有无开启。

结果为on即可，如果未开始，则找到mysql的配置文件my.ini，更改以下属性：

log-bin=mysql-bin #开启 binlog，属性值为文件名称

binlog-format=ROW #选择 ROW 模式

server_id=1 #配置MySQL replaction需要定义，不要和canal的 slaveId重复

mysql授权

在mysql的用户中添加一个canal使用的账户，授予权限以备使用：

DROP USER IF EXISTS 'canal'@'%';

CREATE USER 'canal'@'%' IDENTIFIED BY 'canal'; //创建账号为canal、密码为canal的用户

GRANT ALL PRIVILEGES ON *.* TO 'canal'@'%'; //授权

FLUSH PRIVILEGES;

注意，若使用MySQL8的版本，需要更改密码验证的方式，否则canal无法连接数据库：

ALTER USER 'canal'@'%' IDENTIFIED WITH mysql_native_password BY 'canal';

canal安装

进入canal的github网站Releases · alibaba/canal (github.com)，下载最近的稳定版本：

下载完后解压一下：tar -zxvf canal.deployer-1.1.6.tar.gz

更改conf/example/instance.properties文件中的ip地址和mysql账号：

然后执行bin下的startup.sh脚本：

然后可查看logs/canal/canal.log查看是否运行成功：

logs/canal/canal.log:

 logs/example/example.log:

运行成功。

canal集成

新建一个maven项目，导入依赖：

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

main：

public class RedisCanalClient {
    public static final Integer _60SECONDS = 60;
    
    public static void main(String[] args)
    {
        System.out.println("---------O(∩_∩)O哈哈~ initCanal() main方法-----------");

        //=================================
        // 创建链接canal服务端
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.146.128",
                11111), "example", "", "");
        int batchSize = 1000;
        //空闲空转计数器
        int emptyCount = 0;
        System.out.println("---------------------canal init OK，开始监听mysql变化------");
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
//            connector.subscribe("petstoredb.pets");
            connector.rollback();
            int totalEmptyCount = 10 * _60SECONDS;
            while (emptyCount < totalEmptyCount) {
                System.out.println("我是canal，每秒一次正在监听:"+ UUID.randomUUID().toString());
                Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    emptyCount++;
                    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
                } else {
                    //计数器重新置零
                    emptyCount = 0;
                    printEntry(message.getEntries());
                }
                connector.ack(batchId); // 提交确认
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }
            System.out.println("已经监听了"+totalEmptyCount+"秒，无任何消息，请重启重试......");
        } finally {
            connector.disconnect();
        }
    }
    
    public static void printEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
                continue;
            }

            RowChange rowChage = null;
            try {
                //获取变更的row数据
                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("================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.INSERT) {
                    rowData.getAfterColumnsList().forEach(column->System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated()));
//                    redisInsert(rowData.getAfterColumnsList());
                } else if (eventType == EventType.DELETE) {
                    rowData.getAfterColumnsList().forEach(column->System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated()));
//                    redisDelete(rowData.getBeforeColumnsList());
                } else {//EventType.UPDATE
                    rowData.getAfterColumnsList().forEach(column->System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated()));
//                    redisUpdate(rowData.getAfterColumnsList());
                }
            }
        }
    }
}

当发生数据更改时即可输出更改内容：

connector.subscribe的配置规则：

也可以实现事件函数来更改redis缓存保证数据一致性：

private static void redisInsert(List<Column> columns)
{
    JSONObject jsonObject = new JSONObject();
    for (Column column : columns)
    {
        System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        jsonObject.put(column.getName(),column.getValue());
    }
    if(columns.size() > 0)
    {
        try(Jedis jedis = RedisUtils.getJedis())
        {
            jedis.set(columns.get(0).getValue(),jsonObject.toJSONString());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}


private static void redisDelete(List<Column> columns)
{
    JSONObject jsonObject = new JSONObject();
    for (Column column : columns)
    {
        jsonObject.put(column.getName(),column.getValue());
    }
    if(columns.size() > 0)
    {
        try(Jedis jedis = RedisUtils.getJedis())
        {
            jedis.del(columns.get(0).getValue());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

private static void redisUpdate(List<Column> columns)
{
    JSONObject jsonObject = new JSONObject();
    for (Column column : columns)
    {
        System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        jsonObject.put(column.getName(),column.getValue());
    }
    if(columns.size() > 0)
    {
        try(Jedis jedis = RedisUtils.getJedis())
        {
            jedis.set(columns.get(0).getValue(),jsonObject.toJSONString());
            System.out.println("---------update after: "+jedis.get(columns.get(0).getValue()));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}