java整合canal 实现数据同步

最新推荐文章于 2024-08-29 16:21:31 发布
最新推荐文章于 2024-08-29 16:21:31 发布
阅读量3.1k 收藏 7
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zk86547462/article/details/108907358
版权

官方演示

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

package com.alibaba.otter.canal.sample;
import java.net.InetSocketAddress;
import java.util.List;


import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.common.utils.AddressUtils;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.protocol.CanalEntry.Column;
import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
import com.alibaba.otter.canal.protocol.CanalEntry.RowData;


public class SimpleCanalClientExample {


public static void main(String args[]) {
    // 创建链接
    CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress(AddressUtils.getHostIp(),
                                                                                        11111), "example", "", "");
    int batchSize = 1000;
    int emptyCount = 0;
    try {
        connector.connect();
        connector.subscribe(".*\\..*");
        connector.rollback();
        int totalEmptyCount = 120;
        while (emptyCount < totalEmptyCount) {
            Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
            long batchId = message.getId();
            int size = message.getEntries().size();
            if (batchId == -1 || size == 0) {
                emptyCount++;
                System.out.println("empty count : " + emptyCount);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            } else {
                emptyCount = 0;
                // System.out.printf("message[batchId=%s,size=%s] \n", batchId, size);
                printEntry(message.getEntries());
            }

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

        System.out.println("empty too many times, exit");
    } 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();
        System.out.println(String.format("================&gt; binlog[%s:%s] , name[%s,%s] , eventType : %s",
                                         entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                                         entry.getHeader().getSchemaName(), entry.getHeader().getTableName(),
                                         eventType));

        for (RowData rowData : rowChage.getRowDatasList()) {
            if (eventType == EventType.DELETE) {
                printColumn(rowData.getBeforeColumnsList());
            } else if (eventType == EventType.INSERT) {
                printColumn(rowData.getAfterColumnsList());
            } else {
                System.out.println("-------&gt; before");
                printColumn(rowData.getBeforeColumnsList());
                System.out.println("-------&gt; after");
                printColumn(rowData.getAfterColumnsList());
            }
        }
    }
}

private static void printColumn(List<Column> columns) {
    for (Column column : columns) {
        System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
    }
}

}

https://blog.csdn.net/qq_43791139/article/details/107752629

springboot使用

   <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.7</version>
        </dependency>
               <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
            <version>1.1.3</version>
        </dependency>

package com.example.demo.client;
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.google.protobuf.InvalidProtocolBufferException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;


