关于缓存一致性和使用canal来解决的方案

在日常的项目开发中，有时候会遇到一些数据会进行缓存的情况，但同时数据库层面也会做相关的操作。原则上，对于一些实时性要求很高的数据，是不建议缓存的，这个意义是不大的。然后对于某些数据不管是先更新数据库再更新缓存，或者是先删缓存再更新数据库，都是有可能做到数据不一致的。为了达到最终一致性的话，其实大部分场景下，我们给数据加上过期时间就可以解决大部分的日常开发问题。

如果对于数据的一致性要求很高，或者某些业务场景下，的确是要做这些事情的话，可以采用以下方案来解决。具体场景可以按照自己的项目结构进行

方案一：延时双删模式

延时双删的方案的思路是，为了避免更新数据库的时候，其他线程从缓存中读取不到数据，就在更新完数据库之后，再sleep一段时间，然后再次删除缓存。

sleep的时间要对业务读写缓存的时间做出评估，sleep时间大于读写缓存的时间即可。

流程如下：

1. 线程1删除缓存，然后去更新数据库
2. 线程2来读缓存，发现缓存已经被删除，所以直接从数据库中读取，这时候由于线程1还没有更新完成，所以读到的是旧值，然后把旧值写入缓存
3. 线程1，根据估算的时间，可以设置1s的sleep，由于sleep的时间大于线程2读数据+写缓存的时间，所以缓存被再次删除
4. 如果还有其他线程来读取缓存的话，就会再次从数据库中读取到最新值
   
   注意：
   1、针对上面的情形，休眠时间应该自行评估自己的项目的读数据业务逻辑的耗时。然后写数据的休眠时间则在读数据业务逻辑的耗时基础上，加几百ms即可。这么做的目的，就是确保读请求结束，写请求可以删除读请求造成的缓存脏数据。
   2、如果mysql采用了主从模式的话，还要考虑到主从数据同步的时间，理应在此基础上再多休眠一点时间就好。

方案二：基于canal来解决

假设一种比较理想的情况，就是我们对mysql做相关操作的时候，其实在mysql的binlog日志中都有对相关数据操作的记录。那可以设置一个队binlog的监听，然后当监听到某些表或者某些库的时候，如果有我们想要的操作发生，及时对redis进行操作。这样做就跨过了代码实现的层面，就不用去考虑网络延时或者服务器卡顿情况导致数据更新并不一致的问题。

  canal介绍
 
canal 主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。
早期阿里巴巴因为杭州和美国双机房部署，存在跨机房同步的业务需求，实现方式主要是基于业务 trigger 获取增量变更。从 2010 年开始，业务逐步尝试数据库日志解析获取增量变更进行同步，由此衍生出了大量的数据库增量订阅和消费业务。

基于日志增量订阅和消费的业务包括：

1. 数据库镜像
2. 数据库实时备份
3. 索引构建和实时维护(拆分异构索引、倒排索引等)
4. 业务 cache 刷新
5. 带业务逻辑的增量数据处理

 当前的 canal 支持源端 MySQL 版本包括 5.1.x , 5.5.x , 5.6.x , 5.7.x , 8.0.x
文档地址:  https://github.com/alibaba/canal 

 1） canal服务端以mysql主从复制的形式获取master的binlog文件
 2） canal服务端解析binglog文件，并将其发送客户端
 3） 客户端获取服务端发送的数据后，直接更新redis数据库
 重点: 将canal当成mysql的slave，就类似于主从的理解就好一点理解透了
 

•   环境搭建
   

1. 配置mysql数据库
   1) 开启mysql的主从复制, 保存后，重启mysq 

   编辑mysql的my.ini文件，linux修改my.cnf文件
   #####################新增以下配置##############
   log-bin=mysql-bin #开启bin-long文件
   binlog-format=ROW #选择row模式 
   server_id=1 #服务id(自定义)，唯一不能重复
   

2. 查看是否配置成功 
        使用navicat连接测试:    show variables like 'log_bin';   ON表示开启成功
3.  安装canal
    1)  下载canal    https://github.com/alibaba/canal/releases 
   
   下载后，直接在本地解压      如: linux命令: tar -zxvf canal.deployer-1.1.4.tar.gz 

2)   配置canal
  编辑conf/example/instance.properties
 

// 修改mysql数据库的连接地址
canal.instance.master.address=127.0.0.1:3306
// 修改mysql的账号和密码
canal.instance.dbUsername=canal
canal.instance.dbPassword=canal
// 表示对mysql所有的表进行监听  实际项目中需要指定监听的库和表名
canal.instance.filter.regex=.*\\..*

