Docker安装canal、mysql进行简单测试与实现redis和mysql缓存一致性 ...

一、简介

canal [kə'næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。
早期阿里巴巴因为杭州和美国双机房部署，存在跨机房同步的业务需求，实现方式主要是基于业务 trigger 获取增量变更。从 2010 年开始，业务逐步尝试数据库日志解析获取增量变更进行同步，由此衍生出了大量的数据库增量订阅和消费业务。
Canal 是用 Java 开发的基于数据库增量日志解析，提供增量数据订阅&消费的中间件。
目前，Canal 主要支持了 MySQL 的 Binlog 解析，解析完成后才利用 Canal Client 来处理获得
的相关数据。（数据库同步需要阿里的 Otter 中间件，基于 Canal）。
当前的 canal 支持源端 MySQL 版本包括 5.1.x , 5.5.x , 5.6.x , 5.7.x , 8.0.x。
canal github地址

二、MySQL 的 Binlog

1. Binlog介绍

MySQL 的二进制日志可以说 MySQL 最重要的日志了，它记录了所有的 DDL 和 DML(除
了数据查询语句)语句，以事件形式记录，还包含语句所执行的消耗的时间，MySQL 的二进 制日志是事务安全型的。
一般来说开启二进制日志大概会有 1%的性能损耗。二进制有两个最重要的使用场景：

• MySQL Replication 在 Master 端开启 Binlog，Master 把它的二进制日志传递给 Slaves
  来达到 Master-Slave 数据一致的目的，这就是我们常用的主从复制。
  
• 就是数据恢复了，通过使用 MySQL Binlog 工具来使恢复数据，生产上要开启，不然真的要删库跑路了 。
  

2. Binlog 的分类

MySQL Binlog 的格式有三种，分别是 STATEMENT,MIXED,ROW。在配置文件中可以选择配
置 binlog_format= statement|mixed|row。

• statement：语句级，binlog 会记录每次一执行写操作的语句。比如
  update user set create_date=now()
  优点：节省空间。
  缺点：有可能造成数据不一致。
  
• row：行级， binlog 会记录每次操作后每行记录的变化。
  优点：保持数据的绝对一致性
  缺点：占用较大空间
  
• mixed：statement 的升级版，一定程度上解决了，因为一些情况而造成的 statement
  模式不一致问题，默认还是 statement，一些会产生不一致的情况还是会选择row。
  

综合对比
Canal 想做监控分析，选择 row 格式比较合适。
三、工作原理

1.  MySQL主备复制原理

• MySQL master 将数据变更写入二进制日志( binary log, 其中记录叫做二进制日志事件binary log events，可以通过 show binlog events 进行查看)
  
• MySQL slave 将 master 的 binary log events 拷贝到它的中继日志(relay log)
  
• MySQL slave 重放 relay log 中事件，将数据变更反映它自己的数据
  
  

2. canal 工作原理

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

总结：
我们可以把canal理解为从机，拿到数据然后进行后续操作，可以同步到redis上，再也不需要进行延迟双删来保证mysql和redis的数据一致性了，而且还不会出现各种各样的问题！
四、canal使用场景

场景一： 阿里 Otter 中间件的一部分
Otter 是阿里用于进行异地数据库之间的同步框架，Canal 是其中一部分。
otter github地址

场景二：保证缓存和数据库一致性（我们今天要测试的）

场景三：实时数据分析
抓取业务表的新增变化数据，用于制作实时统计
五、安装mysql、redis

1. 安装mysql

1. sudo docker run -p 3306:3306 --name mysql \
2. -v /mydata/mysql/log:/var/log/mysql \
3. -v /mydata/mysql/data:/var/lib/mysql \
4. -v /mydata/mysql/conf:/etc/mysql \
5. -e MYSQL_ROOT_PASSWORD=root \
6. -d mysql:5.7

复制代码

2. Docker配置MySQL

1. vim /mydata/mysql/conf/my.cnf # 创建并进入编辑

复制代码

添加如下配置：

1. [client]
2. default-character-set=utf8
3. [mysql]
4. default-character-set=utf8
5. [mysqld]
6. init_connect='SET collation_connection = utf8_unicode_ci'
7. init_connect='SET NAMES utf8'
8. character-set-server=utf8
9. collation-server=utf8_unicode_ci
10. skip-character-set-client-handshake
11. skip-name-resolve
12. # 开启binlog日志：目录为docker里的目录
13. log-bin=/var/lib/mysql/mysql-bin
14. # server_id 需保证唯一，不能和 canal 的 slaveId 重复
15. server-id=123456
16. binlog_format=row
17. # test数据库开启，不设置则所有库开启
18. binlog-do-db=test

复制代码

3. 重新启动mysql

1. docker restart mysql

复制代码

4. 创建用户并赋权限

查看mysql的 id：

1. docker ps

复制代码

进入docker容器：

1. docker exec -it 7d /bin/bash

复制代码

连接到mysql：

1. mysql -u root -p

复制代码

创建用户并赋予权限：

1. GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%' IDENTIFIED BY 'canal' ;

复制代码

刷新：

1. flush privileges;

复制代码

5. Win10连接mysql创建user表

1. CREATE TABLE `user`  (
2.   `id` int(10) NOT NULL AUTO_INCREMENT,
3.   `name` varchar(25) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
4.   `sex` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
5.   PRIMARY KEY (`id`) USING BTREE
6. ) ENGINE = InnoDB AUTO_INCREMENT = 8 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
8. SET FOREIGN_KEY_CHECKS = 1;

复制代码

6. 创建redis

1. docker run -p 6379:6379 --name redis \
2. -v /mydata/redis/data:/data \
3. -v /mydata/redis/conf/redis.conf:/etc/redis/redis.conf \
4. -d redis redis-server /etc/redis/redis.conf

复制代码

六、安装canal

1. 启动容器

1. docker run -it --name canal -p 11111:11111 -d canal/canal-server:v1.1.5

复制代码

查看三个容器：

1. docker ps

复制代码

2. 配置canal

进入容器：

1. docker exec -it 56 /bin/bash

复制代码

切换目录：

1. cd canal-server/conf/example

复制代码

修改两个地方：
第一个是mysql的地址，第二个是我们创建数据库名字（可以使用默认带的，就是全部的库都进行收集binlog日志）

1. canal.instance.master.address=192.168.84.138:3306
3. canal.instance.filter.regex=test\..*

复制代码

3. 查看日志

我们查看一下canal的日志，看是否启动成功！
首先进入容器：

1. docker exec -it 56 /bin/bash

复制代码

切换目录：

1. cd canal-server/logs/example/

复制代码

查看日志：

1. cat example.log

复制代码

无报错，刚刚新建的表这里也可以检测到！

4. 查看canal.properties

1. cd /canal-server/conf

复制代码

1. cat canal.properties

复制代码

我们可以看到有很多个模式，可以把canal收集到的binlog发送到三大MQ中，或者tcp。
本次以tcp为准测试，如果大家有需求可以进行发送到MQ，往下滑都有对应的配置！

七、简单测试

1. 新建springboot项目，导入依赖

1. <dependency>
2.     <groupId>org.springframework.boot</groupId>
3.     <artifactId>spring-boot-starter</artifactId>
4. </dependency>
5. <dependency>
6.     <groupId>org.springframework.boot</groupId>
7.     <artifactId>spring-boot-starter-test</artifactId>
8.     <scope>test</scope>
9.     <exclusions>
10.         <exclusion>
11.             <groupId>org.junit.vintage</groupId>
12.             <artifactId>junit-vintage-engine</artifactId>
13.         </exclusion>
14.     </exclusions>
15. </dependency>
16. <dependency>
17.     <groupId>com.alibaba.otter</groupId>
18.     <artifactId>canal.client</artifactId>
19.     <version>1.1.0</version>
20. </dependency>
21. <dependency>
22.    <groupId>org.springframework.boot</groupId>
23.    <artifactId>spring-boot-starter-data-redis</artifactId>
24. </dependency>
25. <dependency>
26.     <groupId>com.fasterxml.jackson.core</groupId>
27.     <artifactId>jackson-core</artifactId>
28.     <version>2.8.6</version>
29. </dependency>
30. <dependency>
31.     <groupId>com.fasterxml.jackson.module</groupId>
32.     <artifactId>jackson-module-jaxb-annotations</artifactId>
33.     <version>2.8.6</version>
34. </dependency>

复制代码

2. 编写测试文件

来自官方例子：
我把statis关键字删除了，方便和redis进行整合
例子地址

1. import com.alibaba.otter.canal.client.CanalConnector;
2. import com.alibaba.otter.canal.protocol.Message;
3. import com.alibaba.otter.canal.protocol.CanalEntry.Column;
4. import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
5. import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
6. import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
7. import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
8. import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
9. import com.alibaba.otter.canal.client.*;
10. import org.springframework.context.annotation.Bean;
11. import org.springframework.context.annotation.Configuration;
14. /**
15. * @author wangzhenjun
16. * @date 2022/6/29 9:31
17. */
18. @Configuration
19. public class SimpleCanalClientExample {
21. //    private static String REDIS_DATABASE = "mall";
22. //    private static String REDIS_KEY_ADMIN = "ums:admin";
24.     @Bean
25.     public void canalSync() {
26.         // 创建链接,第一个参数是canal的ip，第二个参数是canal的端口号，
27.         // 第三个参数是canal虚拟的模块名称，canal是创建的数据库账号密码
28.         CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.84.138",
29.                 11111), "example", "canal", "canal");
30.         int batchSize = 1000;
31.         int emptyCount = 0;
32.         try {
33.             connector.connect();
34.             // 对应上面的配置只对test库进行获取binlog文件
35.             connector.subscribe("test\\..*");
36.             connector.rollback();
37.             int totalEmptyCount = 120;
38.             while (emptyCount < totalEmptyCount) {
39.                 Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
40.                 long batchId = message.getId();
41.                 int size = message.getEntries().size();
42.                 if (batchId == -1 || size == 0) {
43.                     emptyCount++;
44.                     System.out.println("empty count : " + emptyCount);
45.                     try {
46.                         Thread.sleep(1000);
47.                     } catch (InterruptedException e) {
48.                     }
49.                 } else {
50.                     emptyCount = 0;
51.                     // System.out.printf("message[batchId=%s,size=%s] \n", batchId, size);
52.                     printEntry(message.getEntries());
53.                 }
55.                 connector.ack(batchId); // 提交确认
56.                 // connector.rollback(batchId); // 处理失败, 回滚数据
57.             }
59.             System.out.println("empty too many times, exit");
60.         } finally {
61.             connector.disconnect();
62.         }
63.     }
65.     private void printEntry(List<Entry> entrys) {
66.         for (Entry entry : entrys) {
67.             if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
68.                 continue;
69.             }
71.             RowChange rowChage = null;
72.             try {
73.                 rowChage = RowChange.parseFrom(entry.getStoreValue());
74.             } catch (Exception e) {
75.                 throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
76.                         e);
77.             }
79.             EventType eventType = rowChage.getEventType();
80.             System.out.println(String.format("================> binlog[%s:%s] , name[%s,%s] , eventType : %s",
81.                     entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
82.                     entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
83.                     eventType));
85.             for (RowData rowData : rowChage.getRowDatasList()) {
86.                 if (eventType == EventType.DELETE) {
87.                     printColumn(rowData.getBeforeColumnsList());
88.                 } else if (eventType == EventType.INSERT) {
89.                     printColumn(rowData.getAfterColumnsList());
90.                 } else {
91.                     System.out.println("-------> before");
92.                     printColumn(rowData.getBeforeColumnsList());
93.                     System.out.println("-------> after");
94.                     printColumn(rowData.getAfterColumnsList());
95.                 }
96.             }
97.         }
98.     }
99.        
100.     private void printColumn(List<Column> columns) {
101.         for (Column column : columns) {
102.             System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
103.         }
104.     }
105. }

