二、springboot整合canal redis

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

目前我已知的整合方式有两种：
1.基于canal.client包自己实现
2.基于canal-spring-boot-starter（据说已暂停维护,非官方）

---

方法一、基于client包的实现

引入依赖包

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

在配置文件中编写canal的连接配置信息

注入连接与同步数据的util类

import com.alibaba.fastjson.JSONObject;
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.lee.utils.RedisUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.net.InetSocketAddress;
import java.util.List;

@Component
public class CanalUtil {

    @Value("${canal-config.hostname}")
    private String host;

    @Value("${canal-config.port}")
    private Integer port;

    @Value("${canal-config.tableName}")
    private String tableName;

    @Value("${canal-config.destination}")
    private String destination;

    private final static int BATCH_SIZE = 10000;

    /**
     * 开始日志监控
     */
    public void startMonitorSql() {
        // 创建链接
        CanalConnector connector = CanalConnectors
                .newSingleConnector(new InetSocketAddress(host, port), destination, "", "");
        int batchSize = 1000;
        try {
            connector.connect();
            connector.subscribe(tableName);
            connector.rollback();
            System.out.println("开始监听");
            while (true) {
                // 获取指定数量的数据
                Message message = connector.getWithoutAck(batchSize);
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    try {
                        System.out.println("无变化");
                        Thread.sleep(1500);
                    } catch (InterruptedException e) {
                    }
                } else {
                    printEntry(message.getEntries());
                }
                connector.ack(batchId); // 提交确认
            }
        } finally {
            connector.disconnect();
        }
    }

    private static void printEntry(List<CanalEntry.Entry> entrys) {
        for (CanalEntry.Entry entry : entrys) {
            if (entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONBEGIN
                    || entry.getEntryType() == CanalEntry.EntryType.TRANSACTIONEND) {
                continue;
            }

            CanalEntry.RowChange rowChage = null;
            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);
            }

            CanalEntry.EventType eventType = rowChage.getEventType();

            for (CanalEntry.RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == CanalEntry.EventType.DELETE) {
                    // 删除，获取删除前的数据
                    redisDelete(rowData.getBeforeColumnsList(),entry.getHeader().getTableName());
                } else if (eventType == CanalEntry.EventType.INSERT) {
                    // 新增，获取新增后的数据
                    redisSet(rowData.getAfterColumnsList(),entry.getHeader().getTableName());
                } else {
                    // 修改，获取修改后的数据
                    //                    printColumn(rowData.getBeforeColumnsList());
                    redisSet(rowData.getAfterColumnsList(),entry.getHeader().getTableName());
                }
            }
        }
    }

    private static void redisSet(List<CanalEntry.Column> columns, String tableName) {
        JSONObject json = new JSONObject();
        // 字段和值的列表，放入json，后续作为redis的值
        for (CanalEntry.Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            System.out.println("set key: " + columns.get(0).getValue() + ", value: " + json.toJSONString());
            // 获取第一列主键的数据
            RedisUtils.stringSet(tableName+":" + columns.get(0).getValue(), json.toJSONString());
        }
    }

    private static void redisDelete(List<CanalEntry.Column> columns, String tableName) {
        JSONObject json = new JSONObject();
        for (CanalEntry.Column column : columns) {
            json.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            System.out.println("delete key: " + columns.get(0).getValue());
            RedisUtils.delKey(tableName+":" + columns.get(0).getValue());
        }
    }
}

编写配置类，使容器启动时运行监控工具代码

import com.lee.canal.utils.CanalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Configuration;

@Configuration
public class InitCanalConfig implements CommandLineRunner {

    @Autowired
    private CanalUtil canalUtil;


    @Override
    public void run(String... args) throws Exception {
        canalUtil.startMonitorSql();
    }
}

运行结果截图

方法二：基于canal-spring-boot-starter

引入依赖

        <dependency>
            <groupId>top.javatool</groupId>
            <artifactId>canal-spring-boot-starter</artifactId>
            <version>1.2.1-RELEASE</version>
        </dependency

application.properties配置文件信息

# canal starter配置信息
canal.server=127.0.0.1:11111
canal.destination=example

logging.level.root=info
logging.level.top.javatool.canal.client.client.AbstractCanalClient=error

新增监听类

@CanalTable:通过此注解可以指定表名

import com.alibaba.fastjson.JSON;
import com.lee.canal.entity.UserEntity;
import com.lee.utils.RedisUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import top.javatool.canal.client.annotation.CanalTable;
import top.javatool.canal.client.handler.EntryHandler;

/**
 * @author 联想
 * @CanalTable标注监听的表名
 */
@Slf4j
@Component
@CanalTable(value = "t_user")
public class UserServiceImpl implements EntryHandler<com.lee.canal.entity.UserEntity>{
    @Override
    public void insert(UserEntity t) {
        log.info("新增数据为{}",t);
        // redis操作
        RedisUtils.stringSet("t_user:"+t.getId(), JSON.toJSONString(t));
    }
    @Override
    public void update(UserEntity before, UserEntity after) {
        log.info("原来数据为{}",before);
        log.info("更新数据为{}",after);
        // redis操作
        RedisUtils.stringSet("t_user:"+after.getId(), JSON.toJSONString(after));
    }
    @Override
    public void delete(UserEntity t) {
        log.info("删除的数据为{}",t);
        RedisUtils.delKey("t_user:"+t.getId());
    }

}

启动springboot项目并验证

依次执行增改删语句