使用Canal实现数据库和Redis同步

最新推荐文章于 2025-04-18 14:36:57 发布
最新推荐文章于 2025-04-18 14:36:57 发布
阅读量1.3k 收藏 8
点赞数
分类专栏： 数据库 MySQL 文章标签： 数据库 mysql canal
欢迎关注我的微信公众号：串一串爪娃子(微信号：cyc_java)
本文链接：https://blog.youkuaiyun.com/luxiaoruo/article/details/106637425
版权

一、简介

Canal是Java开发的基于数据库增量日志解析工具，提供增量数据订阅和消费，目前主要支持MySQL。它的工作原理比较简单，就是将自己伪装成一个MySQL Slave，从Master同步数据。

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

先了解一下MySQL主备复制原理：

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

二、准备工作

  1. 对于自建的MySQL，需要开启binlog写入功能，并配置biglog-format为ROW模式，这样才能一行行的检测到数据的变动
[mysqld]
log-bin=mysql-bin # 开启 binlog
binlog-format=ROW # 选择 ROW 模式
server_id=1 # 配置 MySQL replaction 需要定义，不要和 canal 的 slaveId 重复
  1. 创建canal用户并授权其作为MySQL Slave的权限
CREATE USER canal IDENTIFIED BY 'canal';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';
FLUSH PRIVILEGES;

三、启动Canal服务

  1. 下载canal

    我们这里使用的是canal.deployer-1.1.4.tar.gz

  2. 解压

    tar zxvf canal.deployer-1.1.4.tar.gz
cd canal.deployer-1.1.4

    image-20200424004844430

  3. 修改配置文件，主要是MySQL Master的连接信息

    打开文件conf/example/instance.properties

    #################################################
## mysql serverId , v1.0.26+ will autoGen
canal.instance.mysql.slaveId=1

# enable gtid use true/false
canal.instance.gtidon=false

# position info
canal.instance.master.address=127.0.0.1:3306
canal.instance.master.journal.name=
canal.instance.master.position=
canal.instance.master.timestamp=
canal.instance.master.gtid=

# rds oss binlog
canal.instance.rds.accesskey=
canal.instance.rds.secretkey=
canal.instance.rds.instanceId=

# table meta tsdb info
canal.instance.tsdb.enable=true
#canal.instance.tsdb.url=jdbc:mysql://127.0.0.1:3306/canal_tsdb
#canal.instance.tsdb.dbUsername=canal
#canal.instance.tsdb.dbPassword=canal

#canal.instance.standby.address =
#canal.instance.standby.journal.name =
#canal.instance.standby.position =
#canal.instance.standby.timestamp =
#canal.instance.standby.gtid=

# username/password
canal.instance.dbUsername=canal
canal.instance.dbPassword=canal
canal.instance.defaultDatabaseName=test_canal
canal.instance.connectionCharset = UTF-8
# enable druid Decrypt database password
canal.instance.enableDruid=false
#canal.instance.pwdPublicKey=MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALK4BUxdDltRRE5/zXpVEVPUgunvscYFtEip3pmLlhrWpacX7y7GCMo2/JM6LeHmiiNdH1FWgGCpUfircSwlWKUCAwEAAQ==

# table regex
canal.instance.filter.regex=.*\\..*
# table black regex
canal.instance.filter.black.regex=
# table field filter(format: schema1.tableName1:field1/field2,schema2.tableName2:field1/field2)
#canal.instance.filter.field=test1.t_product:id/subject/keywords,test2.t_company:id/name/contact/ch
# table field black filter(format: schema1.tableName1:field1/field2,schema2.tableName2:field1/field2)
#canal.instance.filter.black.field=test1.t_product:subject/product_image,test2.t_company:id/name/contact/ch

# mq config
# canal.mq.topic=example
# dynamic topic route by schema or table regex
# canal.mq.dynamicTopic=mytest1.user,mytest2\\..*,.*\\..*
# canal.mq.partition=0
# hash partition config
# canal.mq.partitionsNum=3
# canal.mq.partitionHash=test.table:id^name,.*\\..*
#################################################
    • canal.instance.connectionCharset 代表数据库的编码方式对应到 java 中的编码类型，比如 UTF-8，GBK , ISO-8859-1
    • 如果系统是1个 cpu，需要将 canal.instance.parser.parallel 设置为 false

  4. 启动canal

    sh bin/startup.sh

  5. 查看server和instance日志

    2020-04-23 23:48:59.048 [main] INFO  com.alibaba.otter.canal.deployer.CanalLauncher - ## set default uncaught exception handler
