Canal进行mysql数据同步

最新推荐文章于 2025-03-12 17:03:24 发布
最新推荐文章于 2025-03-12 17:03:24 发布
阅读量1.7k 收藏 2
点赞数 2
分类专栏： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gs_jy/article/details/118488093
版权
本文详细介绍了如何利用Canal监听MySQL数据库的二进制日志，将变化的数据实时同步到SpringBoot应用中。通过配置Canal、启动Canal服务、编写Java代码处理数据变更事件，实现数据的高效同步。在实际运行中遇到的问题是数据库连接不足，调整代码以确保连接池管理正确。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

场景

各个系统模块之间的数据库是独立的，而我开发的功能需要使用到业务库中员工和角色的信息，因此使用了cannal将业务库中的员工和角色表信息实时同步到自己的库中。

思路

  1. canal监听数据库二进制日志（binlog）的变动
  2. 解析生成sql语句
  3. 通过目标库的数据库连接Connection，创建Statement
  4. 执行对应的sql语句，完成数据同步

步骤

安装mysql

首先需要安装好 mysql，用来作为数据提供方（muster），具体安装步骤网上很多，不再赘述。

部署Canal

下载Canal：Canal，可以选择自己需要的版本进行下载。我使用的的版本是：canal.deployer-1.1.4.tar.gz。下载完成后解压，并对配置文件进行修改。

  1. 首先修改conf/canal.properties:
  • canal.ip = 127.0.0.1 #客户端连接时的ip，需要指定ip，否则客户端可能会连接失败
  • canal.port = 11111 #客户端连接时的端口
  • canal.destinations = example #客户端连接指定的destination
  1. conf/example/instance.properties:对应一个数据库实例：
  • canal.instance.mysql.slaveId=123 #模拟slave的身份标志，不能重复
  • canal.instance.master.address=192.168.0.30:3306//监听的数据库连接
  • canal.instance.master.journal.name=mysql-bin.000001
  • canal.instance.master.position=154
  • canal.instance.dbUsername=canal
  • canal.instance.dbPassword=Canal@123456
  1. 启动: 进入bin/startup.bat启动。windows10启动会失败，需要修改启动文件：删除-Dlogback.configuretionFile的那个配置项。然后启动。如图表示启动成功：
    启动成功
    至此canal服务搭建完成。

编写Java代码

  1. 项目使用springboot+mysql+druid。引入相关依赖：pom.xml
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-commons</artifactId>
			<version>2.0.8.RELEASE</version>
			<scope>compile</scope>
		</dependency>

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

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.47</version>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.1.10</version>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.16</version>
			<optional>true</optional>
		</dependency>

		<!-- 工具类 -->
		<dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-all</artifactId>
			<version>5.5.2</version>
		</dependency>
	</dependencies>

2.容器启动完成后，进行数据同步:
SyncDataListener .class

@Service
public class SyncDataListener implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    public CannalHandler cannalHandler;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if(event.getApplicationContext().getParent() == null)//root application context 没有parent，他就是老大.
        {
            //需要执行的逻辑代码，当spring容器初始化完成后就会执行该方法。
            cannalHandler.start();
        }
    }
}

canal具体处理类：CannalHandler.class

public class CannalHandler {

    private final static int BATCH_SIZE = 1000;

    @Autowired
    public SqlExecutor sqlExecutor;

    @Autowired
    public CanalProperties canalProperties;

