spring boot集成canal实现数据库同步，且mysql主库宕机canal自动切换到从库

key-deserializer: org.apache.kafka.common.serialization.StringDeserializer

值的反序列化方式

value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

listener:

在侦听器容器中运行的线程数。

concurrency: 5

#listner负责ack，每调用一次，就立即commit

ack-mode: manual_immediate

missing-topics-fatal: false

CanalClient.java 包含canal的连接，数据库的监听，日志数据的处理，sql的发送

package com.zks.canal.deploy;

import com.alibaba.fastjson.JSON;

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.CanalEntry.Entry;

import com.alibaba.otter.canal.protocol.Message;

import com.google.protobuf.InvalidProtocolBufferException;

import com.zks.canal.producer.KafkaProducer;

import lombok.AllArgsConstructor;

import lombok.Data;

import lombok.NoArgsConstructor;

import lombok.extern.slf4j.Slf4j;

import org.springframework.boot.ApplicationArguments;

import org.springframework.boot.ApplicationRunner;

import org.springframework.stereotype.Component;

import javax.annotation.Resource;

import java.net.InetSocketAddress;

import java.util.List;

import java.util.Queue;

import java.util.concurrent.ConcurrentLinkedQueue;

/**

• @Package: com.zks.canal.deploy

• @ClassName: CanalClient

• @Author: ZhouKaiShun

• @CreateTime: 2021/9/13 11:54

• @Description: canal客户端

*/

@Component

@Slf4j

public class CanalClient implements ApplicationRunner {

@Resource

private KafkaProducer kafkaProducer;

private final static int BATCH_SIZE = 1000;

/**

• sql队列

*/

private Queue SQL_QUEUE = new ConcurrentLinkedQueue<>();

/**

• 订阅的数据库表

*/

public static String SUBSCRIBE_DB_TABLE = “kaishun.tb_user”;

@Override

public void run(ApplicationArguments args) throws Exception {

log.info(“启动canal服务，端口号：7111”);

// 创建链接

CanalConnector connector = CanalConnectors.newSingleConnector(

new InetSocketAddress(“127.0.0.1”, 11111), “example”, “”, “”);

try {

//打开连接

connector.connect();

//订阅数据库表（全库全表：.\… 指定库全表：库名…* 单表：库名.表名 多规则组合使用：库名1…*,库名2.表名1,库名3.表名2 (逗号分隔)）

connector.subscribe(SUBSCRIBE_DB_TABLE);

//回滚到未进行ack的地方，下次fetch的时候，可以从最后一个没有ack的地方开始拿

connector.rollback();

while (true) {

//尝试从master那边拉去数据batchSize条记录，有多少取多少

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 {

//处理数据为sql

dataHandle(message.getEntries());

}

/设置队列sql语句执行最大值/

if (SQL_QUEUE.size() >= 1) {

executeQueueSql();

}

//进行 batch id 的确认。确认之后，小于等于此 batchId 的 Message 都会被确认。

connector.ack(batchId);

}

} catch (Exception e) {

e.printStackTrace();

} finally {

connector.disconnect();

}

System.out.println(“连接canal end”);

}

/**

• @description: 处理队列里sql

• @return:

• @author: ZhouKaiShun

• @time: 2021/9/15 10:35

*/

public void executeQueueSql() {

int size = SQL_QUEUE.size();

for (int i = 0; i < size; i++) {

String sql = SQL_QUEUE.poll();

this.execute(sql);

}

}

/**

• @description: 日志数据处理

• @return:

• @author: ZhouKaiShun

• @time: 2021/9/15 10:35

*/

private void dataHandle(List entrys) throws

InvalidProtocolBufferException {

for (Entry entry : entrys) {

if (CanalEntry.EntryType.ROWDATA == entry.getEntryType()) {

CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());

CanalEntry.EventType eventType = rowChange.getEventType();

if (eventType == CanalEntry.EventType.DELETE) {

saveDeleteSql(entry);

} else if (eventType == CanalEntry.EventType.UPDATE) {

saveUpdateSql(entry);

} else if (eventType == CanalEntry.EventType.INSERT) {

saveInsertSql(entry);

}

}

}

}

/**

• @description: 处理update语句

• @return:

• @author: ZhouKaiShun

• @time: 2021/9/15 10:35

*/

private void saveUpdateSql(Entry entry) {

try {

CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());

List<CanalEntry.RowData> rowDatasList = rowChange.getRowDatasList();

for (CanalEntry.RowData rowData : rowDatasList) {

List<CanalEntry.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<CanalEntry.Column> oldColumnList = rowData.getBeforeColumnsList();

for (CanalEntry.Column column : oldColumnList) {

//暂时只支持单一主键

if (column.getIsKey()) {

sql.append(column.getName() + “= '” + column.getValue() + “'”);

break;

}

}

SQL_QUEUE.add(sql.toString());

}

} catch (InvalidProtocolBufferException e) {

e.printStackTrace();

}

}

/**

• @description: 处理delete语句

• @return:

• @author: ZhouKaiShun

• @time: 2021/9/15 10:35

*/

private void saveDeleteSql(Entry entry) {

try {

CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());

List<CanalEntry.RowData> rowDatasList = rowChange.getRowDatasList();

for (CanalEntry.RowData rowData : rowDatasList) {

List<CanalEntry.Column> columnList = rowData.getBeforeColumnsList();

StringBuffer sql = new StringBuffer("delete from " +

entry.getHeader().getTableName() + " where ");

for (CanalEntry.Column column : columnList) {

if (column.getIsKey()) {

//暂时只支持单一主键

sql.append(column.getName() + “= '” + column.getValue() + “'”);

break;

}

}

SQL_QUEUE.add(sql.toString());

}

} catch (InvalidProtocolBufferException e) {

e.printStackTrace();

}

}