2020-04-23 23:48:59.097 [main] INFO  com.alibaba.otter.canal.deployer.CanalLauncher - ## load canal configurations
2020-04-23 23:48:59.110 [main] INFO  com.alibaba.otter.canal.deployer.CanalStarter - ## start the canal server.
2020-04-23 23:48:59.178 [main] INFO  com.alibaba.otter.canal.deployer.CanalController - ## start the canal server[192.168.0.106(192.168.0.106):11111]
2020-04-23 23:49:00.243 [main] INFO  com.alibaba.otter.canal.deployer.CanalStarter - ## the canal server is running now ......

    er.setConnectionCharset(java.lang.String)]
2020-04-23 23:48:59.793 [main] INFO  c.a.o.c.i.spring.support.PropertyPlaceholderConfigurer - Loading properties file from class path resource [canal.properties]
2020-04-23 23:48:59.794 [main] INFO  c.a.o.c.i.spring.support.PropertyPlaceholderConfigurer - Loading properties file from class path resource [example/instance.properties]
2020-04-23 23:49:00.192 [main] INFO  c.a.otter.canal.instance.spring.CanalInstanceWithSpring - start CannalInstance for 1-example
2020-04-23 23:49:00.199 [main] WARN  c.a.o.canal.parse.inbound.mysql.dbsync.LogEventConvert - --> init table filter : ^.*\..*$
2020-04-23 23:49:00.199 [main] WARN  c.a.o.canal.parse.inbound.mysql.dbsync.LogEventConvert - --> init table black filter :
2020-04-23 23:49:00.206 [main] INFO  c.a.otter.canal.instance.core.AbstractCanalInstance - start successful....

  6. 关闭

    sh bin/stop.sh

四、创建Java工程

  1. 引入canal和redis包

    <dependency>
  <groupId>com.alibaba.otter</groupId>
  <artifactId>canal.client</artifactId>
  <version>1.1.4</version>
</dependency>

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.4.2</version>
</dependency>

  2. 创建RedisUtils工具类

    import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtils {

    // Redis服务器IP
    private static String      ADDR       = "127.0.0.1";

    // Redis的端口号
    private static int         PORT       = 6379;

    // 访问密码
    private static String      AUTH       = "";

    // 可用连接实例的最大数目，默认值为8；
    // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int         MAX_ACTIVE = 1024;

    // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int         MAX_IDLE   = 200;

    // 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int         MAX_WAIT   = 10000;

    // 过期时间
    protected static int       expireTime = 60 * 60 * 24;

    // 连接池
    protected static JedisPool pool;

    /**
     * 静态代码，只在初次调用一次
     */
    static {
        JedisPoolConfig config = new JedisPoolConfig();
        //最大连接数
        config.setMaxTotal(MAX_ACTIVE);
        //最多空闲实例
        config.setMaxIdle(MAX_IDLE);
        //超时时间
        config.setMaxWaitMillis(MAX_WAIT);
        //
        config.setTestOnBorrow(false);
        pool = new JedisPool(config, ADDR, PORT, 1000);
    }

    /**
     * 获取jedis实例
     */
    protected static synchronized Jedis getJedis() {
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
        } catch (Exception e) {
            e.printStackTrace();
            if (jedis != null) {
                pool.returnBrokenResource(jedis);
            }
        }
        return jedis;
    }

    /**
     * 释放jedis资源
     *
     * @param jedis
     * @param isBroken
     */
    protected static void closeResource(Jedis jedis, boolean isBroken) {
        try {
            if (isBroken) {
                pool.returnBrokenResource(jedis);
            } else {
                pool.returnResource(jedis);
            }
        } catch (Exception e) {

        }
    }

    /**
     *  是否存在key
     *
     * @param key
     */
    public static boolean existKey(String key) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = getJedis();
            jedis.select(0);
            return jedis.exists(key);
        } catch (Exception e) {
            isBroken = true;
        } finally {
            closeResource(jedis, isBroken);
        }
        return false;
    }

    /**
     *  删除key
     *
     * @param key
     */
    public static void delKey(String key) {
        Jedis jedis = null;
        boolean isBroken = false;
        try {
            jedis = getJedis();
            jedis.select(0);
            jedis.del(key);
        } catch (Exception e) {
            isBroken = true;
        } finally {
            closeResource(jedis, isBroken);
        }
    }

    /**
     *  取得key的值
     *
     * @param key
     */
    public static String stringGet(String key) {
        Jedis jedis = null;
        boolean isBroken = false;
        String lastVal = null;
        try {
            jedis = getJedis();
            jedis.select(0);
            lastVal = jedis.get(key);
            jedis.expire(key, expireTime);
        } catch (Exception e) {
            isBroken = true;
        } finally {
            closeResource(jedis, isBroken);
        }
        return lastVal;
    }

    /**
     *  添加string数据
     *
     * @param key
     * @param value
     */
    public static String stringSet(String key, String value) {
        Jedis jedis = null;
        boolean isBroken = false;
        String lastVal = null;
        try {
            jedis = getJedis();
            jedis.select(0);
            lastVal = jedis.set(key, value);
            jedis.expire(key, expireTime);
        } catch (Exception e) {
            e.printStackTrace();
            isBroken = true;
        } finally {
            closeResource(jedis, isBroken);
        }
        return lastVal;
    }

    /**
     *  添加hash数据
     *
     * @param key
     * @param field
     * @param value
     */
    public static void hashSet(String key, String field, String value) {
        boolean isBroken = false;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (jedis != null) {
                jedis.select(0);
                jedis.hset(key, field, value);
                jedis.expire(key, expireTime);
            }
        } catch (Exception e) {
            isBroken = true;
        } finally {
            closeResource(jedis, isBroken);
        }
    }

}

  3. 创建CanalClient

    import java.net.InetSocketAddress;
