程序员经验分享-hwhale

使用canal同步数据，踩坑排雷全过程

2023-11-17

1、mysql配置

(1)检查binlog功能是否有开启

mysql> show variables like 'log_bin';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| log_bin | OFF |
+---------------+-------+
1 row in set (0.00 sec)

如果log_bin 显示为OFF则说明服务没有开启，需要修改Linux中MySQL的配置文件my.cnf

vi /etc/my.cnf
#追加内容：
log-bin=mysql-bin #binlog文件名
binlog_format=ROW #选择row模式
server_id=1  #mysql实例id,不能和canal的slaveId重复

之后重启MySQL：

service mysql restart

修改后在进行检查，发现log_bin 已经开启

mysql> show variables like 'log_bin';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| log_bin | ON|
+---------------+-------+
1 row in set (0.00 sec)

（2）在Linux的MySQL中添加相关用户权限

！！第一个坑！！

在输入以下语句时踩坑：

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

遇到的问题：没有插入内容的权限（发现很多权限都没有）

ERROR 1142 (42000): INSERT command denied to user 'canal'@'localhost' for table 'members'

正确输入语句，最简单的方法就是给用户所有的权限：

CREATE USER 'canal'@'%' IDENTIFIED BY 'canal';
GRANT ALL PRIVILEGES ON *.* TO 'canal'@'%';
FLUSH PRIVILEGES;

！！第二个坑！！

密码策略问题异常信息：
 


ERROR 1819 (HY000): Your password does not satisfy the current policy requirements

解决办法：
1、查看 mysql 初始的密码策略，
输入语句 “ SHOW VARIABLES LIKE ‘validate_password%’; ” 进行查看，

mysql> SHOW VARIABLES LIKE 'validate_password%';

+--------------------------------------+--------+
| Variable_name                        | Value  |
+--------------------------------------+--------+
| validate_password_check_user_name    | OFF    |
| validate_password_dictionary_file    |        |
| validate_password_length             | 8      |
| validate_password_mixed_case_count   | 1      |
| validate_password_number_count       | 1      |
| validate_password_policy             | MEDIUM |
| validate_password_special_char_count | 1      |
+--------------------------------------+--------+

2、设置密码的验证强度等级，

设置 validate_password_policy 的全局参数为 LOW ，输入设值语句 “ set global validate_password_policy=LOW; ”

设置validate_password_length 的全局参数为4，输入设值语句 “ set global validate_password_length=4; ”

好了，这样就可以设canal为用户canal密码了

2、下载安装Canal服务

下载地址：
https://github.com/alibaba/canal/releases
（1）下载之后，放到目录中，解压文件
cd /usr/local/canal
canal.deployer-1.1.4.tar.gz
tar zxvf canal.deployer-1.1.4.tar.gz

（2）修改配置文件


vi conf/example/instance.properties

#需要改成自己的数据库信息
canal.instance.master.address=192.168.43.8:3306
#需要改成自己的数据库用户名与密码

canal.instance.dbUsername=canal
canal.instance.dbPassword=canal
#需要改成同步的数据库表规则，例如只是同步一下表
canal.instance.filter.regex=.*\\..*

vi conf/canal.properties

去掉这一行的注解
canal.instance.parser.parallelThreadSize = 16

（3）进入bin目录下启动


 


./startup.sh

启动时踩雷：问题链接

已在另一篇文章里写清楚。

成功运行后可以在canal/logs文件夹中生成canal.log日志。
成功的日志内容为：

2022-05-04 14:16:19.040 [main] INFO  com.alibaba.otter.canal.deployer.CanalLauncher - ## set default uncaught exception handler
2022-05-04 14:16:19.145 [main] INFO  com.alibaba.otter.canal.deployer.CanalLauncher - ## load canal configurations
2022-05-04 14:16:19.198 [main] INFO  com.alibaba.otter.canal.deployer.CanalStarter - ## start the canal server.
2022-05-04 14:16:19.313 [main] INFO  com.alibaba.otter.canal.deployer.CanalController - ## start the canal server[192.168.122.1(192.168.122.1):11111]
2022-05-04 14:16:22.988 [main] INFO  com.alibaba.otter.canal.deployer.CanalStarter - ## the canal server is running now ......

3、SpringBoot内容

