canal+mq将数据同步到redis中的一些类型转换问题

在将 Canal 捕获到的数据库变更同步到 RabbitMQ 时,通常需要将变更事件的数据从 Java 对象转换为一种通用的数据格式,如 JSON。这样可以确保数据在不同系统之间传递时的兼容性。以下是将 Canal 数据同步到 RabbitMQ 并进行数据类型转换的示例代码。

1. Canal 客户端从 MySQL 读取变更

首先,编写 Canal 客户端以从 MySQL 读取数据库变更,并将变更数据转换为 JSON 格式,然后发送到 RabbitMQ。

2. 依赖库

在项目中添加了所需的依赖库,如 Canal 客户端、RabbitMQ 客户端和 JSON 处理库(例如 Jackson)。

3. Canal 客户端发送数据到 RabbitMQ

编写 Canal 客户端,读取 MySQL 数据库变更并将其发送到 RabbitMQ:

java 复制代码
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 com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.net.InetSocketAddress;
import java.util.HashMap;
import java.util.Map;

public class CanalToRabbitMQ {
    private final static String QUEUE_NAME = "db_changes";
    private final static ObjectMapper objectMapper = new ObjectMapper();

    public static void main(String[] args) {
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("127.0.0.1", 11111), "example", "", "");

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");

        try (Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);

            connector.connect();
            connector.subscribe("mydatabase.mytable");
            connector.rollback();

            while (true) {
                Message message = connector.getWithoutAck(100); // 获取指定数量的数据
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId != -1 && size > 0) {
                    for (CanalEntry.Entry entry : message.getEntries()) {
                        if (entry.getEntryType() == CanalEntry.EntryType.ROWDATA) {
                            CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
                            for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
                                Map<String, Object> dataMap = new HashMap<>();
                                if (rowChange.getEventType() == CanalEntry.EventType.INSERT) {
                                    dataMap.put("eventType", "INSERT");
                                    for (CanalEntry.Column column : rowData.getAfterColumnsList()) {
                                        dataMap.put(column.getName(), column.getValue());
                                    }
                                } else if (rowChange.getEventType() == CanalEntry.EventType.UPDATE) {
                                    dataMap.put("eventType", "UPDATE");
                                    for (CanalEntry.Column column : rowData.getAfterColumnsList()) {
                                        dataMap.put(column.getName(), column.getValue());
                                    }
                                } else if (rowChange.getEventType() == CanalEntry.EventType.DELETE) {
                                    dataMap.put("eventType", "DELETE");
                                    for (CanalEntry.Column column : rowData.getBeforeColumnsList()) {
                                        dataMap.put(column.getName(), column.getValue());
                                    }
                                }
                                
                                // 将数据转换为 JSON 字符串
                                String jsonMessage = objectMapper.writeValueAsString(dataMap);
                                
                                // 将 JSON 字符串发送到 RabbitMQ
                                channel.basicPublish("", QUEUE_NAME, null, jsonMessage.getBytes("UTF-8"));
                            }
                        }
                    }
                }
                connector.ack(batchId); // 提交确认
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            connector.disconnect();
        }
    }
}

4. RabbitMQ 消费者同步到 Redis

编写 RabbitMQ 消费者,从 RabbitMQ 队列中消费消息并同步到 Redis:

复制代码
java 复制代码
import com.rabbitmq.client.*;
import redis.clients.jedis.Jedis;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class RabbitMQToRedis {
    private final static String QUEUE_NAME = "db_changes";
    private final static ObjectMapper objectMapper = new ObjectMapper();

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        Jedis jedis = new Jedis("127.0.0.1");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            try {
                // 将 JSON 字符串转换为 Map 对象
                Map<String, Object> dataMap = objectMapper.readValue(message, Map.class);

                // 处理数据并同步到 Redis
                String eventType = (String) dataMap.get("eventType");
                if ("INSERT".equals(eventType) || "UPDATE".equals(eventType)) {
                    // 假设主键是 id
                    String id = (String) dataMap.get("id");
                    jedis.set(id, message);
                } else if ("DELETE".equals(eventType)) {
                    String id = (String) dataMap.get("id");
                    jedis.del(id);
                }

                System.out.println("Received and processed: " + message);
            } catch (Exception e) {
                e.printStackTrace();
            }
        };

        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {});

        // 保持程序运行
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                channel.close();
                connection.close();
                jedis.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }));
    }
}

代码解析

  1. Canal 客户端

    • 连接到 Canal Server,订阅指定数据库和表的变更。
    • 从 binlog 中解析变更事件。
    • 将变更事件转换为 JSON 格式。
    • 将 JSON 消息发送到 RabbitMQ。
  2. RabbitMQ 消费者

    • 连接到 RabbitMQ 队列,消费消息。
    • 将 JSON 消息解析为 Map 对象。
    • 根据事件类型(INSERT、UPDATE、DELETE)同步数据到 Redis。

通过这种方式,Canal 可以将数据库变更事件捕获并转换为 JSON 格式,推送到 RabbitMQ,然后由 RabbitMQ 消费者同步到 Redis。这种方法确保了数据在不同系统之间传递时的兼容性和灵活性。

相关推荐
代码栈上的思考8 分钟前
深入解析 Java 内存可见性问题:从现象到 volatile 解决方案
java·开发语言
切糕师学AI10 分钟前
如何建立针对 .NET Core web 程序的线程池的长期监控
java·前端·.netcore
零千叶1 小时前
【面试】AI大模型应用原理面试题
java·设计模式·面试
坐吃山猪6 小时前
SpringBoot01-配置文件
java·开发语言
我叫汪枫6 小时前
《Java餐厅的待客之道:BIO, NIO, AIO三种服务模式的进化》
java·开发语言·nio
yaoxtao6 小时前
java.nio.file.InvalidPathException异常
java·linux·ubuntu
Swift社区8 小时前
从 JDK 1.8 切换到 JDK 21 时遇到 NoProviderFoundException 该如何解决?
java·开发语言
DKPT8 小时前
JVM中如何调优新生代和老生代?
java·jvm·笔记·学习·spring
phltxy8 小时前
JVM——Java虚拟机学习
java·jvm·学习