利用canal解析本地binlog

背景

前段时间，发现唯一单号重复，由于时间跨度比较大，排除因为并发问题导致。因为唯一单号生成方法是中通通用方案，其他系统没有出问题，方法有Bug的几率较小。故很有可能是逻辑问题导致，想看一下单号的生成轨迹

本地binlog回溯代码展示

1. 需要准备的环境：
   1.1 本地安装mysql，并创建监听binlog里的表结构（解析需要其表结构数据）
2. 测试代码如下

   package com.zhangjie.intl.test;
   
   import com.alibaba.otter.canal.filter.aviater.AviaterRegexFilter;
   import com.alibaba.otter.canal.parse.inbound.mysql.LocalBinlogEventParser;
   import com.alibaba.otter.canal.parse.index.AbstractLogPositionManager;
   import com.alibaba.otter.canal.parse.support.AuthenticationInfo;
   import com.alibaba.otter.canal.protocol.CanalEntry;
   import com.alibaba.otter.canal.protocol.position.EntryPosition;
   import com.alibaba.otter.canal.protocol.position.LogPosition;
   import com.alibaba.otter.canal.sink.exception.CanalSinkException;
   import com.zto.intl.log.logger.DataChangeLogger;
   import com.zto.intl.log.utils.LogUtil;
   import com.zto.titans.common.util.JsonUtil;
   import org.apache.rocketmq.logging.InternalLogger;
   import org.junit.Test;
   
   import java.net.InetSocketAddress;
   import java.util.LinkedHashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.concurrent.CountDownLatch;
   
   /**
    * @ClassName LocalBinlogEventParserTest
    * @Description: 本地Binlog回溯
    * @author: zhangjie
    * @Date: 2021/12/12 10:21
    **/
   public class LocalBinlogEventParserTest {
      //自定义日志输出（可以替换log4j输出）
       private final InternalLogger dataChangeLog = DataChangeLogger.getLog("express");
       private static final String MYSQL_ADDRESS = "127.0.0.1";
       private static final String USERNAME      = "canal";
       private static final String PASSWORD      = "canal";
       // 需要提前在该目录放好binlog文件
       private static final String directory = "C:\\project\\canal\\parse\\src\\test\\resources\\binlogs";
   
       @Test
       public void test() throws InterruptedException {
           final EntryPosition defaultPosition = buildPosition("mysql-bin.000864", null, 1638543000000L);
           final LocalBinlogEventParser controller = new LocalBinlogEventParser();
           controller.setMasterPosition(defaultPosition);
           controller.setMasterInfo(buildAuthentication());
           controller.setDirectory(directory);
           // AbstractCanalEventSinkTest实现CanalEventSink接口
           controller.setEventSink(new AbstractCanalEventSinkTest<List<CanalEntry.Entry>>() {
               @Override
               public boolean sink(List<CanalEntry.Entry> entries, InetSocketAddress inetSocketAddress, String s) throws CanalSinkException, InterruptedException {
                   logRecordEntry(entries);
                   return true;
               }
           });
           // 过滤（只监听cexpress.po_order的变化）
           controller.setEventFilter(new AviaterRegexFilter("cexpress.po_order"));
           // 设置自定义position管理
           controller.setLogPositionManager(new AbstractLogPositionManager() {
   
               public void persistLogPosition(String destination, LogPosition logPosition) {
   //                System.out.println(logPosition);
               }
   
               @Override
               public LogPosition getLatestIndexBy(String destination) {
                   return null;
               }
           });
           controller.start();
   
           CountDownLatch countDownLatch = new CountDownLatch(1);
           countDownLatch.await();
       }
   
       private EntryPosition buildPosition(String binlogFile, Long offest, Long timestamp) {
           return new EntryPosition(binlogFile, offest, timestamp);
       }
   
       private AuthenticationInfo buildAuthentication() {
           return new AuthenticationInfo(new InetSocketAddress(MYSQL_ADDRESS, 3306), USERNAME, PASSWORD);
       }
   
       private void logRecordEntry(List<CanalEntry.Entry> entrys) {
           for (CanalEntry.Entry entry : entrys) {
               if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN
                       || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                   continue;
               }
   
               if (entry.getEntryType() == CanalEntry.EntryType.ROWDATA) {
                   CanalEntry.RowChange rowChange;
                   try {
                       rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
                   } catch (Exception e) {
                       throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:"
                               + entry.toString(), e);
                   }
   
                   CanalEntry.EventType eventType = rowChange.getEventType();
                   String tableName = entry.getHeader().getTableName();
                   for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
                       if (eventType == CanalEntry.EventType.DELETE) {
                           List<CanalEntry.Column> beforeColumnsList = rowData.getBeforeColumnsList();
                           Map<String,String> columnDataMap = getColumnDataMap(beforeColumnsList);
                           dataChangeLog.info("删除{}表记录前的数据:{}",tableName, JsonUtil.toJSON(columnDataMap));
                       } else if (eventType == CanalEntry.EventType.INSERT) {
                           List<CanalEntry.Column> afterColumnsList = rowData.getAfterColumnsList();
                           dataChangeLog.info("新增{}表的数据:{}",tableName, LogUtil.generateRowDataLog(afterColumnsList));
                       } else {
                           List<CanalEntry.Column> beforeColumnsList = rowData.getBeforeColumnsList();
                           List<CanalEntry.Column> afterColumnsList = rowData.getAfterColumnsList();
                           dataChangeLog.info("更新{}表的变更数据：{}",tableName,
                                   LogUtil.generateRowDataDiffLog(beforeColumnsList,afterColumnsList));
                       }
                   }
               }
           }
       }
   
       private Map<String,String> getColumnDataMap(List<CanalEntry.Column> beforeColumnsList){
           Map<String,String> columnDataMap = new LinkedHashMap<>();
           for(CanalEntry.Column column : beforeColumnsList){
               columnDataMap.put(column.getName(),column.getValue());
           }
           return columnDataMap;
       }
   }
   