3)   启动
      启动bin/startup.bat，查看 logs/example/example.log日志是否启动成功

      若启动报错参考:  https://gitmemory.com/issue/alibaba/canal/2152/528270051 
 

• 项目整合
   

1. 创建项目  
    pom.xml引入依赖：

     <dependencies>
    
       <dependency>
         <groupId>com.alibaba.otter</groupId>
         <artifactId>canal.client</artifactId>
         <version>1.1.0</version>
       </dependency>
    
       <dependency>
         <groupId>redis.clients</groupId>
         <artifactId>jedis</artifactId>
         <version>2.9.0</version>
       </dependency>
     </dependencies>

   2. redis连接工具类

   RedisUtil.java

import redis.clients.jedis.Jedis;
 
public class RedisUtil {
 
    private static Jedis jedis = null;
 
    public static synchronized Jedis getJedis() {
        if (jedis == null) {
            jedis = new Jedis("127.0.0.1", 6379);
        }
        return jedis;
    }
 
    public static boolean existKey(String key) {
        return getJedis().exists(key);
    }
 
    public static void delKey(String key) {
        getJedis().del(key);
    }
 
    public static String stringGet(String key) {
        return getJedis().get(key);
    }
 
    public static String stringSet(String key, String value) {
        return getJedis().set(key, value);
    }
 
    public static void hashSet(String key, String field, String value) {
        getJedis().hset(key, field, value);
    }
}

   3.Cancal客户端连接工具类

import com.alibaba.fastjson.JSONObject;
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;
 
 
public class CanalClient {
 
    public static void main(String args[]) {
        // 连接我们的CanalServer端
        CanalConnector connector = CanalConnectors.newSingleConnector(new
                InetSocketAddress("127.0.0.1",
                11111), "example", "", "");
        int batchSize = 100;
        try {
            connector.connect();
            // 表示监听2020_order库下的tbl_order表   2020_order.*表示监听该库下所有表
            connector.subscribe("2020_order.tbl_order");
            connector.rollback();
            while (true) {
                // 获取指定数量的数据
                Message message = connector.getWithoutAck(batchSize);
                long batchId = message.getId();
                int size = message.getEntries().size();
//                System.out.println("batchId = " + batchId);
//                System.out.println("size = " + size);
                if (batchId == -1 || size == 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    printEntry(message.getEntries());
                }
                // 提交确认
                connector.ack(batchId);
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }
        } finally {
            connector.disconnect();
        }
    }
 
    private static void printEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
                continue;
            }
            RowChange rowChage = null;
            try {
                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.DELETE) {
                    redisDelete(rowData.getBeforeColumnsList());
                } else if (eventType == EventType.INSERT) {
                    redisInsert(rowData.getAfterColumnsList());
                } else {
                    System.out.println("-------> before");
                    printColumn(rowData.getBeforeColumnsList());
                    System.out.println("-------> after");
                    redisUpdate(rowData.getAfterColumnsList());
                }
            }
        }
    }
 
    private static void printColumn(List<Column> columns) {
        for (Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
        }
    }
 
    private static void redisInsert(List<Column> columns) {
        JSONObject json = new JSONObject();
        for (Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            RedisUtil.stringSet(columns.get(0).getValue(), json.toJSONString());
        }
    }
 
    private static void redisUpdate(List<Column> columns) {
        JSONObject json = new JSONObject();
        for (Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            RedisUtil.stringSet(""+columns.get(0).getValue(), json.toJSONString());
        }
    }
 
    private static void redisDelete(List<Column> columns) {
        JSONObject json = new JSONObject();
        for (Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            RedisUtil.delKey(columns.get(0).getValue());
        }
    }
}

4.启动main()方法  
 测试：直接修改2020_order库下tbl_order表的数据
 查看控制台 ，查看redis的数据
 
  总结

1） canal服务端以mysql主从复制的形式监听mysql的数据表的变化，然后将监听的数据发送给canal客户端
2） 通过CanalClien.java代码分析，canal客户端以while死循环的方式实时获取canal发送的数据
3） canal客户端获取数据后，以其中一列作为redis的key来添加/更新同步数据 
注意: 第3)步只是官方demo给的例子，canal客户端获取数据后的具体业务代码得自己去写。 

 canal高可用机制 

•  canal宕机
   如果canal宕机的话，再次启动canal，canal也会将在宕机过程中的操作的mysql数据，一样同步给客户端。
• 客户端宕机 
  如果客户端宕机的话，再次启动客户端，canal也会将在宕机过程中的操作的mysql数据，一样同步给客户端。
  
  除此之外我们也可以模仿这种监听模式，采用mq来做，只是个人觉得那样子的话，代码层面就没有必要了。