如何在 Java 中使用 Canal 同步 MySQL 数据到 Redis

原创 已于 2024-11-08 01:11:33 修改 · 1.4k 阅读 · 31 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #mysql #redis

于 2024-11-07 22:57:55 首次发布

文章目录

一、引言

在现代微服务架构中，数据同步是一个常见的需求。特别是将 MySQL 数据实时同步到 Redis，可以显著提升应用的性能和响应速度。本文将详细介绍如何使用 Canal 实现这一目标。Canal 是阿里巴巴开源的一个数据库 Binlog 同步工具，可以实时捕获 MySQL 的 Binlog 日志并将其同步到其他存储系统。
项目地址：alibaba/canal

二、工作原理

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 流)

三、环境准备

1. 安装和配置 MySQL

Canal的原理是基于mysql binlog技术，所以这里一定需要开启mysql的binlog写入功能，并且配置binlog模式为row。编辑 MySQL 配置文件 my.cnf 或 my.ini，添加或修改以下内容：

[mysqld]
server-id=1
log-bin=mysql-bin
binlog-format=ROW

授权 canal 链接 MySQL 账号具有作为 MySQL slave 的权限, 如果已有账户可直接 grant：

CREATE USER canal IDENTIFIED BY 'canal';  
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%';
-- GRANT ALL PRIVILEGES ON *.* TO 'canal'@'%' ;
FLUSH PRIVILEGES;

重启 MySQL 服务以使配置生效：

sudo service mysql restart

2. 安装和配置 Canal

下载并解压 Canal 服务端：

wget https://github.com/alibaba/canal/releases/download/canal-1.1.5/canal.deployer-1.1.5.tar.gz
tar -zxvf canal.deployer-1.1.5.tar.gz -C /opt/canal
cd /opt/canal

编辑 Canal 配置文件 conf/example/instance.properties，配置 MySQL 服务器的相关信息：

canal.instance.master.address=127.0.0.1:3306
canal.instance.dbUsername=canal
canal.instance.dbPassword=canal
canal.instance.connectionCharset=UTF-8
canal.instance.filter.regex=.*\\..*

启动 Canal 服务：

sh bin/startup.sh

查看 server 日志

vi logs/canal/canal.log</pre>
2013-02-05 22:45:27.967 [main] INFO  com.alibaba.otter.canal.deployer.CanalLauncher - ## start the canal server.
2013-02-05 22:45:28.113 [main] INFO  com.alibaba.otter.canal.deployer.CanalController - ## start the canal server[10.1.29.120:11111]
2013-02-05 22:45:28.210 [main] INFO  com.alibaba.otter.canal.deployer.CanalLauncher - ## the canal server is running now ......

查看 instance 的日志

vi logs/example/example.log
2013-02-05 22:50:45.636 [main] INFO  c.a.o.c.i.spring.support.PropertyPlaceholderConfigurer - Loading properties file from class path resource [canal.properties]
2013-02-05 22:50:45.641 [main] INFO  c.a.o.c.i.spring.support.PropertyPlaceholderConfigurer - Loading properties file from class path resource [example/instance.properties]
2013-02-05 22:50:45.803 [main] INFO  c.a.otter.canal.instance.spring.CanalInstanceWithSpring - start CannalInstance for 1-example 
2013-02-05 22:50:45.810 [main] INFO  c.a.otter.canal.instance.spring.CanalInstanceWithSpring - start successful....

如果启动失败，注意检查配置文件conf/example/instance.properties的内容，还要注意JDK版本及配置。建议使用1.6.25。我用openjdk 21启动报错，改回JDK8u421启动成功。

3. 安装和配置 Redis

确保 Redis 服务已经安装并启动。可以在 Redis 客户端中执行以下命令检查：

redis-cli
ping

四、开发 Java 应用

1. 添加依赖

在你的 pom.xml 文件中添加 Canal 客户端和 Redis 客户端的依赖。以下是一个示例：

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

2. 编写 Canal 客户端代码

创建一个 Java 类来连接 Canal 服务并处理 Binlog 事件，将数据同步到 Redis：

package org.hbin.canal;

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 redis.clients.jedis.Jedis;

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

public class CanalToRedisSync {

    public static void main(String[] args) {
        // 创建 Canal 连接
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 11111);
        CanalConnector connector = CanalConnectors.newSingleConnector(address, "example", "", "");

        // 连接到 Canal 服务
        connector.connect();
        connector.subscribe(".*\\..*");
        connector.rollback();