步骤分析

下载binlog文件到本地

1. 应用使用的阿里云RDS，它提供一种查询Binlog日志的接口
   1.1 需要登录的阿里云账号有权限
   1.2 点击调试，输入实例ID、查询开始时间、查询结束时间
   1.3 点击返回的DownloadLink进行下载binlog（每个binlog文件都有记录的开始时间以及结束时间）
   （1）返回LogBeginTime是UTC时间，需要+8小时处理
2. 在写好代码调式没问题后，准备真正解析线上binlog时发现已经查不到了，所以猜测默认过期时间是7天
3. 通过观察返回结果，发现每个binlog记录时间会有重叠部分

   {
     "TotalRecordCount": 3,
     "PageRecordCount": 3,
     "RequestId": "BAD40DDB-4506-5568-A33D-9475C59807A1",
     "PageNumber": 1,
     "TotalFileSize": "1572994846",
     "Items": {
     	"BinLogFile": [
     		{
     			 "DownloadLink":"https://xxxxxxxx/mysql-bin.000864"
   	  		 "LogBeginTime": "2021-12-03T14:43:16Z",
   	  		 "LogEndTime": "2021-12-03T17:30:39Z"
     		},
     		{
     			 "DownloadLink":"https://xxxxxxxx/mysql-bin.002711"
   	  		 "LogBeginTime": "2021-12-03T12:48:50Z",
   	  		 "LogEndTime": "2021-12-03T16:08:07Z"
     		}
     	]
     }
   }
   

利用canal的LocalBinlogEventParser解析binlog

1. 在成功解析本地binlog之前，还是遇到一些问题，但都是因为不太熟的原因导致，下面先梳理一下LocalBinlogEventParser的解析流程
2. 下面先总结一下整个解析的过程
   
   2.1 读取目录中binlog文件列表并赋值到binlogs属性中
   2.2 获取最后的位置信息（可以自定义位置管理器：logPositionManager）
   2.3 dump数据，将解析日志事件发布到disruptor中处理

disruptor在canal中使用

1. 更详细的介绍参考丁威老师的《Disruptor使用实战》
   1.1 解析binlog的目的是提取数据的变化，即DML语句(插入、更新、删除)，将这些数据变更在目标端进行重放，为了提高性能，采用disruptor框架提高性能
   （1）将解析动作分解为两步，第一步判断事件是否是dml事件，即是否需要解析
   （2）解析dml

2. SimpleParserStage#onEvent 判断是否是DML事件
   2.1 判断是否是DML事件，是则获取表的元数据（表结构）

   LogEvent logEvent = event.getEvent();
   // DML事件：LogEvent.WRITE_ROWS_EVENT（30）
                        LogEvent.UPDATE_ROWS_EVENT（31）
                        LogEvent.DELETE_ROWS_EVENT（32）
   int eventType = logEvent.getHeader().getType();
   

   2.2 从缓存tableMetaCache中获取表元数据

    // TableMetaCache#getTableMeta
   public synchronized TableMeta getTableMeta(String schema, String table, boolean useCache, EntryPosition position) {
        // tableMetaDB为guava的LoadingCache，没有执行show create table `cexpress`.`pb_order_hx`命令查询
   	 return tableMetaDB.getUnchecked(getFullName(schema, table));
   }
   

3. DmlParserStage#onEvent 解析DML
   3.1 构建RowChange（数据变更）信息（需要表元数据信息）
   3.2 将rowChange封装在Entry中

4. SinkStoreStage#onEvent
   4.1 将entry放入事务缓冲区

   public void onEvent(MessageEvent event, long sequence, boolean endOfBatch) throws Exception {
   	// 如果entry不为空，则放入到事务缓冲区中
   	if (event.getEntry() != null) {
            transactionBuffer.add(event.getEntry());
       }
   }
   

   4.2 EventTransactionBuffer#add 如果事务结束则刷新数据

   public void add(CanalEntry.Entry entry) throws InterruptedException {
   	switch (entry.getEntryType()) {
           case TRANSACTIONBEGIN:
               flush();// 刷新上一次的数据
               put(entry);
               break;
           case TRANSACTIONEND:
               put(entry);
               // 会触发自定义回调函数：CanalEventSink#sink（在这里做业务处理），更新position
               flush();
               break;
           case ROWDATA:
               put(entry);
               // 针对非DML的数据，直接输出，不进行buffer控制
               EventType eventType = entry.getHeader().getEventType();
               if (eventType != null && !isDml(eventType)) {
                   flush();
               }
               break;
          }
   }      
   

   public AbstractEventParser(){
   	 // 初始化一下
       transactionBuffer = new EventTransactionBuffer(transaction -> {
           // 触发自定义消费事务消息
           boolean successed = consumeTheEventAndProfilingIfNecessary(transaction);
           if (!running) {
               return;
           }
   
           if (!successed) {
               throw new CanalParseException("consume failed!");
           }
   
           LogPosition position = buildLastTransactionPosition(transaction);
           if (position != null) { // 可能position为空
           	// 更新position
               logPositionManager.persistLogPosition(AbstractEventParser.this.destination, position);
           }
       });
   }