使用canal同步mysql数据库到redis +实践策略模式

  • 背景

    为提高系统性能、减小数据库压力,需要对频繁查询的数据进行缓存处理。为保证mysql和redis数据一致,网上博客一大堆缓存同步策略,最核心的问题其实还是数据修改时的数据一致性:先更新(删除)缓存再更新数据库、先更新数据库再更新(删除)缓存、延时双删等。

    以上所说的这些策略主要是考虑并发场景下db-redis之间的数据最终一致,如果业务场景没有多大的并发,或缓存的数据大多是配置之类不影响业务主流程的数据,其实以上策略基本也不会有问题。如果想做到数据强一致,那就只有一种方式就是串行,但是串行必然导致性能的降低,所以是要性能还是要数据强一致就需要根据实际业务来权衡了(CAP原理的体现)。

  • canal同步缓存策略

    下面要说的是另外一种缓存同步策略,使用canal同步mysql数据库到redis。

  • 什么是canal?

    canal是阿里推出的,官方地址:https://github.com/alibaba/canal。

使用canal同步mysql数据库到redis +实践策略模式_第1张图片

  • canal 工作原理

    • canal 模拟 MySQL slave 的交互协议,伪装自己为 MySQL slave ,向 MySQL master 发送dump 协议
    • MySQL master 收到 dump 请求,开始推送 binary log 给 slave (即 canal )
    • canal 解析 binary log 对象(原始为 byte 流)
  • 使用canal同步mysql到redis示例流程图:
    使用canal同步mysql数据库到redis +实践策略模式_第2张图片