复制代码

3. 启动项目


4. 插入一条数据

1. INSERT INTO user VALUES (1,'小红','女');

复制代码

总结：
我们测试是可以获取到binlog日志的，下面我们进入实战：实现redis缓存同步
八、实战redis同步缓存

1. 编写redis序列化配置类

1. import org.springframework.context.annotation.Bean;
2. import org.springframework.context.annotation.Configuration;
3. import org.springframework.data.redis.connection.RedisConnectionFactory;
4. import org.springframework.data.redis.core.RedisTemplate;
5. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
6. import org.springframework.data.redis.serializer.StringRedisSerializer;
8. /**
9. * @author wangzhenjun
10. * @date 2022/6/30 9:24
11. */
12. @Configuration
13. public class RedisConfig {
15.     @Bean
16.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
17.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
18.         redisTemplate.setConnectionFactory(connectionFactory);
19.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
20.         redisTemplate.setKeySerializer(stringRedisSerializer);
21.         redisTemplate.setHashKeySerializer(stringRedisSerializer);
22.         Jackson2JsonRedisSerializer<?> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
23.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
24.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
25.         redisTemplate.afterPropertiesSet();
26.         return redisTemplate;
27.     }
29. }

复制代码

2. 添加redis增删改方法

主要添加了同步到redis的两个方法，这里是2分钟就会停止监听，大家可以按自己的来调整：

