資料庫系列——基於Canal實現MySQL增量資料同步

環境準備：

1、redis （預設埠6379）

2、zookeeper （預設埠2181）

3、Kafka （預設埠9092）

4、Canal （預設埠 11111）

5、MySQL （預設埠 3306

Canal介紹：引用官方介紹

---

canal 是阿里巴巴 MySQL 資料庫 Binlog 的增量訂閱&消費元件。

名稱：canal [kə'næl]
譯意： 水道/管道/溝渠
語言： 純java開發
定位： 基於資料庫增量日誌解析，提供增量資料訂閱&消費，目前主要支援了MySQL

早期，阿里巴巴 B2B 公司因為存在杭州和美國雙機房部署，存在跨機房同步的業務需求。不過早期的資料庫同步業務，主要是基於 trigger 的方式獲取增量 變更，不過從 2010 年開始，阿里系公司開始逐步的嘗試基於資料庫的日誌解析，獲取增量變更進行同步，由此衍生出了增量訂閱&消費的業務，從此開 啟了一段新紀元。ps. 目前內部使用的同步，已經支援 MySQL 8.x 和 Oracle 部分版本的日誌解析

基於日誌增量訂閱&消費支援的業務：

1. 資料庫映象

2. 資料庫實時備份

3. 多級索引 (賣家和買家各自分庫索引)

4. search build （elastic search）

5. 業務cache重新整理（redis）

6. 價格變化等重要業務訊息

Canal 工作原理：

原理相對比較簡單：

1. canal模擬mysql slave的互動協議，偽裝自己為mysql slave，向mysql master傳送dump協議

2. mysql master收到dump請求，開始推送binary log給slave(也就是canal)

3. canal解析binary log物件(原始為byte流)

以上為官方介紹

---

 實現專案開發中如何使用呢？

實際專案我們是配置MQ模式，配合RocketMQ或者Kafka，canal會把資料傳送到MQ的topic中，然後通過訊息佇列的消費者進行消費處理。

這篇文章演示部署Canal，配合使用Kafka，同步資料到Redis

通過架構圖，我們很清晰就知道要用到的元件：MySQL、Canal、Kafka、ZooKeeper、Redis

MySQL搭建大家應該都會，ZooKeeper、Redis這些網上也有很多資料參考

主要說下Kafka搭建

首先在官網下載安裝包：
 

解壓，開啟/config/server.properties配置檔案，修改日誌目錄

首先啟動ZooKeeper，我用的是3.4.13版本：

 
接著再啟動Kafka，在Kafka的bin目錄下開啟cmd，輸入命令：

kafka-server-start.bat ../../config/server.properties

我們可以通過ZooInspector看到ZooKeeper上註冊了Kafka相關的配置資訊：

 

然後需要建立一個佇列，用於接收canal傳送過來的資料，使用命令：

 

kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic canaltopic

 建立的佇列名是canaltopic。

配置Cannal Server

canal官網下載相關安裝包：

 

找到canal.deployer-1.1.4/conf目錄下的canal.properties配置檔案：

# tcp, kafka, RocketMQ 這裡選擇kafka模式
canal.serverMode = kafka
# 解析器的執行緒數，開啟此配置，不開啟則會出現阻塞或者不進行解析的情況
canal.instance.parser.parallelThreadSize = 16
# 配置MQ的服務地址，這裡配置的是kafka對應的地址和埠
canal.mq.servers = 127.0.0.1:9092
# 配置instance，在conf目錄下要有example同名的目錄，可以配置多個
canal.destinations = example

然後配置instance，找到/conf/example/instance.properties配置檔案：

## mysql serverId , v1.0.26+ will autoGen(自動生成，不需配置)
# canal.instance.mysql.slaveId=0

# position info
canal.instance.master.address=127.0.0.1:3306
# 在Mysql執行 SHOW MASTER STATUS;檢視當前資料庫的binlog
canal.instance.master.journal.name=mysql-bin.000006
canal.instance.master.position=4596
# 賬號密碼
canal.instance.dbUsername=canal
canal.instance.dbPassword=Canal@****
canal.instance.connectionCharset = UTF-8
#MQ佇列名稱
canal.mq.topic=canaltopic
#單佇列模式的分割槽下標
canal.mq.partition=0

配置完成後，就可以啟動canal了。

測試驗證

這時可以開啟kafka的消費者視窗，測試一下kafka是否收到訊息。

kafka-console-consumer.bat --bootstrap-server 127.0.0.1:9092 --from-beginning --topic canaltopic

控制檯會出現亂碼的話，需要臨時設定一下編碼

在cmd命令列執行前切換到UTF-8編碼即可，使用命令列：chcp 65001

在MySQL資料庫運算元據，然後觀察Kafka這邊變化情況;

啟動Redis，把資料同步到Redis。

環境都搭建好了以後，下面編寫Redis客戶端程式碼

首先引入Kafka和Redis的maven依賴：

 <dependencies>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.28</version>
            <scope>compile</scope>
        </dependency>
</dependencies>

在application.yml檔案配置：

spring:  
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    password: 123456

編寫操作Redis的工具類：
 

@Component
public class RedisClient {

    /**
     * 獲取redis模版
     */
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 設定redis的key-value
     */
    public void setString(String key, String value) {
        setString(key, value, null);
    }

    /**
     * 設定redis的key-value，帶過期時間
     */
    public void setString(String key, String value, Long timeOut) {
        stringRedisTemplate.opsForValue().set(key, value);
        if (timeOut != null) {
            stringRedisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
        }
    }

    /**
     * 獲取redis中key對應的值
     */
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 刪除redis中key對應的值
     */
    public Boolean deleteKey(String key) {
        return stringRedisTemplate.delete(key);
    }
}

建立MQ消費者進行資料同步

在application.yml配置檔案加上kafka的配置資訊：

spring:
  kafka:
  	# Kafka服務地址
    bootstrap-servers: 127.0.0.1:9092
    consumer:
      # 指定一個預設的組名
      group-id: consumer-group1
      #序列化反序列化
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringDeserializer
      value-serializer: org.apache.kafka.common.serialization.StringDeserializer
      # 批量抓取
      batch-size: 65536
      # 快取容量
      buffer-memory: 524288

可以建立一個CanalBean物件進行接收 

public class CanalBean {
    //資料
    private List<Student> data;
    //資料庫名稱
    private String database;
    private long es;
    //遞增，從1開始
    private int id;
    //是否是DDL語句
    private boolean isDdl;
    //表結構的欄位型別
    private MysqlType mysqlType;
    //UPDATE語句，舊資料
    private String old;
    //主鍵名稱
    private List<String> pkNames;
    //sql語句
    private String sql;
    private SqlType sqlType;
    //表名
    private String table;
    private long ts;
    //(新增)INSERT、(更新)UPDATE、(刪除)DELETE、(刪除表)ERASE等等
    private String type;
    //getter、setter方法
}

public class MysqlType {
    private String id;
    private String commodity_name;
    private String commodity_price;
    private String number;
    private String description;
    //getter、setter方法
}

public class SqlType {
    private int id;
    private int commodity_name;
    private int commodity_price;
    private int number;
    private int description;
}

建立業務測試表對應的Bean用於測試使用

 

@Data // lombok外掛依賴
public class Student implements Serializable {
    private Long id;

    private String name;

    private Integer age;

    private static final long serialVersionUID = 1L;
}

最後就可以建立一個消費者CanalConsumer進行消費

package com.gary.sync.consumer;

import com.alibaba.fastjson.JSONObject;
import com.gary.sync.model.CanalBean;
import com.gary.sync.model.Student;
import com.gary.sync.model.TbCommodityInfo;
import com.gary.sync.redis.RedisClient;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;

@Component
public class CanalConsumer {
    //日誌記錄
    private static Logger log = LoggerFactory.getLogger(CanalConsumer.class);
    //redis操作工具類
    @Resource
    private RedisClient redisClient;
    //監聽的佇列名稱為：canaltopic
    @KafkaListener(topics = "canaltopic")
    public void receive(ConsumerRecord<?, ?> consumer) {
        String value = (String) consumer.value();
        log.info("topic名稱:{},key:{},分割槽位置:{},下標:{},value:{}", consumer.topic(), consumer.key(),consumer.partition(), consumer.offset(), value);
        //轉換為javaBean
        CanalBean canalBean = JSONObject.parseObject(value, CanalBean.class);
        //獲取是否是DDL語句
        boolean isDdl = canalBean.getIsDdl();
        //獲取型別
        String type = canalBean.getType();
        //不是DDL語句
        if (!isDdl) {
            List<Student> students = canalBean.getData();
            //過期時間
            long TIME_OUT = 600L;
            if ("INSERT".equals(type)) {
                //新增語句
                for (Student student : students) {
                    Long id = student.getId();
                    //新增到redis中,過期時間是10分鐘
                    redisClient.setString(String.valueOf(id), JSONObject.toJSONString(student), TIME_OUT);
                }
            } else if ("UPDATE".equals(type)) {
                //更新語句
                for (Student student : students) {
                    Long id = student.getId();
                    //更新到redis中,過期時間是10分鐘
                    redisClient.setString(String.valueOf(id), JSONObject.toJSONString(student), TIME_OUT);
                }
            } else {
                //刪除語句
                for (Student student : students) {
                    Long id = student.getId();
                    //從redis中刪除
                    redisClient.deleteKey(String.valueOf(id));
                }
            }
        }
    }
}

測試MySQL與Redis資料同步

依次啟動-zookeeper-》kafka-》canal-》redis

zookeeper

kafka 

canal 

redis

測試資料準備：

先在MySQL建立表

DROP TABLE IF EXISTS `student`;

CREATE TABLE `student` (
  `id` int NOT NULL,
  `name` varchar(25) DEFAULT NULL,
  `age` int DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

然後啟動專案 

 接著新增一條資料：

INSERT INTO `test`.`student` (`id`, `name`, `age`) 
VALUES
  ('777', '測試', '123') ;

student表查到新增的資料：

Redis也查到了對應的資料，證明同步成功！

 

使用場景：

1. canal只能同步增量資料。

2. 不是實時同步，是準實時同步。

增量同步，實現性不太強的場景