        // 创建 Redis 客户端
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        while (true) {
            Message message = connector.getWithoutAck(100); // 获取最多 100 条记录
            long batchId = message.getId();
            int size = message.getEntries().size();
            if (batchId == -1 || size == 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                handleEntry(message.getEntries(), jedis);
            }

            connector.ack(batchId); // 提交确认
            // connector.rollback(batchId); // 处理失败, 回滚数据
        }
    }

    private static void handleEntry(List<CanalEntry.Entry> entries, Jedis jedis) {
        for (CanalEntry.Entry entry : entries) {
            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                continue;
            }

            CanalEntry.RowChange rowChange = null;
            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();
            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 (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
                if (eventType == CanalEntry.EventType.DELETE) {
                    syncDelete(rowData.getBeforeColumnsList(), jedis, entry.getHeader().getSchemaName(), entry.getHeader().getTableName());
                } else if (eventType == CanalEntry.EventType.INSERT) {
                    syncInsert(rowData.getAfterColumnsList(), jedis, entry.getHeader().getSchemaName(), entry.getHeader().getTableName());
                } else {
                    System.out.println("-------> before");
                    syncUpdate(rowData.getBeforeColumnsList(), jedis, entry.getHeader().getSchemaName(), entry.getHeader().getTableName());
                    System.out.println("-------> after");
                    syncUpdate(rowData.getAfterColumnsList(), jedis, entry.getHeader().getSchemaName(), entry.getHeader().getTableName());
                }
            }
        }
    }

    private static void syncInsert(List<CanalEntry.Column> columns, Jedis jedis, String schema, String table) {
        StringBuilder key = new StringBuilder();
        StringBuilder value = new StringBuilder();
        for (CanalEntry.Column column : columns) {
            if (column.getName().equals("id")) {
                key.append(column.getValue());
            } else {
                value.append(column.getName()).append(":").append(column.getValue()).append(",");
            }
        }
        System.out.println("Insert: " + key.toString() + " -> " + value.toString());
        jedis.hset(schema + ":" + table, key.toString(), value.toString());
    }

    private static void syncUpdate(List<CanalEntry.Column> columns, Jedis jedis, String schema, String table) {
        StringBuilder key = new StringBuilder();
        StringBuilder value = new StringBuilder();
        for (CanalEntry.Column column : columns) {
            if (column.getName().equals("id")) {
                key.append(column.getValue());
            } else {
                value.append(column.getName()).append(":").append(column.getValue()).append(",");
            }
        }
        System.out.println("Update: " + key.toString() + " -> " + value.toString());
        jedis.hset(schema + ":" + table, key.toString(), value.toString());
    }

    private static void syncDelete(List<CanalEntry.Column> columns, Jedis jedis, String schema, String table) {
        StringBuilder key = new StringBuilder();
        for (CanalEntry.Column column : columns) {
            if (column.getName().equals("id")) {
                key.append(column.getValue());
            }
        }
        System.out.println("Delete: " + key.toString());
        jedis.hdel(schema + ":" + table, key.toString());
    }
}

3. 运行和测试

3.1 启动 Canal 服务：

sh /opt/canal/bin/startup.sh

3.2 启动 Redis 服务：

确保 Redis 服务已经启动，可以在 Redis 客户端中执行以下命令检查：

redis-cli
ping

3.3 启动 Java 应用：

编译并运行上述 Java 应用，确保 Canal 服务和 MySQL 服务器正常运行。

3.4 测试数据同步：

在 MySQL 中插入、更新或删除数据，观察 Java 应用是否能够实时捕获这些变化并将数据同步到 Redis。
相关SQL如下：

drop database if exists canal;
create database canal;
use canal;

drop table if exists user;
create table user(
  `id` bigint AUTO_INCREMENT primary key,
  `name` varchar(20) NOT NULL,
  `age` tinyint DEFAULT 0,
  `detail` varchar(100) DEFAULT '',
  `create_time` date,
  `update_time` date
);

insert into user value(1, 'Tom1', 25, 'canal', '2024-11-07', '2024-11-07');
insert into user value(2, 'Tom2', 25, 'canal', '2024-11-07', '2024-11-07');
insert into user value(3, 'Tom3', 25, 'canal', '2024-11-07', '2024-11-07');
update user set age=26 where id=2;
delete from user where id=3;

输出信息：