由上图可知,使用canal同步mysql到redis,也是一种异步更新缓存的方案,保证数据的最终一致。为什么要使用canal?主要考虑以下几个原因:1. 项目不是新开发,使用canal对业务的代码的侵入性小;2.基于mysql binlog监听的同步实时性较高,官方给出的说法是可以准实时。

  • canal server搭建
    canal server搭建主要包括以下几点:

    • 安装jdk,canal是由java开发,要运行canal需要安装有jdk,注意配置java环境变量

    • 修改mysql配置文件 /etc/my.cnf 并重启mysql:

      log-bin=mysql-bin     #binlog文件名
      binlog_format=row     #选择row模式
      server_id=1           #mysql实例id,不能和canal的slaveId重复
      
    • 在mysql中创建canal使用的账号密码和权限(使用已有的账号密码也可以):

      CREATE USER canal IDENTIFIED BY 'canal';    
      GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';  
      FLUSH PRIVILEGES;
      
    • 安装canal server:

      • 下载, 项目git地址:https://github.com/alibaba/canal/releases

      • 解压

      • 配置项目, conf/example/instance.properties

        # position info
        canal.instance.master.address = 127.0.0.1:3306    # mysql连接
        		
        canal.instance.dbUsername = canal                 # mysql账号
        canal.instance.dbPassword = canal                 # 密码
        canal.instance.defaultDatabaseName = test	      # 需要同步的库名
        canal.instance.connectionCharset = UTF-8	      # mysql编码
        
      • 启动项目: sh bin/startup.sh (即执行bin目录下的startup.sh 脚本即可)

      • 查看日志:

        vim logs/canal/canal.log #canal server端运行日志

        vim logs/example/example.log #canal client端连接日志

        vim logs/example/meta.log #实例binlog 读取记录文件(记录变更位置,默认为新增变更)

  • 开发canal client

    • 官方demo地址:https://github.com/alibaba/canal/wiki/ClientExample

    • 引入 canal依赖:

       <dependency>
           <groupId>com.alibaba.ottergroupId>
           <artifactId>canal.clientartifactId>
           <version>1.1.5version>
      dependency>
      <dependency>
          <groupId>com.alibaba.ottergroupId>
          <artifactId>canal.protocolartifactId>
          <version>1.1.5version>
      dependency>
      
    • 配置文件中配置:

      #canal服务配置
      canal-server:
        #canal服务地址
        host: 192.168.1.1
        #canal服务端口
        port: 11111
        #canal服务 desrination名称
        desrination: example
        #要监控的数据库名
        data-base: my_test
        #每批处理数量
        batch-size: 1000
      
    • canal服务启动类:
      说明:DTS是阿里云提供的服务,在同步缓存这方面来说,与canal实现的功能是一样的;为保证生产的稳定性,开发环境使用canal,生产环境使用DTS。(这里可以先忽略DTS,后续有时间再说DTS的使用)

      /**
       * 通过监听mysql binlog同步redis缓存:非生产环境使用阿里云DTS,非生产环境(开发、测试、预生产)使用自搭建canal服务
       */
      @Slf4j
      @Component
      public class MySQL2Redis {
      
          /**
           * canal服务配置<测试环境用canal>
           **/
          @Value("${canal-server.host}")
          private String canalServerHost;
      
          @Value("${canal-server.port}")
          private int canalServerPort;
      
          @Value("${canal-server.desrination}")
          private String canalServerDesrination;
      
          @Value("${canal-server.data-base}")
          private String dataBase;
      
          @Value("${canal-server.batch-size}")
          private int batchSizeInit;
      
          /**
           * 阿里DTS服务配置<生产环境用DTS>
           **/
          @Value("${dts.accessKey}")
          private String accessKey;
      
          @Value("${dts.accessSecret}")
          private String accessSecret;
      
          @Value("${dts.subscription_instance_id}")
          private String subscriptionInstanceId;
      
      
          @Autowired
          private SpringContextUtil springContextUtil;
      
          @Autowired
          private RedisUtil redisUtil;
      
          @Autowired
          private TableStrategyContext tableStrategyContext;
      
          @PostConstruct
          public void init() {
              log.info(" === start ===");
              String activeProfile = springContextUtil.getActiveProfile();
              boolean proEvn = ActiveEvnEnums.isProEvn(activeProfile);
              if (proEvn) {
                  log.info(" === 生产环境,启动DTS监听 ===");
                  new Thread(new DTSMySQL2RedisTask(accessKey, accessSecret,
                          subscriptionInstanceId, tableStrategyContext)).start();
              } else {
                  log.info(" === 非生产环境,启动canal-client监听 ===");
                  new Thread(new CanalMySQL2RedisTask(canalServerHost, canalServerPort,
                          canalServerDesrination, dataBase, batchSizeInit, tableStrategyContext)).
                          start();
              }
          }
      }
      
    • canal任务执行类:

      说明:因不同的表存入缓存时可能设置的key不同以及缓存查策略不同,因此这里使用策略模式,不同的表同步缓存时单独处理,策略的key定义为表名,有新的表要实现同步缓存时,只需要新增一个策略就行,不用改动其他代码,保证代码良好的扩展性。

      /**
       * @author simon
       * @version 1.0.0
       * @ClassName com.dhzhly.cache.client.synchronous.cache.CanalMySQL2RedisTask
       * @Description
       * @createTime 2022/2/23
       */
      @Slf4j
      public class CanalMySQL2RedisTask implements Runnable {
      
          private String canalServerHost;
      
          private int canalServerPort;
      
          private String canalServerDesrination;
      
          private String dataBase;
      
          private int batchSizeInit;
      
          //策略上下文
          private TableStrategyContext tableStrategyContext;
      
          public CanalMySQL2RedisTask(String canalServerHost, int canalServerPort, String canalServerDesrination,
                                      String dataBase, int batchSizeInit, TableStrategyContext tableStrategyContext) {
              this.canalServerHost = canalServerHost;
              this.canalServerPort = canalServerPort;
              this.canalServerDesrination = canalServerDesrination;
              this.dataBase = dataBase;
              this.batchSizeInit = batchSizeInit;
              this.tableStrategyContext = tableStrategyContext;
          }
      
          @Override
          public void run() {
              //创建客户端
              CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress(canalServerHost,
                      canalServerPort), canalServerDesrination, Constants.BLANK_STR, Constants.BLANK_STR);
              try {
                  //批量个数
                  int batchSize = batchSizeInit;
                  //连接
                  connector.connect();
                  //过滤监听的库-表
                  connector.subscribe(dataBase + ".*");
                  while (true) {
                      // 获取指定数量的数据
                      Message message = connector.getWithoutAck(batchSize);
                      long batchId = message.getId();
                      int size = message.getEntries().size();
                      log.info("batchId = {},size = {}", batchId, size);
                      List<CanalEntry.Entry> entries = message.getEntries();
                      if (CollectionUtils.isEmpty(entries)) {
                          try {
                              Thread.sleep(300);
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      } else {
                          //处理数据
                          handleEntry(message.getEntries());
                      }
                      // 提交确认
                      connector.ack(batchId);
                  }
              } catch (Exception e) {
                  log.error("exception e ," + e);
                  //异常回滚:回滚到未进行 {@link #ack} 的地方,下次fetch的时候,可以从最后一个没有 {@link #ack} 的地方开始拿
                  connector.rollback();
              } finally {
                  //释放连接
                  connector.disconnect();
              }
          }
      
          private void handleEntry(List<CanalEntry.Entry> entrys) {
              for (CanalEntry.Entry entry : entrys) {
                  if (entry.getEntryType().equals(CanalEntry.EntryType.ROWDATA)) {
                      CanalEntry.RowChange rowChage = null;
                      try {
                          rowChage = 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 = rowChage.getEventType();
                      String tableName = entry.getHeader().getTableName();
                      log.info("tableName :{}, eventType : {}", tableName, eventType);
      
                      /** 后续通过表名 对不同的表数据分别进行处理 **/
      
                      for (CanalEntry.RowData rowData : rowChage.getRowDatasList()) {
                          if (eventType == CanalEntry.EventType.DELETE) {
                              redisDelete(rowData.getBeforeColumnsList(), tableName);
                          } else if (eventType == CanalEntry.EventType.INSERT) {
                              redisInsert(rowData.getAfterColumnsList(), tableName);
                          } else {
                              log.info("-------> before");
                              printColumn(rowData.getBeforeColumnsList());
                              log.info("-------> after");
                              redisUpdate(rowData.getAfterColumnsList(), tableName);
                          }
                      }
                  }
              }
          }
      
          private void printColumn(List<CanalEntry.Column> columns) {
              for (CanalEntry.Column column : columns) {
                  log.info(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
              }
          }
      
          private void redisInsert(List<CanalEntry.Column> columns, String tableName) {
              JSONObject json = new JSONObject();
              for (CanalEntry.Column column : columns) {
                  json.set(FieldConvertUtil.lineToHump(column.getName()), column.getValue());
              }
              if (columns.size() > 0) {
                  //通过表名获取策略
                  TableRedisOperationStrategy resource = tableStrategyContext.getResource(tableName);
                  if (resource != null) {
                      resource.insert(JSONUtil.toJsonStr(json));
                  }
              }
          }
      
          private void redisUpdate(List<CanalEntry.Column> columns, String tableName) {
              JSONObject json = new JSONObject();
              for (CanalEntry.Column column : columns) {
                  json.set(FieldConvertUtil.lineToHump(column.getName()), column.getValue());
              }
              if (columns.size() > 0) {
                  //通过表名获取策略
                  TableRedisOperationStrategy resource = tableStrategyContext.getResource(tableName);
                  if (resource != null) {
                      resource.update(JSONUtil.toJsonStr(json));
                  }
              }
          }
      
          private void redisDelete(List<CanalEntry.Column> columns, String tableName) {
              JSONObject json = new JSONObject();
              for (CanalEntry.Column column : columns) {
                  json.set(FieldConvertUtil.lineToHump(column.getName()), column.getValue());
              }
              if (columns.size() > 0) {
                  //通过表名获取策略
                  TableRedisOperationStrategy resource = tableStrategyContext.getResource(tableName);
                  if (resource != null) {
                      resource.delete(JSONUtil.toJsonStr(json));
                  }
              }
          }
      }
      
    • 下划线装驼峰工具类

      /**
       * @author simon
       * @version 1.0.0
       * @ClassName com.dhzhly.cache.client.common.util.FieldConvertUtil
       * @Description
       * @createTime 2022/3/4
       */
      public class FieldConvertUtil {
      
          private static Pattern linePattern = Pattern.compile("_(\\w)");
      
          /** 下划线转驼峰 */
          public static String lineToHump(String str) {
              str = str.toLowerCase();
              Matcher matcher = linePattern.matcher(str);
              StringBuffer sb = new StringBuffer();
              while (matcher.find()) {
                  matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
              }
              matcher.appendTail(sb);
              return sb.toString();
          }
      }
      
    • 策略接口

      public interface TableRedisOperationStrategy {
      
          void insert(String value);
      
          void delete(String value);
      
          void update(String value);
      }
      
    • 具体策略类

      /**
       * @author simon
       * @version 1.0.0
       * @ClassName com.dhzhly.cache.client.synchronous.table.AccountInfoRedisOpration
       * @Description
       * @createTime 2022/3/16
       */
      @Component("account_info")
      @Slf4j
      public class AccountInfoRedisOpration implements TableRedisOperationStrategy {
      
          private static final String REDIS_KEY_PREFIX = "account_info::";
      
          private static final String LOGIN_NAME_FIELD = "loginName";
      
          @Autowired
          private RedisUtil redisUtil;
      
          @Override
          public void insert(String value) {
              JSONObject jsonObject = JSONUtil.parseObj(value);
              String loginName = jsonObject.getStr(LOGIN_NAME_FIELD);
              redisUtil.set(Constants.generateKey(REDIS_KEY_PREFIX, loginName), value, Constants.REFIS_KEY_TIMEOUT);
          }
      
          @Override
          public void delete(String value) {
              JSONObject jsonObject = JSONUtil.parseObj(value);
              String loginName = jsonObject.getStr(LOGIN_NAME_FIELD);
              redisUtil.del(Constants.generateKey(REDIS_KEY_PREFIX, loginName));
          }
      
          @Override
          public void update(String value) {
              JSONObject jsonObject = JSONUtil.parseObj(value);
              String loginName = jsonObject.getStr(LOGIN_NAME_FIELD);
              redisUtil.set(Constants.generateKey(REDIS_KEY_PREFIX, loginName), value, Constants.REFIS_KEY_TIMEOUT);
          }
      }
      
    • 策略上下文

      /**
       * @author simon
       * @version 1.0.0
       * @ClassName com.dhzhly.cache.client.synchronous.OperationStrategyContext
       * @Description
       * @createTime 2022/3/3
       */
      @Component
      public class TableStrategyContext {
      
          @Autowired
          private final Map<String, TableRedisOperationStrategy> tableStrategyMap = new ConcurrentHashMap<>();
      
          public TableStrategyContext(Map<String, TableRedisOperationStrategy> strategyMap) {
              this.tableStrategyMap.clear();
              strategyMap.forEach((k, v)-> this.tableStrategyMap.put(k, v));
          }
      
          public TableRedisOperationStrategy getResource(String tableName){
              return tableStrategyMap.get(tableName);
          }
      
      }
      
    • 常量类

      /**
       * @author simon
       * @version 1.0.0
       * @ClassName com.dhzhly.cache.client.common.constants
       * @Description
       * @createTime 2022/2/23
       */
      public class Constants {
      
          public static final String BLANK_STR = "";
      
          //缓存超时时间 7天
          public static final long REFIS_KEY_TIMEOUT = 60 * 60 * 24 * 7L;
      
          public static String generateKey(String redisKey,String param) {
              return new StringBuffer().append(redisKey).append(param).toString();
          }
      }
      
    • 代码结构目录
      使用canal同步mysql数据库到redis +实践策略模式_第3张图片

      如上图所示,如果一张新表t_student要同步缓存,只需要再写一类 StudentRedisOpration,实现策略接口TableRedisOperationStrategy,StudentRedisOpration类上加注解@Component(“t_student”)即可,其他逻辑不用修改。

​ 以上就是使用canal同步mysql到redis的简单用法。至于业务代码如何加缓存,如何无代码侵入性的加缓存,下篇再说。

你可能感兴趣的:(java,redis,数据库,mysql,策略模式)