    public void start() {
        // 创建链接
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress(canalProperties.getHostName(), canalProperties.getPort()), canalProperties.getDestination(), "", "");
        try {
            //打开连接
            connector.connect();
            //订阅数据库表,全部表
            System.out.println(">>>>"+canalProperties.getSubscribe());
            String subscribe=canalProperties.getSubscribe();
            connector.subscribe(subscribe);
            //回滚到未进行ack的地方，下次fetch的时候，可以从最后一个没有ack的地方开始拿
            connector.rollback();
            while (true) {
                // 获取指定数量的数据
                Message message = connector.getWithoutAck(BATCH_SIZE);
                //获取批量ID
                long batchId = message.getId();
                //获取批量的数量
                int size = message.getEntries().size();
                //如果没有数据
                if (batchId == -1 || size == 0) {
                    try {
                        //线程休眠2秒
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    //如果有数据,处理数据
                    printEntry(message.getEntries());
                }
                //进行 batch id 的确认。确认之后，小于等于此 batchId 的 Message 都会被确认。
                connector.ack(batchId);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            connector.disconnect();
        }
    }

    /**
     * 打印canal server解析binlog获得的实体类信息
     */
    private  void printEntry(List<CanalEntry.Entry> entrys) {
        System.out.println("printEntry>>>>>>开始");
        for (CanalEntry.Entry entry : entrys) {
            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                //开启/关闭事务的实体类型，跳过
                continue;
            }
            //RowChange对象，包含了一行数据变化的所有特征
            //比如isDdl 是否是ddl变更操作 sql 具体的ddl sql beforeColumns afterColumns 变更前后的数据字段等等
            CanalEntry.RowChange rowChage;
            try {
                rowChage = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error , data:" + entry.toString(), e);
            }
            //获取操作类型：insert/update/delete类型
            CanalEntry.EventType eventType = rowChage.getEventType();
            //打印Header信息
            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));
            String dbName=entry.getHeader().getSchemaName();
            String tableName= entry.getHeader().getTableName();
            //判断是否是DDL语句
            if (rowChage.getIsDdl()) {
                System.out.println("================》;isDdl: true,sql:" + rowChage.getSql());
                sqlExecutor.executorSql(rowChage.getSql());
            }
            //获取RowChange对象里的每一行数据，打印出来
            for (CanalEntry.RowData rowData : rowChage.getRowDatasList()) {
                String sql=parseCRUDSql(tableName,rowData.getBeforeColumnsList(),rowData.getAfterColumnsList(),eventType);
                //执行sql语句
                sqlExecutor.executorSql(sql);
            }
        }
        System.out.println("printEntry>>>>>>结束");
    }
	//解析sql语句，代码可以进一步优化
    private  String parseCRUDSql( String tableName,List<CanalEntry.Column> beforeColumns, List<CanalEntry.Column> afterColumns, CanalEntry.EventType eventType) {
        String sql="";
        if (eventType == CanalEntry.EventType.DELETE) { //删除
            //DELETE FROM table_name WHERE ID=1 AND YEAR=2
            StringBuffer deleteBuffer=new StringBuffer();
            deleteBuffer.append("DELETE FROM "+tableName+" WHERE ");
            for (CanalEntry.Column column : beforeColumns) {
                String columnName=column.getName();
                String columnValue="'"+ column.getValue()+"'";
                if(StringUtils.isNotEmpty(columnValue)){
                    deleteBuffer.append(columnName+"="+columnValue);
                    deleteBuffer.append(" AND ");
                }
            }
            //截取掉最后一个AND
            sql = deleteBuffer.substring(0, deleteBuffer.lastIndexOf("AND"));
        } else if (eventType == CanalEntry.EventType.INSERT) {  //如果是新增语句
            StringBuffer sqlBeforeBuffer=new StringBuffer();//sql前一部分
            StringBuffer sqlAfterBuffer=new StringBuffer();//sql后一部分
            // INSERT INTO `canal.sys_holiday` (`year`, `date_str`, `day_type`) VALUES ('2020', '2020-10-01', '0');
            sqlBeforeBuffer.append("INSERT INTO "+tableName);
            sqlBeforeBuffer.append('(');//前半部分
            sqlAfterBuffer.append(" VALUES (");//后半部分
            for (CanalEntry.Column column : afterColumns) {
                String columnName=column.getName();
                String columnValue="'"+column.getValue()+"'";
                sqlBeforeBuffer.append(columnName+",");
                sqlAfterBuffer.append(columnValue+",");
            }
            String beforeStr=sqlBeforeBuffer.substring(0,sqlBeforeBuffer.length()-1);
            String afterStr=sqlAfterBuffer.substring(0,sqlAfterBuffer.length()-1);
            beforeStr=beforeStr+")";
            afterStr=afterStr+")";
            sql=beforeStr+afterStr;//拼接前一部分和后一部分

        } else {  //如果是更新的语句
            //UPDATE runoob_tbl SET id=1,runoob_title='学习 C++' WHERE runoob_id=3 AND TITLE=45;
            StringBuffer updateBuffer=new StringBuffer();
            StringBuffer whereBuffer=new StringBuffer();
            updateBuffer.append("UPDATE "+tableName+" SET ");
            for (CanalEntry.Column column : afterColumns) {
                String columnName=column.getName();
                String columnValue="'"+ column.getValue()+"'";
                boolean updated = column.getUpdated();
                if(updated){//表示更新的字段
                    updateBuffer.append(columnName+"="+columnValue+",");
                }else{
                    whereBuffer.append(" "+columnName+"="+columnValue+" AND");
                }
            }
            String beforeStr=updateBuffer.substring(0,updateBuffer.length()-1);
            String whereStr=whereBuffer.substring(0, whereBuffer.lastIndexOf("AND"));
            sql=beforeStr+" WHERE "+whereStr;
        }
        return sql;
    }
}