import javax.annotation.Resource;
import javax.sql.DataSource;
import java.net.InetSocketAddress;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
@Component
public class CanalClient {
    Logger logger = LoggerFactory.getLogger(CanalClient.class);
    //sql队列
    private Queue<String> SQL_QUEUE = new ConcurrentLinkedQueue<>();
    @Resource
    private DataSource dataSource;
    /**
     * canal入库方法
     */
    public void run() {
        /*master服务器地址，以及开启的端口号，实例名instance.properties文件中不修改这用这个默认的，用户名密码使用远程连接账号的，同前配置文件*/
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("106.55.168.234",
                11111), "example", "", "");
        int batchSize = 1000;
        try {
            while (true) {
                logger.info("-------------canal开始连接-------------");
                try {
                    connector.connect();
                    connector.subscribe(".*\\..*");
                    connector.rollback();
                } catch (Exception e) {
                    logger.info("-------------canal连接失败,五分钟后尝试重新连接-------------");
                    try {
                        Thread.sleep(300000);
                    } catch (InterruptedException e1) {
                        logger.error(e1.getMessage());
                    }
                }
                logger.info("-------------canal连接成功-------------");
                break;
            }
            while (true) try {
                /*从master拉取数据batchSize条记录*/
                Message message = connector.getWithoutAck(batchSize);
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    Thread.sleep(10000);
                } else {
                    dataHandle(message.getEntries());
                }
                /*提交ack确认*/
                connector.ack(batchId);
                /*设置队列sql语句执行最大值*/
                if (SQL_QUEUE.size() >= 1) {
                    executeQueueSql();
                }
            } catch (Exception e) {
                e.printStackTrace();
                logger.error("canal入库方法" + e.getMessage());
            }

        } finally {
            connector.disconnect();
        }
    }
    /**
     * 模拟执行队列里面的sql语句
     */
    public void executeQueueSql() {
        int size = SQL_QUEUE.size();
        for (int i = 0; i < size; i++) {
            String sql = SQL_QUEUE.poll();
            System.out.println("[sql]----> " + sql);
            this.execute(sql.toString());
        }
    }
    /**
     * 数据处理
     *
     * @param entrys
     */
    private void dataHandle(List<Entry> entrys) throws
            InvalidProtocolBufferException {
        for (Entry entry : entrys) {
            if (EntryType.ROWDATA == entry.getEntryType()) {
                RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
                EventType eventType = rowChange.getEventType();
                if (eventType == EventType.DELETE) {
                    saveDeleteSql(entry);
                } else if (eventType == EventType.UPDATE) {
                    saveUpdateSql(entry);
                } else if (eventType == EventType.INSERT) {
                    saveInsertSql(entry);
                }
            }
        }
    }
    /**
     * 保存更新语句
     *
     * @param entry
     */
    private void saveUpdateSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> newColumnList = rowData.getAfterColumnsList();
                StringBuffer sql = new StringBuffer("update " +
                        entry.getHeader().getTableName() + " set ");
                for (int i = 0; i < newColumnList.size(); i++) {
                    sql.append(" " + newColumnList.get(i).getName()
                            + " = '" + newColumnList.get(i).getValue() + "'");
                    if (i != newColumnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(" where ");
                List<Column> oldColumnList = rowData.getBeforeColumnsList();
                for (Column column : oldColumnList) {
                    if (column.getIsKey()) {
//暂时只支持单一主键
                        sql.append(column.getName() + "=" + column.getValue());
                        break;
                    }
                }
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }
    /**
     * 保存删除语句
     *
     * @param entry
     */
    private void saveDeleteSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> columnList = rowData.getBeforeColumnsList();
                StringBuffer sql = new StringBuffer("delete from " +
                        entry.getHeader().getTableName() + " where ");
                for (Column column : columnList) {
                    if (column.getIsKey()) {
//暂时只支持单一主键
                        sql.append(column.getName() + "=" + column.getValue());
                        break;
                    }
                }
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }
    /**
     * 保存插入语句
     *
     * @param entry
     */
    private void saveInsertSql(Entry entry) {
        try {
            RowChange rowChange = RowChange.parseFrom(entry.getStoreValue());
            List<RowData> rowDatasList = rowChange.getRowDatasList();
            for (RowData rowData : rowDatasList) {
                List<Column> columnList = rowData.getAfterColumnsList();
                StringBuffer sql = new StringBuffer("insert into " +
                        entry.getHeader().getTableName() + " (");
                for (int i = 0; i < columnList.size(); i++) {
                    sql.append(columnList.get(i).getName());
                    if (i != columnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(") VALUES (");
                for (int i = 0; i < columnList.size(); i++) {
                    sql.append("'" + columnList.get(i).getValue() + "'");
                    if (i != columnList.size() - 1) {
                        sql.append(",");
                    }
                }
                sql.append(")");
                SQL_QUEUE.add(sql.toString());
            }
        } catch (InvalidProtocolBufferException e) {
            e.printStackTrace();
        }
    }
    /**
     * 入库
     * @param sql
     */
    public void execute(String sql) {
        Connection con = null;
        try {
            if(null == sql) return;
            con = dataSource.getConnection();
            QueryRunner qr = new QueryRunner();
            int row = qr.execute(con, sql);
            System.out.println("update: "+ row);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DbUtils.closeQuietly(con);
        }
    }
}

启动类

package com.example.demo;

import com.example.demo.client.CanalClient;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
    @Resource
    private CanalClient canalClient;
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... strings) throws Exception {
        /*启动canal客户端监听*/
        canalClient.run();
    }
}
拾 -.-
关注
centos 7安装canal并使用java代码结合canal监听数据库
qq_15145603的博客
08-17 984
Canal是阿里巴巴的数据同步工具，最初主要为了应对杭州和美国的双机房部署问题，目前也是国内互联网企业经常使用的数据增量同步解决方案。Canal是一种开源的、基于数据库的分布式数据变更日志解析和传输的工具。它主要用于实时同步数据库的数据变更到其他系统，例如缓存、搜索引擎、数据仓库等。Canal通过解析数据库的二进制日志（binlog），获取数据库的数据变更信息，并将这些变更信息按照事务的顺序进行组织和传输。
python can总线_[MicroPython]TPYBoard v102 CAN总线通信
weixin_35500243的博客
03-01 388
0x00前言CAN是控制器局域网络(Controller Area Network, CAN)的简称，是ISO国际标准化的串行通信协议。CAN总线结构简单，只需2根线与外部相连，并且内部集成了错误探测和管理模块。本篇文章以TPYBoard v102开发板为例，为大家介绍一下如何使用STM32自带的CAN控制器，来实现两个开发板之间的CAN通讯。0x01实验器材TPYBoard v102开发板2...
java整合Canal实现数据库监听(附完整的踩坑总结)
2301_77516476的博客
04-20 2358
如下图所示:需要检查下地址的配置,确认能ping通如果可以ping通但是仍然无法连接,查看是否是虚拟机的防火墙是否打开,11111端口可能被拦截。
SpringBoot整合Canal实现双写一致性
最新发布
dibdoehn的博客
08-29 687
基于Canal实现Redis和MySQL的双写一致性
【Canal】使用
依旧的博客
03-26 2198
canal，译意为水道/管道/沟渠，主要用途是基于MySQL 数据库增量日志解析，提供增量数据订阅和消费。 canal实际应用所在的位置如下图： 一、canal能做什么 canal的数据同步不是全量的，而是增量。基于binary log增量订阅和消费，canal可以做： 数据库镜像 数据库实时备份 索引构建和实时维护 业务cache(缓存)刷新 带业务逻辑的增量数据处理 二、搭建canal 在MySQL中需要创建一个用户，并授权： -- 使用命令登录：mysql -u ro...
canal+spring的集成
04-25
canal+spring的集成和封装，灵活使用,整合内容包含服务方，消费方 canal消费方采用策略模式，将不同表的数据分配到相应的Process类中。定义BaseProcess抽象类，包含processInsert、processUpdate、processDelete三个抽象方法，分别用于处理三种类型的数据操作。
Java开发案例-springboot-36-整合canal实现数据同步-源代码+文档.rar
05-31
Java开发案例-springboot-36-整合canal实现数据同步-源代码+文档.rar Java开发案例-springboot-36-整合canal实现数据同步-源代码+文档.rar Java开发案例-springboot-36-整合canal实现数据同步-源代码+文档.rar Java...
springboot整合canal
02-23
SpringBoot整合Canal是将阿里巴巴开源的数据库实时变更数据订阅与推送组件Canal与SpringBoot框架结合，以实现高效的数据同步。Canal主要用于数据库的实时增量数据同步，它能够监听MySQL数据库的binlog事件，当数据库...
springboot整合canal实现与mysql数据实时同步
xyouzi的博客
05-27 1135
以下有关linux操作都是基于docker容器的 一、Canal介绍 1、介绍 canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL。 2、Canal环境搭建 canal的原理是基于mysql binlog技术，所以这里一定需要开启mysql的binlog写入功能 （1）检查binlog功能是否有开启 mysql> show variables like ‘log_bin’; ±--------------±----
SpringBoot整合Canal实现数据同步到ElasticSearch
2401_84167005的博客
04-08 639
外链图片转存中…(img-z53ehebC-1712535332576)][外链图片转存中…(img-l65Hriws-1712535332577)]
canal实现mysql数据同步
m0_67391401的博客
07-31 441
canal是实现mysql数据备份，异地灾备，异地数据同步等重要的中间件，在实际的业务场景中有着广泛的使用，本文基于小编所在项目中一个异地数据同步的场景为例，通过案例演示下利用canal实现mysql数据同步的过程。...
jnaCan:Java 的 CAN 总线，使用 JNA 访问 Linux SocketCan API
06-02
大麻 Java 的 CAN 总线，使用 JNA 访问 Linux SocketCan API。 本软件为Alpha品质，请勿用于生产。 通过使用Java Native Access，无需编写本机代码即可访问SocketCan API。 这个项目是纯 Java 的（从技术上讲，JNA jar 包含一些小型现成的本机二进制库）。 该库目前仅支持原始罐头模式。 读取和写入调用将被阻塞。 但是，有套接字选项设置 SO_RCVTIMEO 值，以便读取超时。 包括 Netty 4.0 通道实现。 jnaCan 在 GNU LESSER GENERAL PUBLIC LICENSE Version 3 下获得许可，请参阅 LICENSE.txt jnaerator 开关 请注意，Linux C 头文件中定义的某些常量在您的平台上可能不同，因此生成的 Java 代码可能无法正常工作。 我已经在
canal与spring整合实例demo
09-21
canal与spring整合demo，整合内容包含服务方，消费方 canal消费方采用策略模式，将不同表的数据分配到相应的Process类中。定义BaseProcess抽象类，包含processInsert、processUpdate、processDelete三个抽象方法，分别用于处理三种类型的数据操作。
canal数据binlog同步demo
04-07
canal订阅监听mysql binlog日志，消费订阅日志demo。 canal\mysql\同步。
Android java开发can通信 接收和发送can 信息 标准/扩展帧
weixin_45220510的博客
12-27 2711
Android java开发can通信 接收和发送can 信息 标准/扩展帧。
Java can接口使用
oThrowsException的博客
09-06 388
https://my.oschina.net/yojiang/blog/5578038
【开发日志1-2】Java can接口使用
m199811的博客
03-06 1422
Java can接口使用 CAN是一种工业现场总线的名称。一般普通计算机上没有这个接口。它是串行通信方式，但不是一般说的串口。接口外观可以是15针D型口，也可以RJ45接口，看用在什么场合了。项目需要用到can口找了很多地方，发现Java对这一块的支持很薄弱最后只能采用命令行脚本来执行；
汽车CAN通信基础知识-Java之Socket通信实战
Tiger的专栏
07-24 3315
目录 1.理解JavaSocket通信原理 2.定义数据通信数据规则 3.实现Socket通信 3.1创建Socket并主动连接服务器 3.2通过OutpuStream写入数据给服务器 3.3起线程通过InputStream从服务器不断的读取数据流 3.4关闭资源 1.理解JavaSocket通信原理 https://blog.csdn.net/ahou2468/article/...
Java接收can信号数据处理
信徒博客
07-30 6181
package cn.com.lf; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketException; import java.sql.SQLException; p...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值