Flink CDC多表同步（mysql到mysql）

原创 已于 2025-08-04 16:27:51 修改 · 702 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
flink

当前文章被收录于：

flink
4 篇文章 3 人学习
订阅专栏 查看详情
于 2025-08-04 16:17:17 首次发布

前言

距离前一次多表同步文章到现在已经两年啦，今天更新一下方法（相对而言代码量少一点，理解起来也容易一些）

方案思路

中心思想，自定义序列化，拿到表名（自定义sink组装语句用）、主键。然后自定义msyql sink，根据表名和类型（delete还是upsert）组装不同的statement，然后批量写入，大致就是这个样子，再详细说就暴露我的代码水平了

版本

flink版本：1.20.1
flink cdc版本：3.4.0
注意：需先在sink库创建好相应的表

不多说，直接贴代码了

import com.alibaba.fastjson2.JSON;
import config.CDCConfig;
import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.cdc.connectors.mysql.source.MySqlSource;
import org.apache.flink.cdc.connectors.mysql.table.StartupOptions;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.configuration.RestOptions;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import sink.MysqlJdbcSink;

/**
 * @author csdn
 */
public class MysqlSyncMysql {
    private static final CDCConfig config = CDCConfig.load("config.yml");
    
    public static void main(String[] args) throws Exception {
        Configuration configuration = new Configuration();
        configuration.setString(RestOptions.BIND_PORT, "8081");
        // 启用空闲空间监测
        configuration.setInteger("table.exec.source.idle-timeout", 5);
        StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(configuration);
        // StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.STREAMING);
        env.enableCheckpointing(10000);
        // checkpoint超时时间
        env.getCheckpointConfig().setCheckpointTimeout(120000);
        // checkpoint最小间隔
        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(5000);
        // 同时只允许一个checkpoint
        env.getCheckpointConfig().setMaxConcurrentCheckpoints(1);

        StartupOptions startupOptions = config.getSource().getStartupOptions() == null ? StartupOptions.initial() : StartupOptions.specificOffset(config.getSource().getStartupOptions());


        // 1. 创建 MySQL CDC Source，监听整个数据库
        MySqlSource mySqlSource = MySqlSource.<String>builder()
                .hostname(config.getSource().getHost())
                .port(config.getSource().getPort())
                .databaseList(config.getSource().getDatabase())
                .tableList(config.getTables())
                .username(config.getSource().getUsername())
                .password(config.getSource().getPassword())
                .deserializer(new DynamicDeserialization())
                .build();

        DataStreamSource<String> source = env
                .fromSource(mySqlSource,WatermarkStrategy.noWatermarks(),"MySQL Source")
                .setParallelism(2);

        source
                .keyBy(jsonStr -> JSON.parseObject(jsonStr).getString("table"))
                .process(new MysqlJdbcSink(
                        config.getCdc().getBatchSize(),
                        config.getCdc().getMaxDelay(),
                        String.format("jdbc:mysql://%s:%d/%s", config.getSink().getHost(), config.getSink().getPort(), config.getSink().getDatabase()),
                        config.getSink().getUsername(),
                        config.getSink().getPassword()
                ))
                // 防止多个表占用多个slot
                .setParallelism(2)
                .uid("cdc-jdbc-sink");

        env.execute("CDC to JDBC Job");
    }
}

自定义sink

package sink;