import java.util.List;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.common.utils.AddressUtils;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.protocol.CanalEntry.*;

public class CanalClient {

    public static void main(String args[]) {
        // 创建链接
        CanalConnector connector = CanalConnectors
                .newSingleConnector(new InetSocketAddress(AddressUtils.getHostIp(), 11111), "example", "", "");
        int batchSize = 1000;
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            while (true) {
                Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                    }
                } else {
                    printEntry(message.getEntries());
                }
                connector.ack(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();

            for (RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == EventType.DELETE) {
                    // 删除，获取删除前的数据
                    redisDelete(rowData.getBeforeColumnsList());
                } else if (eventType == EventType.INSERT) {
	                  // 新增，获取新增后的数据
                    redisSet(rowData.getAfterColumnsList());
                } else {
                  	// 修改，获取修改后的数据
                    //                    printColumn(rowData.getBeforeColumnsList());
                    redisSet(rowData.getAfterColumnsList());
                }
            }
        }
    }

    private static void redisSet(List<Column> columns) {
        JSONObject json = new JSONObject();
      	// 字段和值的列表，放入json，后续作为redis的值
        for (Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
          	System.out.println("set key: " + columns.get(0).getValue() + ", value: " + json.toJSONString());
          	// 获取第一列主键的数据
            RedisUtils.stringSet("demo:" + 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) {
	          System.out.println("delete key: " + columns.get(0).getValue());
            RedisUtils.delKey("demo:" + columns.get(0).getValue());
        }
    }

}