/**

• @description: 处理insert语句

• @return:

• @author: ZhouKaiShun

• @time: 2021/9/15 10:35

*/

private void saveInsertSql(Entry entry) {

try {

CanalEntry.RowChange rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());

List<CanalEntry.RowData> rowDatasList = rowChange.getRowDatasList();

for (CanalEntry.RowData rowData : rowDatasList) {

List<CanalEntry.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();

}

}

/**

• @description: 发送sql至kafka供订阅者消费

• @return:

• @author: ZhouKaiShun

• @time: 2021/9/15 10:35

*/

public void execute(String sql) {

kafkaProducer.send(sql);

System.out.println(“SQL=”+sql);

}

}

KafkaProducer.java Kafka消息发送

package com.zks.canal.producer;

import com.alibaba.fastjson.JSONObject;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.kafka.core.KafkaTemplate;

import org.springframework.kafka.support.SendResult;

import org.springframework.stereotype.Component;

import org.springframework.util.concurrent.ListenableFuture;

import org.springframework.util.concurrent.ListenableFutureCallback;

/**

• @Package: com.zks.kafka.producer

• @ClassName: KafkaProducer

• @Author: ZhouKaiShun

• @CreateTime: 2021/9/13 17:01

• @Description:

*/

@Component

@Slf4j

public class KafkaProducer {

@Autowired

private KafkaTemplate<String, Object> kafkaTemplate;

//自定义topic

public static final String TOPIC_TEST = “topic.test”;

public void send(Object obj) {

String obj2String = JSONObject.toJSONString(obj);

log.info(“准备发送消息为：{},监控到变动时间：{}”, obj2String,System.currentTimeMillis());

//发送消息

ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send(TOPIC_TEST, obj);

future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {

@Override

public void onFailure(Throwable throwable) {

//发送失败的处理

log.info(TOPIC_TEST + " - 生产者 发送消息失败：" + throwable.getMessage());

}

@Override

public void onSuccess(SendResult<String, Object> stringObjectSendResult) {

//成功的处理

log.info(TOPIC_TEST + " - 生产者 发送消息成功：" + stringObjectSendResult.toString());

log.info(TOPIC_TEST + " - 成功反馈时间：{}", System.currentTimeMillis());

}

});

}

}

到这里 canal监听以及kafka发送消息就完成了。后面新建两个项目去监听就可以了

新建一个项目 kafka，结构如下

xml只需要引入kafka即可，yml同理

KafkaConsumer.java

package com.zks.kafka.consumer;

import lombok.extern.slf4j.Slf4j;

import org.apache.kafka.clients.consumer.ConsumerRecord;

import org.apache.kafka.clients.producer.KafkaProducer;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.kafka.annotation.KafkaListener;

import org.springframework.kafka.support.Acknowledgment;

import org.springframework.kafka.support.KafkaHeaders;

import org.springframework.messaging.handler.annotation.Header;

import org.springframework.stereotype.Component;

import javax.annotation.Resource;

import java.util.Optional;

/**

• @Package: com.zks.kafka.consumer

• @ClassName: KafkaConsumer

• @Author: ZhouKaiShun

• @CreateTime: 2021/9/13 17:01

• @Description:

*/

@Component

@Slf4j

public class KafkaConsumer {

@Autowired

private JdbcTemplate jdbcTemplate;

//自定义topic

public static final String TOPIC_TEST = “topic.test”;

public static final String TOPIC_GROUP1 = “topic.group1”;

@KafkaListener(topics = TOPIC_TEST, groupId = TOPIC_GROUP1)

public void topic_test(ConsumerRecord<?, ?> record, Acknowledgment ack, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {

log.info(“项目kafka监听触发时间：{}”,System.currentTimeMillis());

Optional message = Optional.ofNullable(record.value());

if (message.isPresent()) {

String sql = (String)message.get();

jdbcTemplate.update(sql);

log.info(“项目kafka入库成功时间：{}”,System.currentTimeMillis());

ack.acknowledge();

}

}

}

然后再建立一个项目模拟子模块，如kafka2，结构与这个一样

测试结构展示

启动zookeeper、Kafka、conal

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

如何快速更新自己的技术积累？

• 在现有的项目里，深挖技术，比如用到netty可以把相关底层代码和要点都看起来。
• 如果不知道目前的努力方向，就看自己的领导或公司里技术强的人在学什么。
• 知道努力方向后不知道该怎么学，就到处去找相关资料然后练习。
• 学习以后不知道有没有学成，则可以通过面试去检验。

我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！

以上面试专题的答小编案整理成面试文档了，文档里有答案详解，以及其他一些大厂面试题目

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

4q-1712868562664)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-44KcZOpy-1712868562664)]

如何快速更新自己的技术积累？

• 在现有的项目里，深挖技术，比如用到netty可以把相关底层代码和要点都看起来。
• 如果不知道目前的努力方向，就看自己的领导或公司里技术强的人在学什么。
• 知道努力方向后不知道该怎么学，就到处去找相关资料然后练习。
• 学习以后不知道有没有学成，则可以通过面试去检验。

我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！

以上面试专题的答小编案整理成面试文档了，文档里有答案详解，以及其他一些大厂面试题目

[外链图片转存中…(img-JpNOkZ0G-1712868562664)]

[外链图片转存中…(img-eU55B9Bj-1712868562665)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-YWWEQTvh-1712868562665)]