import com.alibaba.fastjson.JSONObject;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import lombok.Data;
import org.apache.flink.cdc.connectors.shaded.com.google.common.collect.Maps;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.connector.jdbc.JdbcConnectionOptions;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.util.Collector;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MysqlJdbcSink extends KeyedProcessFunction<String, String, Void> {
    private final int batchSize;
    private final long maxDelay;
    private transient Connection connection;
    private final JdbcConnectionOptions connectionOptions;
    private transient HikariDataSource dataSource;
    private Map<String, Map<String, TableData>> batchBuffer  = Maps.newConcurrentMap();
    private Map<String, Long> timerState  = Maps.newConcurrentMap();
    

    public MysqlJdbcSink(int batchSize, long maxDelay, String jdbcUrl, String username, String password) {
        this.batchSize = batchSize;
        this.maxDelay = maxDelay;
        this.connectionOptions = new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
                .withUrl(jdbcUrl)
                .withDriverName("com.mysql.jdbc.Driver")
                .withUsername(username)
                .withPassword(password)
                .build();
    }


    @Override
    public void open(Configuration parameters) throws Exception {
        // 初始化数据库连接
        connection = createConnection();
    }

    @Override
    public void processElement(String value, Context ctx, Collector<Void> out) throws Exception {
        writeRecord(value, ctx);
    }

    public synchronized void writeRecord(String record, Context ctx) throws IOException {
        try {
            
            TableData tableData = TableData.fromJson(record);
            String tableName = tableData.getTableName();
            String uniqueKeyField = tableData.getUniqueKeyField();
            String uniqueKeyValue = String.valueOf(tableData.getData().get(uniqueKeyField));

            // 添加数据到缓存
            Map<String, TableData> buffer = batchBuffer.get(tableName);
            if (buffer == null) {
                buffer = Maps.newConcurrentMap();
                // 第一条数据时设置定时器
                long timer = ctx.timerService().currentProcessingTime() + maxDelay;
                ctx.timerService().registerProcessingTimeTimer(timer);
                timerState.put(tableName, timer);
            }
            buffer.put(uniqueKeyValue, tableData);
            batchBuffer.put(tableName, buffer);

            // 达到批次大小时触发flush
            if (buffer.size() >= batchSize) {
                log.info(tableName + " - 批次达到阈值，触发flush");
                flushWithRetry(tableName, "BATCH_SIZE");
                // 清理定时器
                Long timer = timerState.get(tableName);
                if (timer != null) {
                    ctx.timerService().deleteProcessingTimeTimer(timer);
                    timerState.remove(tableName);
                }
            }
        } catch (Exception e) {
            throw new IOException("Writing records to JDBC failed.", e);
        }
    }

    private synchronized void flushWithRetry(String tableName, String triggerType) throws Exception {
        log.info("开始flush操作: {} , 触发类型: {}", tableName, triggerType);
            
            int maxRetries = 5;
            int retryCount = 0;
            Exception lastException = null;

            while (true) {
                try {
                    Map<String, TableData> buffer = batchBuffer.get(tableName);
                    long startTime = System.currentTimeMillis();
                    flush(tableName);
                    long costTime = System.currentTimeMillis() - startTime;
                    log.info("{} - {} flush完成，处理{}条数据，耗时{}ms", tableName, triggerType, buffer.size(), costTime);
                    batchBuffer.remove(tableName);
                    break;
                } catch (SQLException e) {
                    lastException = e;
                    retryCount++;
                    if (retryCount >= maxRetries) {
                        break;
                    }
                    long sleepTime = Math.min(1000L * (1L << retryCount), 10000L);
                    log.warn("{} - 第{}次重试，等待{}ms", tableName, retryCount, sleepTime);
                    Thread.sleep(sleepTime);
                    checkAndRenewConnection();
                }
            }

            if (lastException != null) {
                log.error("{} - {} flush失败，重试{}次后放弃", tableName, triggerType, maxRetries);
                throw lastException;
            }
        log.info("flush操作完成: {}", tableName);
    }

    private void flush(String tableName) throws Exception {
        checkAndRenewConnection();
        Map<String, TableData> buffer = batchBuffer.get(tableName);
        if (buffer == null || buffer.isEmpty()) {
            return;
        }

        Map<String, PreparedStatement> stmtCache = new HashMap<>();
        try {
            connection.setAutoCommit(false);
            for (TableData record : buffer.values()) {
                // 为每条记录生成对应的SQL语句（insert/upsert/delete）
                String sql = record.generateSql();
                // 复用相同SQL的PreparedStatement，避免重复创建
                // computeIfAbsent: 如果SQL不存在，则创建新的PreparedStatement；如果存在，则直接返回
                PreparedStatement stmt = stmtCache.computeIfAbsent(sql, k -> {
                    try {
                        return connection.prepareStatement(k);
                    } catch (SQLException e) {
                        throw new RuntimeException(e);
                    }
                });

                setParameters(stmt, record);
                stmt.addBatch();
            }

            // 执行批处理
            for (PreparedStatement stmt : stmtCache.values()) {
                stmt.executeBatch();
            }
            connection.commit();
        } catch (Exception e) {
            connection.rollback();
            throw e;
        } finally {
            connection.setAutoCommit(true);
            for (PreparedStatement stmt : stmtCache.values()) {
                stmt.close();
            }
        }
    }

    // 添加重连机制和连接检查
    private void checkAndRenewConnection() throws SQLException {
        if (connection == null || connection.isClosed()) {
            connection = createConnection();
        }
    }

    private Connection createConnection() throws SQLException {
        if (dataSource == null) {
            HikariConfig hikariConfig = new HikariConfig();
            hikariConfig.setJdbcUrl(connectionOptions.getDbURL());
            // 正确处理 Optional 类型的用户名和密码
            hikariConfig.setUsername(connectionOptions.getUsername().orElse(null));
            hikariConfig.setPassword(connectionOptions.getPassword().orElse(null));

            // 连接池配置
            hikariConfig.setMinimumIdle(1);
            hikariConfig.setMaximumPoolSize(10);

            // 连接超时设置
            hikariConfig.setConnectionTimeout(30000); // 等待连接池分配连接的最大时长
            hikariConfig.setIdleTimeout(600000); // 空闲连接存活最大时间，默认600000（10分钟）
            hikariConfig.setMaxLifetime(1800000); // 连接最大生命周期，默认1800000（30分钟）

            dataSource = new HikariDataSource(hikariConfig);
        }
        return dataSource.getConnection();
    }

    @Override
    public void close() throws SQLException {
        if(connection != null) {
            connection.close();
        }
        if (dataSource != null) {
            dataSource.close();
        }
    }

    @Override
    public synchronized void onTimer(long timestamp, OnTimerContext ctx, Collector<Void> out) throws Exception {
        String tableName = ctx.getCurrentKey();
        log.info("{} - 定时器触发flush，时间: {}", tableName, LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        if(batchBuffer.containsKey(tableName) && !batchBuffer.get(tableName).isEmpty()) {
            // 定时器触发的flush也会遵循锁机制，如果获取不到锁会跳过
            flushWithRetry(tableName, "TIMER");
            timerState.remove(tableName);
        }
    }

    private void setParameters(PreparedStatement stmt, TableData record) throws SQLException {
        String operation = record.getOperation();
        String primaryKeyField = record.getUniqueKeyField();
        // 与 generateSql 方法中的删除判断逻辑保持一致
        if ("d".equalsIgnoreCase(operation) || "-d".equalsIgnoreCase(operation) || "-u".equalsIgnoreCase(operation) || "delete".equalsIgnoreCase(operation)) {
            stmt.setObject(1, record.getData().get(primaryKeyField));
        } else {
            // insert和update使用相同的参数设置方式
            int paramIndex = 1;
            for (Object value : record.getData().values()) {
                stmt.setObject(paramIndex++, value);
            }
        }
    }

    /**
     * 定义一个数据结构来封装CDC数据
     */
    @Data
    public static class TableData {
        private String tableName;
        private String operation;
        private String uniqueKeyField;
        private Map<String, Object> data;


        /**
         * 从JSON字符串创建TableData的工厂方法
         */
        public static TableData fromJson(String jsonStr) {
            JSONObject json = JSONObject.parseObject(jsonStr);
            TableData tableData = new TableData();
            tableData.setTableName(json.getString("table"));
            tableData.setOperation(json.getString("op"));
            tableData.setUniqueKeyField(json.getString("primaryKeyField"));
            tableData.setData(json.getJSONObject("data"));
            return tableData;
        }

        /**
         * 生成SQL语句
         */
        public String generateSql() {
            if ("d".equalsIgnoreCase(operation) || "-d".equalsIgnoreCase(operation) || "-u".equalsIgnoreCase(operation) || "delete".equalsIgnoreCase(operation)) {
                if (uniqueKeyField == null) {
                    throw new IllegalStateException("Unique key is required for delete operation");
                }
                return generateDeleteSql();
            } else {
                // 对于insert和update，根据uniqueKeyField决定使用insert还是upsert
                return uniqueKeyField == null ? generateInsertSql() : generateUpsertSql();
            }
        }

        private String generateInsertSql() {
            String fields = data.keySet().stream()
                    .map(field -> "`" + field + "`")
                    .collect(Collectors.joining(","));

            String placeholders = String.join(",", Collections.nCopies(data.size(), "?"));

            return String.format(
                    "INSERT INTO `%s` (%s) VALUES (%s)",
                    tableName,
                    fields,
                    placeholders
            );
        }

        private String generateUpsertSql() {
            String fields = data.keySet().stream()
                    .map(field -> "`" + field + "`")
                    .collect(Collectors.joining(","));

            String placeholders = String.join(",", Collections.nCopies(data.size(), "?"));

            String updateClause = data.keySet().stream()
                    .filter(field -> !field.equals(uniqueKeyField))
                    .map(field -> "`" + field + "`=VALUES(`" + field + "`)")
                    .collect(Collectors.joining(","));

            return String.format(
                    "INSERT INTO `%s` (%s) VALUES (%s) ON DUPLICATE KEY UPDATE %s",
                    tableName,
                    fields,
                    placeholders,
                    updateClause
            );
        }

        private String generateDeleteSql() {
            return String.format("DELETE FROM %s WHERE %s=?", tableName, uniqueKeyField);
        }
    }
}

自定义序列化

import com.alibaba.fastjson2.JSONObject;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.cdc.connectors.shaded.org.apache.kafka.connect.data.Field;
import org.apache.flink.cdc.connectors.shaded.org.apache.kafka.connect.data.Schema;
import org.apache.flink.cdc.connectors.shaded.org.apache.kafka.connect.data.Struct;
import org.apache.flink.cdc.connectors.shaded.org.apache.kafka.connect.source.SourceRecord;
import org.apache.flink.cdc.debezium.DebeziumDeserializationSchema;
import org.apache.flink.util.Collector;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 动态解析 MySQL CDC 数据，提取表名和字段
 * @author csdn
 */
public class DynamicDeserialization implements DebeziumDeserializationSchema<String> {

    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    public void deserialize(SourceRecord record, Collector<String> collector) throws Exception {
        Struct value = (Struct) record.value();
        if (value == null) {
            return;
        }
        Struct source = value.getStruct("source");
        String tableName = source.getString("table");
        Struct after = value.getStruct("after");
        Struct before = value.getStruct("before");
        // 获取操作类型（c = create, u = update, d = delete）
        String op = value.getString("op");
        // 获取主键字段
        String primaryKeyField = getPrimaryKey(record);

        // 没有主键的操作跳过
        if (primaryKeyField == null) {
            System.out.println("Table " + tableName + " has no primary key, skipping processing.");
            return;
        }

        // 删除用 `before`，其余用 `after`
        Struct dataStruct = (op.equals("d")) ? before : after;

        // 构造 JSON 数据
        JSONObject json = new JSONObject();
        json.put("table", tableName);
        json.put("op", op);
        json.put("primaryKeyField", primaryKeyField);

        if (dataStruct == null) {
            return;
        }

        // 获取字段列表
        Schema schema = dataStruct.schema();
        List<String> fieldNames = schema.fields().stream().map(Field::name).collect(Collectors.toList());

        JSONObject data = new JSONObject();
        for (String fieldName : fieldNames) {
            Object fieldValue = dataStruct.get(fieldName);

            // 处理 DATETIME 类型，把时间戳转换成 "yyyy-MM-dd HH:mm:ss"
            if (fieldValue instanceof Long && fieldName.toLowerCase().contains("time")) {
                fieldValue = DATE_FORMAT.format(new Date((Long) fieldValue));
            }
            data.put(fieldName, fieldValue);
        }
        json.put("data", data);
        collector.collect(json.toString());

    }

    @Override
    public TypeInformation<String> getProducedType() {
        return TypeInformation.of(String.class);
    }


    /**
     * 从 SourceRecord.key() 获取主键字段名
     */
    private String getPrimaryKey(SourceRecord record) {
        Object key = record.key();
        if (key instanceof Struct) {
            Struct keyStruct = (Struct) key;
            Schema keySchema = keyStruct.schema();
            // 获取 keySchema 下所有字段（主键字段）
            List<Field> keyFields = keySchema.fields();
            if (!keyFields.isEmpty()) {
                // 假设主键只有一个，返回第一个字段名
                return keyFields.get(0).name();
            }
        }
        return null;
    }
}

配置类

package config;

import lombok.Data;
import org.apache.flink.shaded.jackson2.org.yaml.snakeyaml.Yaml;

import java.io.InputStream;

@Data
public class CDCConfig {
    private SourceConfig source;
    private SinkConfig sink;
    private PoolConfig pool;
    private CdcConfig cdc;
    private String tables;
    
    @Data
    public static class SourceConfig {
        private String host;
        private int port;
        private String database;
        private String username;
        private String password;
        private String startupOptions;
    }
    
    @Data
    public static class SinkConfig {
        private String host;
        private int port;
        private String database;
        private String username;
        private String password;
    }
    
    @Data
    public static class PoolConfig {
        private int minimumIdle = 1;
        private int maximumPoolSize = 10;
        private long connectionTimeout = 30000;
        private long idleTimeout = 600000;
        private long maxLifetime = 1800000;
        private long validationTimeout = 5000;
    }
    
    @Data
    public static class CdcConfig {
        private int batchSize = 100;
        private long maxDelay = 1000;
        private int parallelism = 2;
        private int maxRetries = 3;
    }
    
    public static CDCConfig load(String configPath) {
        try (InputStream input = CDCConfig.class.getClassLoader().getResourceAsStream(configPath)) {
            Yaml yaml = new Yaml();
            return yaml.loadAs(input, CDCConfig.class);
        } catch (Exception e) {
            throw new RuntimeException("Failed to load configuration: " + configPath, e);
        }
    }
}

config.yml

source:
  host: localhost
  port: 33306
  database: lidy
  username: root
  password: Ldy@

sink:
  host: localhost
  port: 33306
  database: flinktest
  username: root
  password: Ldy@

tables: lidy.policy_info,lidy.policy_info_key_words

pool:
  minimumIdle: 1
  maximumPoolSize: 10
  connectionTimeout: 30000
  idleTimeout: 600000
  maxLifetime: 1800000
  validationTimeout: 5000

cdc:
  batchSize: 100
  maxDelay: 1000
  parallelism: 2
  maxRetries: 3
标签
#flink #mysql #实时大数据 #大数据
最新版Flink CDC MySQL同步MySQL（一）_flink 连接mysql
2401_84181403的博客
04-14 2458
得这些内容对你有帮助，可以添加VX：vip204888 （备注大数据获取）**[外链图片转存中…(img-bjg180DR-1713035295230)]
flink-cdc同步数据到doris中
warrah 南极狼
02-19 1868
此时任务可以正常执行了，数据也可以正常过来了。可以看到下面，要获取acc的全部表，但是有一些是做了分表，需合并到其中doris的一张表里面，这个规则是有效的，开始。从下面的yml脚本可以看到，并没有doris中创建eayc_user表，应该是flink-cdc自动创建的。如果mysql的表没有主键，则报下面的错误，这个时候就需要修正原mysql表数据。默认也是1，我也改成了8，启动之后，没有报下面的错误，但是之前执行的任务没有了。默认为1，slot不够，就报下面的错误，因为是16C32G，于是我改成了8，
flink+flinkcdc+同步(MYSQL到MYSQL)实践
RodJohnsonDoctor的专栏
08-24 2801
通过Flink +FlinkCDC实现MYSQL到MYSQL的同步【单表，多表】
FlinkCDC第三部分-同步mysql到mysql，ctrl就完事~（flink版本1
2401_87390048的博客
09-27 2782
需要注意的是，scan.fetch-size 属性值是一个相对的配置，不同的数据源和查询场景可能有不同的最佳值。请注意，为了准确分析火焰图，建议在负载较高的情况下生成火焰图，并保持足够的监视时间。考虑网络环境和带宽限制：如果数据源位于远程服务器或网络环境较差，可以选择适当较小的 fetch size 值，以减少网络传输的负载，避免出现大量的网络超时和传输失败情况。考虑数据源的吞吐量：如果你的数据源的吞吐量较高，网络延迟较低，可以适当增大 scan.fetch-size 的值，以减少网络往返次数和请求开销。
FlinkCDC第三部分-同步mysql到mysql，ctrl就完事~（flink版本1.16.2）
qq_43511677的博客
07-06 9107
需要注意的是，BEGIN STATEMENT SET 和 COMMIT 语句是 Flink SQL 的扩展语法，它们可能在某些特定的 Flink 版本或环境中才可用。通过设置适当的检查点间隔，可以在容忍一定故障的同时，控制检查点的频率和资源使用。如果在 BEGIN STATEMENT SET 和 COMMIT 之间的任何一条语句执行失败，整个事务将回滚，即已经执行的语句会被撤销。使用这个语句的好处是可以根据作业的需求和资源情况调整这些属性，以获得最佳的性能和资源利用率。
基于Flink CDC实时同步数据（MySQL到MySQL）
热门推荐
04-22 2万+
Flink FlinkCDC 实时ETL
Flinkjar开发 CDC 实时mysql到mysql
letterss的博客
06-09 3944
CDC 的全称是 Change Data Capture ，在广义的概念上，只要是能捕获数据变更的技术，我们都可以称之为 CDC。目前通常描述的 CDC 技术主要面向数据库的变更，是一种用于捕获数据库中数据变更的技术。[mysqld][mysqld]重启数据库。
Golang代码示例：调用flink cdc实现MySQL到Doris单表及多表的数据同步
学亮编程手记
01-23 1061
【代码】Golang代码示例：调用flink cdc实现MySQL到Doris单表及多表的数据同步。
flink cdc MySQL2Doris 案例分享 解决分库多表同步
fengjian的博客
11-18 4000
使用flink cdc，完成mysql 多库 多表同时同步到doris中
Java纯代码方式，通过flink cdc实现MySQL到Doris无侵入多表数据同步
Gogym的博客
11-27 347
这里以spring boot 工程为例，先说一下原理，很简单，就是通过flink 监听mysql binlog，同步方式有很多种，flink cdc 算是比较方便好用的一种方式，只要是简单，并且可以做到对业务没有入侵。mysql、doris、flink是什么就不介绍了，能看到这个文章，说明已经了解过。我们项目有时候需要把mysql数据库的数据同步到其他数据库，这里以doris为例。如果数据变更，会读取到变更，然后通过处理，同步到指定的数据库中。2、同步逻辑，关键代码，注释很全，自行参考即可。
Flink Doris Connector 示例：使用 Flink CDC 接入多表或整库（flink jar方式提交任务）
学亮编程手记
01-06 1836
【代码】Flink Doris Connector 示例：使用 Flink CDC 接入多表或整库（flink jar方式提交任务）
Flink CDC整库同步（多表异构同步）
qq_36062467的博客
11-30 1万+
flinkcdc整库（多表异构）同步方案
CDC 实时入湖方案：MySQL＞Flink CDC＞Kafka ＆ Schema Registry＞Hudi ( HoodieMultiTableStreamer )
Laurence的技术博客
05-19 2212
本方案的技术链路为：使用 Flink CDC 将 MySQL 的 CDC 数据 （Avro 格式）接入到 Kafka ，然后通过 Hudi 的 HoodieMultiTableStreamer 将摄取的 CDC 数据写入到 Hudi 表中。整个链路由 Confluent Schema Registry 控制 Schema 的变更。本文和《CDC 实时入湖方案：MySQL > Flink CDC > Kafka ＆ Schema Registry > Hudi ( Flink Connector ) 》介绍的
FlinkCDC实战：将 MySQL 数据同步至 ES
2509_94083075的博客
01-07 906
CDC (Change Data Capture) 是 变更数据获取的简称。核心思想是监测并捕获数据库的变动(数据或数据表的插入、更新以及删除等)，将这些变更按发生的顺序完整地记录下来，写入到消息中间件中以供其他服务进行订阅并消费。Flink 社区开发了 flink-cdc-connectors 组件，这个一个可以直接从 MySQL、PostgreSQL等数据库直接读取全量数据和增量变更数据的source 组件。
第3.4章：StarRocks数据导入--Flink Connector与CDC秒级数据同步
流木的博客
02-11 1万+
Flink作为当前流行的流式计算框架，在对接StarRocks时，若直接使用JDBC的方式“流式”写入数据，对StarRocks是不友好的，StarRocks作为一款MVCC的数据库，其导入的核心思想还是“攒微批+降频率”。为此，StarRocks单独开发了flink-connector-starrocks，其内部实现仍是通过对数据缓存攒批后执行Stream Load导入。 StarRocks Flink Connector目前也已开源，其github地址为： GitHub - StarRocks/fl
Flink CDC 3.0 实战：构建实时数据管道，从MySQL到Elasticsearch的流式同步与监控
最新发布
weixin_30632883的博客
05-19 430
本文详细解析了Flink CDC 3.0的核心特性，包括全量+增量一体化读取、精确一次语义等，并实战演示了如何构建从MySQL到Elasticsearch的实时数据管道。通过环境准备、高可用配置、同步流程实现及性能调优等步骤，帮助开发者掌握流式数据同步与监控的最佳实践。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值