五、验证

  1. 启动CanalClient.java

  2. 创建数据表test_canal

    CREATE TABLE `test_canal` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(11) DEFAULT NULL,
  `age` int(11) DEFAULT 0,
  `sex` varchar(11) DEFAULT '男',
  PRIMARY KEY (`id`),
  KEY `idx_name` (`name`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4

  3. 校验一下Redis中目前是否为空

    image-20200424011739125

  4. 插入数据

    • 插入三条数据
    INSERT INTO test_canal(name, age, sex) VALUES('cc0', 3, '男');
INSERT INTO test_canal(name, age, sex) VALUES('cc1', 6, '女');
INSERT INTO test_canal(name, age, sex) VALUES('cc2', 9, '男');
    • 查看控制台

    image-20200424011949902

    • 查询Redis中的数据

    image-20200424012034154

    验证成功，数据同步达到了毫秒级。

  5. 修改数据

    • 修改id=5的数据
    UPDATE test_canal SET sex='11' WHERE id=5;
    • 查看控制台

    image-20200424012346073

    • 查询Redis中的数据

    image-20200424012421781

    验证成功，Redis中的sex列已经修改为何MySQL表中一致了

  6. 删除数据

    • 删除id=5的数据
    DELETE FROM test_canal WHERE id=5;
    • 查看控制台

    image-20200424012700399

    • 查询Redis中的数据

    image-20200424013951523

    验证成功，Redis中的"demo:5"已经被删除了

总结

关于更多的Canal介绍可以查看官方文档：Canal官方介绍，源端目前只支持MySQL，目标端可以是任意组件

使用Spring Boot和Canal实现MySQL与Redis的数据同步
带你成为别人眼中的大佬！
09-30 324
在上面的示例中，我们使用Jedis库与Redis进行交互。Canal是阿里巴巴开源的一款基于MySQL协议的增量订阅&消费组件，它可以订阅MySQL的binlog日志，并将变更事件推送给消费者。通过结合Spring Boot，我们可以轻松地将Canal集成到我们的应用程序中，以实现MySQL与Redis之间的数据同步。在现代应用程序开发中，数据同步是一个常见的需求，特别是当涉及到不同的数据存储系统时。在本文中，我们将介绍如何使用Spring Boot和Canal来实现MySQL与Redis之间的数据同步。
Springboot 基于canal实现MySQL和redis的数据一致性
weixin_46019985的博客
01-23 575
安装mysql和redis教程跳过，如未安装，自行百度。
使用canal同步mysql数据库到redis +实践策略模式
Mr__simon的博客
03-17 3052
背景 为提高系统性能、减小数据库压力，需要对频繁查询的数据进行缓存处理。为保证mysql和redis数据一致，网上博客一大堆缓存同步策略，最核心的问题其实还是数据修改时的数据一致性：先更新（删除）缓存再更新数据库、先更新数据库再更新(删除)缓存、延时双删等。 以上所说的这些策略主要是考虑并发场景下db-redis之间的数据最终一致，如果业务场景没有多大的并发，或缓存的数据大多是配置之类不影响业务主流程的数据，其实以上策略基本也不会有问题。如果想做到数据强一致，那就只有一种方式就是串行，但是串行必然导致性..
Redis更新缓存同步数据库的理解
shouzei123的专栏
09-27 6775
问题：当数据库有数据更新时，怎样保证redis缓存中的数据与数据库数据一致？   Redis更新的正确方法 原文（缓存更新的套路）：看到好些人在写更新缓存数据代码时，先删除缓存，然后再更新数据库，而后续的操作会把数据再装载的缓存中。然而，这个是逻辑是错误的。试想，两个并发操作，一个是更新操作，另一个是查询操作，更新操作删除缓存后，查询操作没有命中缓存，先把老数据读出来后放到缓存中，然后更...
Canal组件学习使用
最新发布
liushangzaibeijing的博客
04-18 1218
本篇博文是canal的科普和实战干货文章。主要有三大部分，canal使用的原理，canal服务端安装使用、canal管理的安装使用、canal的与mq、kafka、rdb、java客户端的集成使用。
canal同步数据到redis
qingwenc的博客
04-10 883
canal原理：canal需要使用到mysql，但canal是基于mysql的主从模式实现的，所以必须先开启binlog (1) 连接到mysql中,并修改/etc/mysql/mysql.conf.d/mysqld.cnf 需要开启主 从模式，开启binlog模式。 执行如下命令，编辑mysql配置文件 命令行如下： docker exec -it mysql /bin/bash cd /e...
基于Canal的Mysql&Redis数据同步实现
zhiyikeji的博客
04-06 2792
我们在做mysql与redis的数据同步时，往往采用的是代码层实现，或者通过等缓存框架。但是仍然有某些场景，比如说原项目无源码，或者不能进行二开时，就需要独立的第三方来实现数据同步。我们需要一种无代码入侵式的数据同步，完全由第三方组件管理。这就需要借助canal来实现mysql到redis的数据同步canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL（也支持mariaDB。
Canal 实现Mysql Redis数据同步
thebinso的博客
05-12 1204
1.首先mysql数据库得开启binlog 2.导入canal依赖 <!--Canal 依赖--> <dependency> <groupId>top.javatool</groupId> <artifactId>canal-spring-boot-starter</artifactId> <version>1.2.1-RELE
canal实现mysql和redis同步
06-28
Canal是一个开源的数据库增量订阅&消费组件，可以实现MySQL和Redis的同步。它可以通过解析MySQL的binlog日志，将数据变更事件转换成Java对象，然后通过消息队列的方式异步地传递给消费端，消费端可以根据自己的需求...
利用Canal实现数据库改动就更新redis功能
月哥说了算的博客
08-19 534
此功能设计到三个微服务： service_business: 负责查询数据库数据。 service_business_api：存feigin远程调用接口。 service_canal:负责canal功能。 service_business controller @RestController @CrossOrigin @RequestMapping("/ad") public class AdCo...
Redis 和数据库的数据同步
m0_50272029的博客
08-15 2011
每一种同步方式都有它的优缺点，但只要合理搭配，Redis 和数据库之间的数据同步就能像故事中的冒险一样，充满智慧与奇迹。如果没有，Cache Aside 就不得不跑到数据城，从数据库居民那里获取最新的信息，并将这些信息存放在自己的缓存仓库里，以备下次使用。每当访客需要更新信息时，Write Through 先将信息送到 Redis 的缓存仓库，然后再马不停蹄地奔向数据城，将同样的信息传递给数据库居民。这使得即使在高并发的情况下，信息也能有条不紊地同步到数据城，确保王国的信息管理一如既往的高效。
redis 同步mysql java_canal解决mysql与redis数据同步框架
weixin_35792040的博客
01-19 202
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.*;i...
使用canal进行mysql数据同步到Redis
X-man
03-13 645
业务场景描述在我们的项目中有些配置信息持久化在数据库中，这些配置信息又是在系统启动后自动加载并缓存在local或者Redis中，但如果后台运营系统进行了相应更新配置操作，我们需要实现“热部署”或“热插拔”等功能的话，我们有哪些方案可以实现呢？单机项目就非常简单了，但分布式集群的项目怎么办呢？分布式集群的项目之间同步数据，我们来讲一下有哪些方案解决。方案一：项目程序中对DB进行操作后，留一个后门接口...
利用Canal完成Mysql数据同步Redis
热门推荐
南山行者
12-21 3万+
流程 Canal的原理是模拟Slave向Master发送请求，Canal解析binlog，但不将解析结果持久化，而是保存在内存中，每次有客户端读取一次消息，就删除该消息。这里所说的客户端，就需要我们写一个连接Canal的程序，持续从Canal获取数据。 步骤 一、配置Canal 参考https://github.com/alibaba/canal 【mysql配置】 1，配
SpringBoot整合Canal1.1.6并同步数据到Redis（超详细和很多踩坑点）
qq_41275753的博客
04-18 2713
SpringBoot初步整合Canal
Canal通过TCP实现MySQL与Redis同步
吉衣の秋先生的博客
04-22 2479
Canal通过TCP实现MySQL与Redis同步 Canal通过TCP实现MySQL与Redis同步 Docker环境安装 安装yum-utils： yum install -y yum-utils device-mapper-persistent-data lvm2 为yum源添加docker仓库位置： yum-config-manager --add-repo https://do...
Java开发 - Canal进阶之和Redis的数据同步
CodingFire的博客
07-04 4436
本篇是对单节点的应用，但从中我们也能推断出一些关于集群的应用，不过大多数公司能搞个主从就已经是不错了，所以你能学会这个已经算是很有用了，关于ES，博主前面也讲过一些基础应用，创建一个工具类利用ES的数据模型进行存储就可以达到一个canal同时对Redis和ES的同步，如果担心出问题，可以把Canal搞成集群的形式，这个后续有时间博主再给大家做讲解。今天就到这里了，觉得不错就支持一下吧。
使用Canal实现redis和mysql的同步
weixin_30408309的博客
01-07 459
使用Canal实现redis和mysql的同步 ### canal 工作思路 Canal 会将自己伪装成 MySQL 从节点（Slave），并从主节点（Master）获取 Binlog，解析和贮存后供下游消费端使用。Canal 包含两个组成部分：服务端和客户端。服务端负责连接至不同的 MySQL 实例，并为每个实例维护一个事件消息队列；客户端则可以订阅这些队列中的数据变更事件，处理并存储到数据仓库...
工业级数据同步实战：基于Canal+MySQL+Redis+ES构建亿级流量高可用方案
Zyw907155124的博客
09-20 2140
"揭秘阿里开源的Canal核心原理与生产级部署方案，手把手教你构建零延迟的异构数据同步体系。本文深度解析MySQL Binlog日志解析、RabbitMQ消息削峰、Redis缓存双写一致性、Elasticsearch近实时索引等企业级技术组合，涵盖从DBA配置到SpringCloud集成全流程，提供多节点高可用架构设计与性能调优指南。已通过日均10亿级交易场景验证，配套提供云原生部署方案与可视化监控脚本。"
Canal实现MySQL与Redis数据同步实战
在使用Canal进行MySQL与Redis同步的过程中，一般会涉及到数据同步策略。常见的策略有全量同步和增量同步两种。全量同步是指将MySQL中的数据一次性同步到Redis中，适用于系统初始化或数据重建的场景。增量同步则是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值