创建canal_clientedu模块

 引入相关依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
        </dependency>
    </dependencies>

创建application.properties配置文件

# 服务端口
server.port=10000
# 服务名
spring.application.name=canal-client
# 环境设置：dev、test、prod
spring.profiles.active=dev
# mysql数据库连接
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/guli?serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

编写canal客户端类

package com.atguigu.canal.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.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.Iterator;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;

@Component
public class CanalClient {

    //sql队列
    private Queue<String> SQL_QUEUE = new ConcurrentLinkedQueue<>();

    @Resource
    private DataSource dataSource;

    /**
     * canal入库方法
     */
    public void run() {

        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("192.168.43.8",
                11111), "example", "", "");
        int batchSize = 1000;
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            try {
                while (true) {
                    //尝试从master那边拉去数据batchSize条记录，有多少取多少
                    Message message = connector.getWithoutAck(batchSize);
                    long batchId = message.getId();
                    int size = message.getEntries().size();
                    if (batchId == -1 || size == 0) {
                        Thread.sleep(1000);
                    } else {
                        dataHandle(message.getEntries());
                    }
                    connector.ack(batchId);

                    //当队列里面堆积的sql大于一定数值的时候就模拟执行
                    if (SQL_QUEUE.size() >= 1) {
                        executeQueueSql();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (InvalidProtocolBufferException e) {
                e.printStackTrace();
            }
        } 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.atguigu.canal;


import com.atguigu.canal.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 CanalApplication implements CommandLineRunner {
    @Resource
    private CanalClient canalClient;

    public static void main(String[] args) {
        SpringApplication.run(CanalApplication.class, args);
    }

    @Override
    public void run(String... strings) throws Exception {
        //项目启动，执行canal客户端监听
        canalClient.run();
    }
}

4、测试

注意事项：

为了测试简单，先关闭一下Linux防火墙（也可以添加端口）；

systemctl stop firewalld

windows数据库和Linux数据库的库名和表名必须一致；

要开启canal服务；

之后就可以启动SpringBoot项目了。

在Linux数据库中进行登录MySQL并进行插入操作：

[root@localhost ~]# mysql -u canal -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 6
Server version: 5.7.26-log MySQL Community Server (GPL)

Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> use guli;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> insert into members
    -> (id,username,age)
    -> values(8,'sss',22);
Query OK, 1 row affected (0.07 sec)

windows数据库同步显示：

OK！使用canal同步数据成功！ 

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

学习

mysql

Linux

canal

Windows

使用canal同步数据，踩坑排雷全过程 的相关文章

随机推荐

  • OWASP Dependency-Check工具集成

    OWASP Dependency Check工具集成 SonarQube 插件不执行分析 而是读取现有的 Dependency Check 报告 先要通过Jenkins插件去执行扫描 然后sonar里面再分析报告 一 搭建本地NVD Mir

  • 解决新版edge浏览器首页被搜狗、haoqq等垃圾搜索引擎捆绑问题，并将启动首页设为edge自带新标签页

    最近想试一下edge浏览器 发现每次启动都是这个haoqq com 这是主页被恶意挟持了 经过不懈努力终于给他关闭了 edge真香 解决步骤 1 打开电脑管家 或火绒软件 找到浏览器保护 电脑管家是在工具箱里 火绒的话在防护中心 系统防护

  • Verilog：【1】时钟分频电路（clk_divider.sv）

    碎碎念 作为Basic Verilog的第一个学习笔记 打算用这种命名方式来对博客进行命名 应该有助于检索 简单阅览了部分工程的代码 发现里面有很多嵌套关系 因此决定先从基础模块开始 也是为了整个博客内容的流畅性 读者朋友有问题的话 也可以

  • java robot截图报错_robot framework笔记（介绍+基础关键字）

    robot framework库 Builtin 提供了一组通常需要的通用关键字 String 生成 修改和验证字符串的库 Screenshot 提供关键字捕捉桌面截图 XML 生成 修改和验证xml文件的库 DateTime 日期和时间转

  • 腾讯mini项目-【指标监控服务重构】2023-08-13

    今日已办 使用watermill框架替代当前的base runner框架 a 参考官方提供的sarama kafka Pub Sub https github com ThreeDotsLabs watermill kafka 实现kafk

  • node-sass与node版本不匹配问题解决方法

    Node和node sass的版本存在绑定关系 关系对照表如下 如果版本不匹配 比如在node16上面安装node sass 4 x 那么就可能会报以下错误 此时如果没有别的项目受影响 最好是将node的版本降低一下 咨询朋友说最好是降级n

  • Java线程：线程的调度-休眠

    本文转载至 http lavasoft blog 51cto com 62575 221790 Java线程 线程的调度 休眠 Java线程调度是Java多线程的核心 只有良好的调度 才能充分发挥系统的性能 提高程序的执行效率 这里要明确的

  • Linux 面试题

    一 填空题 1 在Linux系统中 以 文件 方式访问设备 2 Linux内核引导时 从文件 etc fstab 中读取要加载的文件系统 3 Linux文件系统中每个文件用 i节点 来标识 4 全部磁盘块由四个部分组成 分别为引导块 专用块

  • 给WPF的DataGrid添加行号的方法（在XAML中添加，不是添加到行最前面那种）

  • 主机入侵检测系统wazuh3.13单机部署

    Wazuh涉及两个主要组件的安装 Wazuh服务器和Elastic Stack 此外 Wazuh agent需要部署到受监视的主机上 Wazuh server 运行Wazuh管理器和API 它从已部署的代理收集和分析数据 Elastic S

  • Mac brew安装mysql之后无法启动mysql

    使用Mac brew装完mysql之后 连接mysql报错 songdeMacBook Pro mysql song mysql uroot p Enter password ERROR 2002 HY000 Can t connect t

  • Linux之硬链接和软链接

    硬链接 1 包含在目录中的一个文件名就是一个文件的硬链接 或简称链接 Link 在同一目录或者不同目录中 同一个文件可以有好几个链接 对应好几个文件名 创建链接的命令 ln P1 P2 用来创建一个新的硬链接 即为由路径P1标识的文件创建一

  • 推荐几个UI/UX设计师常用软件和网站

    网站 Dribbble dribbble com Dribble是一个面向创作家 艺术工作者 设计师等创意类作品的人群 提供作品在线服务 供网友在线查看已经完成的作品或者正在创作的作品的交流网站 Dribbble还针对手机推出了相应的软件

  • Nginx介绍

    Nginx介绍 是什么 Nginx是一款轻量级的Web 服务器 反向代理服务器及电子邮件 IMAP POP3 代理服务器 在BSD like 协议下发行 其特点是占有内存少 并发能力强 事实 上nginx的并发能力在同类型的网页服务器中表现

  • Win11怎么设置任务栏大小？Win11调整任务栏

    有用户在使用Win11系统的过程中发现任务栏大小不一样 非常影响美观 有什么办法可以设置Win11任务栏的大小吗 下面小编就给大家带来Win11调整任务栏大小的教程 希望对大家有帮助 Win11 4月最新版下载 Ghost Win11 22

  • Spring学习总结

    Spring学习总结 文章目录 Spring学习总结 toc 一 Spring介绍 1 概念 2 下载路径 二 IOC容器 1 IOC概念和原理 什么是IOC IOC底层原理 2 IOC接口 3 IOC操作 Bean管理 什么是Bean管理

  • 零基础入门金融风控-贷款违约预测-机器学习-数据分析

    零基础入门金融风控 贷款违约预测 一 赛题数据 赛题以预测用户贷款是否违约为任务 数据集报名后可见并可下载 该数据来自某信贷平台的贷款记录 总数据量超过120w 包含47列变量信息 其中15列为匿名变量 为了保证比赛的公平性 将会从中抽取8

  • 计算机网络实验｜DNS 域名服务协议

    DNS 域名服务协议 实验目的 1 理解 DNS 实现的原理 2 了解 DNS 解析的过程 3 掌握 DNS 报文格式 实验环境 本实验要求实验室主机能够连接到 Internet 并可浏览网页 实验拓扑如图 实验内容 1 学习 DNS 协议

  • 《Effective Modern C++》第3章学习记录

    Moving to Modern C C 11 and C 14 big name features auto smart pointers move semantics lambdas concurrency braces vs pare

  • 使用canal同步数据，踩坑排雷全过程

    1 mysql配置 1 检查binlog功能是否有开启 mysql gt show variables like log bin Variable name Value log bin OFF 1 row in set 0 00 sec 如

热门标签