================> binlog[binlog.000008:6390] , name[canal,user] , eventType : CREATE
================> binlog[binlog.000008:6899] , name[canal,user] , eventType : INSERT
Insert: 1 -> name:Tom1,age:25,detail:canal,create_time:2024-11-07,update_time:2024-11-07,
================> binlog[binlog.000008:7213] , name[canal,user] , eventType : INSERT
Insert: 2 -> name:Tom2,age:25,detail:canal,create_time:2024-11-07,update_time:2024-11-07,
================> binlog[binlog.000008:7527] , name[canal,user] , eventType : INSERT
Insert: 3 -> name:Tom3,age:25,detail:canal,create_time:2024-11-07,update_time:2024-11-07,
================> binlog[binlog.000008:7850] , name[canal,user] , eventType : UPDATE
-------> before
Update: 2 -> name:Tom2,age:25,detail:canal,create_time:2024-11-07,update_time:2024-11-07,
-------> after
Update: 2 -> name:Tom2,age:26,detail:canal,create_time:2024-11-07,update_time:2024-11-07,
================> binlog[binlog.000008:8193] , name[canal,user] , eventType : DELETE
Delete: 3

五、注意事项

  • 性能优化：根据实际需求调整 Canal 和 Redis 的配置，以优化性能。
  • 错误处理：在生产环境中，需要增加错误处理和重试机制，确保数据同步的可靠性。
  • 安全性：确保 Canal 和 Redis 的连接是安全的，使用适当的认证和授权机制。

六、结论

通过使用 Canal，我们可以轻松地将 MySQL 数据实时同步到 Redis、Kafka 或其他系统。这不仅提高了数据的一致性和实时性，还为应用提供了更高的性能和响应速度。希望本文对你有所帮助。

七、参考资料