1. int totalEmptyCount = 120;

复制代码

1. import java.net.InetSocketAddress;
2. import java.util.List;
4. import com.alibaba.fastjson.JSONObject;
5. import com.alibaba.otter.canal.client.CanalConnector;
6. import com.alibaba.otter.canal.protocol.Message;
7. import com.alibaba.otter.canal.protocol.CanalEntry.Column;
8. import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
9. import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
10. import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
11. import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
12. import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
13. import com.alibaba.otter.canal.client.*;
14. import org.springframework.beans.factory.annotation.Autowired;
15. import org.springframework.context.annotation.Bean;
16. import org.springframework.context.annotation.Configuration;
17. import org.springframework.data.redis.core.RedisTemplate;
20. /**
21. * @author wangzhenjun
22. * @date 2022/6/29 9:31
23. */
24. @Configuration
25. public class SimpleCanalClientExample {
27.     @Autowired
28.     private RedisTemplate redisTemplate;
30.     private static final String KEY = "user:info";
32.     @Bean
33.     public void canalSync() {
34.         // 创建链接,第一个参数是canal的ip，第二个参数是canal的端口号，
35.         // 第三个参数是canal虚拟的模块名称，canal是创建的数据库账号密码
36.         CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.84.138",
37.                 11111), "example", "canal", "canal");
38.         int batchSize = 1000;
39.         int emptyCount = 0;
40.         try {
41.             connector.connect();
42.             // 对应上面的配置只对test库进行获取binlog文件
43.             connector.subscribe("test\\..*");
44.             connector.rollback();
45.             int totalEmptyCount = 120;
46.             while (emptyCount < totalEmptyCount) {
47.                 Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
48.                 long batchId = message.getId();
49.                 int size = message.getEntries().size();
50.                 if (batchId == -1 || size == 0) {
51.                     emptyCount++;
52.                     System.out.println("empty count : " + emptyCount);
53.                     try {
54.                         Thread.sleep(1000);
55.                     } catch (InterruptedException e) {
56.                     }
57.                 } else {
58.                     emptyCount = 0;
59.                     // System.out.printf("message[batchId=%s,size=%s] \n", batchId, size);
60.                     printEntry(message.getEntries());
61.                 }
63.                 connector.ack(batchId); // 提交确认
64.                 // connector.rollback(batchId); // 处理失败, 回滚数据
65.             }
67.             System.out.println("empty too many times, exit");
68.         } finally {
69.             connector.disconnect();
70.         }
71.     }
73.     private void printEntry(List<Entry> entrys) {
74.         for (Entry entry : entrys) {
75.             if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
76.                 continue;
77.             }
79.             RowChange rowChage = null;
80.             try {
81.                 rowChage = RowChange.parseFrom(entry.getStoreValue());
82.             } catch (Exception e) {
83.                 throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(),
84.                         e);
85.             }
87.             EventType eventType = rowChage.getEventType();
88.             System.out.println(String.format("================> binlog[%s:%s] , name[%s,%s] , eventType : %s",
89.                     entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
90.                     entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
91.                     eventType));
93.             for (RowData rowData : rowChage.getRowDatasList()) {
94.                 if (eventType == EventType.DELETE) {
95.                     printColumn(rowData.getBeforeColumnsList());
96.                     // 同步到redis
97.                     delete(rowData.getBeforeColumnsList());
98.                 } else if (eventType == EventType.INSERT) {
99.                     printColumn(rowData.getAfterColumnsList());
100.                     // 同步到redis
101.                     insertOrUpdate(rowData.getAfterColumnsList());
102.                 } else {
103.                     System.out.println("-------> before");
104.                     printColumn(rowData.getBeforeColumnsList());
105.                     System.out.println("-------> after");
106.                     printColumn(rowData.getAfterColumnsList());
107.                     // 同步到redis
108.                     insertOrUpdate(rowData.getAfterColumnsList());
109.                 }
110.             }
111.         }
112.     }
114.     private void printColumn(List<Column> columns) {
115.         for (Column column : columns) {
116.             System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
117.         }
118.     }
120.     /**
121.      * 更新或者添加触发同步到redis
122.      * @param columns
123.      */
124.     private void insertOrUpdate (List<Column> columns) {
125.         if (columns.size() > 0) {
126.             JSONObject json = new JSONObject();
127.             for (Column column : columns) {
128.                 json.put(column.getName(), column.getValue());
129.             }
130.             redisTemplate.opsForHash().put(KEY,columns.get(0).getValue(),json.toJSONString());
131.         }
132.     }
134.     /**
135.      * 删除触发同步到redis
136.      * @param columns
137.      */
138.     private void delete (List<Column> columns) {
139.         if (columns.size() > 0) {
140.             redisTemplate.opsForHash().delete(KEY, columns.get(0).getValue());
141.         }
142.         
143.     }
144. }

复制代码

3. 测试添加

数据库插入一条：

1. insert into user values (1,'我是测试添加','男');

复制代码

控制台捕捉到信息：

我们看到redis已经有数据了，同步成功！

4. 测试更新

更细我们刚刚添加的那条数据：

1. update user set name = '修改了' where id = 1;

复制代码

控制台捕捉到了更新信息：

redis也同步修改了！

5. 测试删除

我们先多添加几条哈：

删除id为1的那条数据：

1. delete from user where id = 1;

复制代码

控制台捕捉到了删除信息：

redis也同步删除了！

九、总结

这样就实现了一个canal的应用场景，当然也可以把binlog的数据发送到MQ来！
小编整理了一天，看到这里给小编点个关注呗，谢谢大家的支持哦！！
有缘人才可以看得到的哦！！！点击访问！小编自己的网站，里面也是有很多好的文章哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！