SqlExecutor.class

public class SqlExecutor {

    @Resource
    private DataSource dataSource;

    public void executorSql(String sql){
        Connection connection = null;
        Statement statement = null;
        try {
            connection = dataSource.getConnection();
            statement = connection.createStatement();
            statement.execute(sql);
            System.out.println(sql+">>>>>>>>执行完毕");
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                statement.close();
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

注入bean的信息：

    @Bean(name = "dataSource")
    public DataSource druidDataSource(){
        return new DruidDataSource();
    }

    @Bean("sqlExecutor")
    public SqlExecutor sqlExecutor(){
        return  new SqlExecutor();
    }

    @Bean("cannalHandler")
    public CannalHandler cannalHandler(){
        return new CannalHandler();
    }

CanalProperties.java

@Component
@ConfigurationProperties(prefix = "canal")
@Data
public class CanalProperties {

    private String hostName;

    private Integer port;

    private String destination;

    private String subscribe;
}

spring:
  application:
    name: canal
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    # 目标数据库Slaver
    url: jdbc:mysql://127.0.0.1:3306/canal? useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

canal:
  hostName: 127.0.0.1
  port: 11111
  destination: example
  # 订阅所有表
  #subscribe: .*\..*
  # 订阅canal库中，表名sys_开始的表
  subscribe: canal\.sys_.*

配置完成后，启动项目。启动成功后，修改数据源，然后查看slaver中是否发生变化。
在过程中，遇到了一个问题：程序同步数据时，只同步了一部分就不再执行，重启后依然如此。经过排查，由于每执行一个sql，获取一个连接，同时执行后并未关闭这个连接，导致最初连接被用完，程序一直在等待数据库连接。
文中哪里有不妥之处，请指正。希望对你能够有所帮助！

canal实现mysql数据同步
congge
01-27 1万+
canal实现mysql数据同步
ES使用经验之——canal配置MySQL数据同步到ES
qq_35059338的博客
05-23 701
利用alibaba canal实现mysql数据同步到es
canal同步mysql
12-12
canal同步mysql,基于springboot2.0.6,使用undertow容器，可直接运行。
canal 同步mysql数据
qq_33730616的博客
08-28 1239
使用 Canal 同步 MySQL 数据的过程涉及到配置 Canal 服务器、编写消费端应用程序以及处理接收到的变更数据
MySQL与Canal、RabbitMQ集成指南
最新发布
如意小码农的博客
03-12 911
本文主要讲述 rabbitmq canal redis三者协作实现缓存同步
基于canal实现mysql的数据同步
qq_39962403的博客
11-02 1583
canal是什么？ canal [kə'næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费 基于日志增量订阅和消费的业务包括 数据库镜像 数据库实时备份 索引构建和实时维护(拆分异构索引、倒排索引等) 业务 cache 刷新 带业务逻辑的增量数据处理 当前的 canal 支持源端 MySQL 版本包括 5.1.x , 5.5.x , 5.6.x , 5.7.x , 8.0.x ## 工作原理
Canal实现MYSQL实时数据同步
人生需要动态规划 学习需要贪心算法
04-10 4306
访问 xxx.xxx.xxx.xxx:8089, 前面换成自己的服务器、虚拟机地址。为了兼容MYSQL8.0+， 我们需要拉取 v1.1.7的镜像。instance.properties 一共2处修改。canal.properties 一共1处修改。如果是服务器部署的话，记得开放对应的端口号。如果是服务器部署的话，记得开放对应的端口号。一般都是开启的, 可以通过下列命令在。，因为后面的文件都是在这个路径下。，所以我们可以制作对应的镜像。或其他数据库工具进行查看。作者并没有上传对应的镜像。
canal mysql数据同步mysql
逗比爱好者
06-07 2592
mysql 数据同步mysql 多表同步需要创建多个rdb/yml文件
canal实现mysql到ES数据实时同步
07-11
- 观察Canal Server和Adapter的日志，确认数据同步是否正常。 - 使用Elasticsearch的查询语句验证数据是否已正确写入。 在实际应用中，还需要考虑一些高级特性，如数据过滤（只同步部分表或部分列）、数据一致性...
docker使用Canal实现ClickHouse实时同步MySQL数据
05-09
docker使用Canal实现ClickHouse实时同步MySQL数据
全网最详细、最简单 canal同步mysql 监听单实例、监听多实例 配置
wonder_dog的博客
05-07 6532
下载 监听一个数据源到一个数据库 监听多个数据源到一个数据库
使用canal同步mysql数据
qq_33816292的博客
04-04 1215
1.canal相当于mysql的一个连接的从库，canal监听指定库和指定表的数据变更，从而发出默认的广播模式mq，1. admin:canal的客户端控制台 2.deployer 是canal的服务器。2.然后业务端监听mq的交换机，去用队列去绑定交换机，来监听收到消息，来同步到es库上。二、然后通过java代码mq监听去处理对应表数据的事务操作增删改。1.使用策略模式处理对应的表数据变更业务。
canal 相关SQL
wangbaosongmsn的博客
07-28 315
SHOW BINARY LOGS; SHOW BINLOG EVENTS IN 'mysql-bin.000542'; SHOW MASTER STATUS; show variables like 'binlog_format'; show variables like 'log_bin'; select version();
canal 配置MySQL数据同步
jingleli21的博客
07-11 2412
canal配置MySQL数据库同步
Canal实现mysq-A数据同步到mysql-B
weixin_46155421的博客
11-15 554
Canal实现mysql数据同步至mysql
canal同步MySQL的数据
没有合适的昵称
09-08 1779
canal是什么? canal是阿里巴巴的一个开源项目,其作用就是:模拟MySQL的从节点,从而达到数据的同步作用 原理图如下: 这种方式对比flume和sqoop的优点是: 不影响源数据库 可以识别新增数据，也可以检测到删除或者更新的数据 不要求源数据库必须有用于表示增量的字段 ...
canal同步数据从mysql -同步到mysql
wudonglianga的专栏
03-15 1955
1.canal同步数据从mysql -同步到mysql 1.1同步场景架构 1.2 canal 的简介详细请看 https://blog.youkuaiyun.com/wudonglianga/article/details/113805286 1.3：给msyql 添加账号： 1.4. mysql 安装省略 1.5 为canal -admin 创建用户 CREATE USER canaladmin IDENTIFIED BY 'canaladmin%123'; GRANT ALL ON canal_manage
实战：MySQL数据同步神器之Canal
为无为，事无事，味无味。
08-02 5073
canal [kə'næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。项目起源于阿里巴巴内部对于跨机房数据同步的需求，通过解析MySQL的二进制日志（Binary Log），Canal能够捕获并推送数据库的变更事件，满足了诸如数据库镜像、实时备份、索引实时维护等多种业务场景的需求。GitHub - alibaba/canal: 阿里巴巴 MySQL binlog 增量订阅&消费组件。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值