binbinxyz
关注
Canal + Kafka 同步 MySQL 数据到 Redis
Zxdwr520的博客
02-23 1036
实现数据同步
使用canal同步mysql数据库到redis +实践策略模式
Mr__simon的博客
03-17 3113
背景 为提高系统性能、减小数据库压力，需要对频繁查询的数据进行缓存处理。为保证mysql和redis数据一致，网上博客一大堆缓存同步策略，最核心的问题其实还是数据修改时的数据一致性：先更新（删除）缓存再更新数据库、先更新数据库再更新(删除)缓存、延时双删等。 以上所说的这些策略主要是考虑并发场景下db-redis之间的数据最终一致，如果业务场景没有多大的并发，或缓存的数据大多是配置之类不影响业务主流程的数据，其实以上策略基本也不会有问题。如果想做到数据强一致，那就只有一种方式就是串行，但是串行必然导致性..
Canal实现MySql和redis的数据同步
Alon的博客
02-25 1828
canal是阿里开源的数据同步工具，基于bin log可以将数据库同步到其他各类数据库中，目标数据库支持mysql,postgresql,oracle,redis,MQ,ES等。
Canal Java 入门与使用
a56546的博客
06-07 4627
​ 在如今时代数据是最关键的，大的数据量势必会影响用户体验，在我的日常开发中遇到了一个类似的问题，由于数据库中数据量过于庞大造成查询效率低，决定采用redis来存取最新的数据，由于系统为其它语言编写本人并不擅长，便采取canal来通过增量的方式更新数据。下面让我们了解一下canal。以上介绍来自于官网介绍。我们可以简单把canal理解为一个同步增量数据的工具。上图为官方给出的示意图，可以看到canal把自己伪装成一个mysql的slave，架起了MySQL与其他软件之间的桥梁。canal的工作原理就是把自
SpringBoot集成Canal实现MySQL实时同步数据到Redis
weixin_46619605的博客
12-18 746
SpringBoot集成Canal实现MySQL实时同步数据到Redis
使用canal解决Mysql和Redis数据同步(TCP)
墨家巨子@俏如来
08-20 6523
之前写过一篇文章《[使用canal解决Mysql和Redis数据同步问题](https://blog.csdn.net/u014494148/article/details/123336787)》，也是使用canal实现mysql和redis的数据同步，和该篇文章不一样的是，上一篇是基于MQ实现数据同步，该篇文章是基于TCP方式来实现。
Springcloud Alibaba使用Canal将Mysql数据实时同步到Redis保证缓存的一致性
qq_43649937的博客
12-28 3075
Springcloud, Redis, Canal
java通过canal同步mysql变动数据到redis
H的博客
10-29 1602
canal 模拟 MySQL slave 的交互协议，伪装自己为 MySQL slave ，向 MySQL master 发送dump 协议，具体可以直接去看官方文档：https://github.com/alibaba/canal ，此处使用tcp协议同步数据到redis 此处使用1.1.4的版本，通过WebUI能力来配置canal 一、需要先安装好java环境与mysql 1，java安装：https://blog.csdn.net/u012946310/article/details/8197959
java使用阿里巴巴cancal直接同步mysql表到redis，包含增删改查
qq_29238373的博客
12-12 953
mysql表下的数据可以直接通过阿里的cancal同步至redis
Canal+Kafka实现mysql与redis数据准实时同步
热门推荐
yehongzhi1994的博客
08-16 1万+
Canal实战应用，canal+Kafka实现MySQL与Redis数据同步
canal同步mysql
12-12
canal同步mysql,基于springboot2.0.6,使用undertow容器，可直接运行。
【Canal】使用
依旧的博客
03-26 2272
canal，译意为水道/管道/沟渠，主要用途是基于MySQL 数据库增量日志解析，提供增量数据订阅和消费。 canal实际应用所在的位置如下图： 一、canal能做什么 canal的数据同步不是全量的，而是增量。基于binary log增量订阅和消费，canal可以做： 数据库镜像 数据库实时备份 索引构建和实时维护 业务cache(缓存)刷新 带业务逻辑的增量数据处理 二、搭建canal 在MySQL中需要创建一个用户，并授权： -- 使用命令登录：mysql -u ro...
工业级数据同步实战：基于Canal+MySQL+Redis+ES构建亿级流量高可用方案
Zyw907155124的博客
09-20 2326
"揭秘阿里开源的Canal核心原理与生产级部署方案，手把手教你构建零延迟的异构数据同步体系。本文深度解析MySQL Binlog日志解析、RabbitMQ消息削峰、Redis缓存双写一致性、Elasticsearch近实时索引等企业级技术组合，涵盖从DBA配置到SpringCloud集成全流程，提供多节点高可用架构设计与性能调优指南。已通过日均10亿级交易场景验证，配套提供云原生部署方案与可视化监控脚本。"
SpringBoot整合Canal1.1.6并同步数据到Redis（超详细和很多踩坑点）
qq_41275753的博客
04-18 3559
SpringBoot初步整合Canal
Java开发 - Canal进阶之和Redis的数据同步
CodingFire的博客
07-04 4497
本篇是对单节点的应用，但从中我们也能推断出一些关于集群的应用，不过大多数公司能搞个主从就已经是不错了，所以你能学会这个已经算是很有用了，关于ES，博主前面也讲过一些基础应用，创建一个工具类利用ES的数据模型进行存储就可以达到一个canal同时对Redis和ES的同步，如果担心出问题，可以把Canal搞成集群的形式，这个后续有时间博主再给大家做讲解。今天就到这里了，觉得不错就支持一下吧。
canal简单安装使用--转载
z7one
09-07 246
canal简单安装使用 canal简介：https://github.com/alibaba/canal 1、数据库配置 首先使用canal需要修改数据库配置 [mysqld] log-bin=mysql-bin # 开启 binlog binlog-format=ROW # 选择 ROW 模式 server_id=1 # 配置 MySQL replaction 需要定义，不要和 canal 的 slaveId 重复 创建canal数据库用户 CREATE USER canal IDENTI
Java开发 - Canal的基本用法
CodingFire的博客
06-30 5343
译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。下面这张图可以代表Canal的用途，就染我们来一起瞻仰一下：基于日志增量订阅和消费的业务包括数据库镜像数据库实时备份索引构建和实时维护(拆分异构索引、倒排索引等)业务 cache 刷新带业务逻辑的增量数据处理当前的 canal 支持源端 MySQL 版本包括 5.1.x , 5.5.x , 5.6.x , 5.7.x , 8.0.x。
Canal笔记:安装与整合Springboot模式Mysql同步Redis
Think_and_work的博客
12-05 1097
Canal笔记:安装与整合Springboot模式Mysql同步Redis
mysql进阶：canal实现mysql数据同步到redis｜实现自定义canal客户端
55555的博客
09-25 3380
canal是阿里开源的数据同步工具，基于bin log可以将数据库同步到其他各类数据库中，目标数据库支持mysql,postgresql,oracle,redis,MQ,ES等canal分成服务端deployer和客户端adapter，我们可以部署多个，同时为了方便管理还提供了一个管理端admincanal的数据同步流程如下图所示因为目前canal还不能直接通过配置就实现对redis的数据同步，因此我们需要自定义一下canal客户端，通过服务端将数据同步到客户端后，由客户端自定义操作同步到redis。
canal实现mysql数据到redis
最新发布
03-18
<think>好的，用户想了解如何通过Canal将MySQL的数据同步到Redis。首先，我需要回忆Canal的工作原理。Canal是阿里巴巴开源的MySQL数据库增量日志解析工具，它模拟MySQL slave的交互协议，将自己伪装成slave，从而获取主库的binlog，进而解析出变更事件。然后将这些事件发送到消息队列，比如Kafka，再由消费者处理这些事件，将数据同步到Redis。 接下来，用户的问题是关于具体实现方式的步骤。我需要整理出详细的步骤，从环境准备到配置，再到数据处理。可能需要分步骤说明，比如安装Canal Server、配置MySQL主库、创建同步账号、配置Canal实例，然后处理数据同步到Redis的具体方法，比如使用Canal Client或者结合Kafka。同时，需要注意Canal只能同步增量数据，不是实时的，而是准实时的，这点需要提醒用户。 另外，用户提供的引用资料中提到了一些关键点，比如需要创建MySQL同步账号，Canal的配置文件中指定binlog的位置，以及可能存在的问题比如顺序性和数据一致性问题。这些都需要在回答中提及，确保用户了解潜在的挑战和注意事项。 还需要考虑用户可能的后续问题，比如性能优化、如何处理全量数据同步、监控和错误处理机制等，虽然用户没有直接问，但可以生成相关问题供用户参考。同时，要确保回答结构清晰，步骤明确，符合用户要求的系统级指令，比如正确使用LaTeX格式，引用标识自然添加。 最后，检查回答是否符合所有要求：使用中文，正确的LaTeX格式，分步骤说明，引用资料正确标注，并生成相关问题。确保没有遗漏任何关键步骤，比如MySQL的binlog配置、Canal的instance配置，以及Redis数据写入的具体方式。可能还需要提到使用第三方工具如canal-adapter来简化流程，以及结合Kafka处理高并发情况。</think>### Canal实现MySQL到Redis数据同步的步骤 #### 1. **环境准备** - **MySQL配置** 开启binlog并设置为`ROW`模式，在`my.cnf`中添加： ```ini [mysqld] log-bin=mysql-bin binlog-format=ROW server-id=1 ``` 创建同步账号并授权[^1]： ```sql CREATE USER 'canal'@'%' IDENTIFIED BY 'canal_password'; GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'canal'@'%'; ``` - **Redis部署** 确保Redis服务已启动，建议使用集群模式应对高并发场景[^3]。 #### 2. **Canal Server部署** - 下载并解压Canal Server，修改`conf/canal.properties`： ```properties canal.serverMode = kafka # 或使用TCP直连模式 canal.mq.servers = kafka-server:9092 ``` - 配置实例文件`conf/example/instance.properties`： ```properties canal.instance.mysql.host=mysql-host canal.instance.mysql.port=3306 canal.instance.dbUsername=canal canal.instance.dbPassword=canal_password canal.instance.master.journal.name=mysql-bin.000001 # 指定binlog位置 ``` #### 3. **数据同步实现** - **方式一：Canal Client直接消费** 编写Java客户端监听Canal Server的TCP端口，解析`Entry`对象并转换为Redis操作： ```java connector.connect(); connector.subscribe(".*\\..*"); // 订阅所有表 while (true) { Message message = connector.getWithoutAck(100); for (Entry entry : message.getEntries()) { if (entry.getEntryType() == EntryType.ROWDATA) { RowChange rowChange = RowChange.parseFrom(entry.getStoreValue()); // 解析INSERT/UPDATE/DELETE事件，生成Redis命令 } } } ``` - **方式二：Kafka中转** 通过Canal将binlog推送到Kafka，再通过消费者写入Redis[^4]： 1. Canal配置为`kafka`模式，指定Topic 2. 编写Kafka消费者，解析JSON格式的binlog消息： ```python consumer = KafkaConsumer('canal_topic') for msg in consumer: data = json.loads(msg.value) if data['table'] == 'user': redis.hset('user:'+data['id'], mapping=data['columns']) ``` #### 4. **数据一致性保障** - **幂等性处理**：在Redis操作中使用`SETNX`或Lua脚本保证重复操作的幂等性 - **顺序性控制**：对同一Key的操作使用Kafka分区键保证顺序消费 - **异常重试**：在消费者中实现死信队列机制，失败消息重试3次后人工干预 #### 5. **增量与全量同步** - **增量数据**：Canal默认支持，通过binlog实时捕获 - **全量数据**：需借助额外工具（如mysqldump）导出历史数据，再通过脚本初始化到Redis ### 关键注意事项 1. **时延问题**：Canal同步为秒级延迟，需业务容忍准实时性 2. **数据结构映射**：需设计MySQL表与Redis结构（String/Hash/List）的对应关系 3. **性能瓶颈**：单线程解析binlog时，TPS上限约1万-2万，可通过多实例分库分表提升吞吐
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值