springboot集成canal canal starter 小工具

万丿小衫

已于 2024-05-24 14:56:47 修改

阅读量922

点赞数 6

文章标签： spring boot 后端 java

于 2024-05-23 13:01:57 首次发布

本文链接：https://blog.csdn.net/qq_16938433/article/details/139144642

版权

1、版本：springboot 2.7.1

2、目录结构

3、项目文件

spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.me.starter.canal.config.CanalAutoConfig,\
  com.me.starter.canal.server.CanalSlave

CanalAutoConfig

package com.me.starter.canal.config;


import com.me.starter.canal.properties.CanalProperties;
import com.me.starter.canal.server.CanalSlave;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.sql.DataSource;

@Configuration
@EnableConfigurationProperties({CanalProperties.class})
public class CanalAutoConfig {
    protected final static Logger logger             = LoggerFactory.getLogger(CanalAutoConfig.class);
    @Autowired
    private CanalProperties canalProperties;

    @Autowired
    private CanalSlave canalSlave;


    @PostConstruct
    public void startCanal(){

        if(!canalProperties.isAutoStarted()){
            logger.warn("starter.canal.AutoStarted = false ,canal do not start,If you want to start, please set  starter.canal.AutoStarted = true");
            return;
        }
        start();

    }

    public void start(){
        if(!canalProperties.isEnabled()){
            logger.warn("starter.canal.enabled = false ,canal do not start,If you want to start, please set  starter.canal.enabled = true");
            return;
        }
        if(StringUtils.isEmpty(canalProperties.getDestination())){
            logger.error("starter.canal.destination is null ");
            return;
        }
        if(StringUtils.isEmpty(canalProperties.getUsername())){
            logger.error("starter.canal.username is null ");
            return;
        }
        if(StringUtils.isEmpty(canalProperties.getPassword())){
            logger.error("starter.canal.password is null ");
            return;
        }
        if(StringUtils.isEmpty(canalProperties.getZookeeper())){
            logger.error("starter.canal.zookeeper is null ");
            return;
        }
        if(StringUtils.isEmpty(canalProperties.getSchema())){
            logger.error("starter.canal.schema is null ");
            return;
        }
        if(canalProperties.isSaslClient() && StringUtils.isEmpty(canalProperties.getZkAuthConfig())){
            logger.error("starter.canal.saslClient use ,  ZkAuthConfig mast not be null");
            return;
        }
        if(StringUtils.isNotEmpty(canalProperties.getFilter())){
            //todo checkFilter
        }

        if(canalSlave.getHandlerMap().size() == 0 ){
            logger.error("app has no canal handler ,canal cannot start ,please define handler extend AbstractCanalHandler ");
            return;
        }
        canalSlave.startUp();
    }
    public void stop(){
        canalSlave.stop();
    }
}

CanalHandler

package com.me.starter.canal.handler;

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

import java.io.IOException;
import java.util.concurrent.ConcurrentSkipListSet;

public interface CanalHandler {

    public  ConcurrentSkipListSet<String> allTableSet = new ConcurrentSkipListSet<String>();

    String getHandlerName();

    boolean handle(CanalEntry.Entry entry,CanalEntry.RowChange rowChange) throws IOException;


    public default CanalHandler instance(String tableName)  {

        if(getTableSet().contains(tableName)){
            doPreparatoryWork(tableName);
            return this;
        }
        return null;
    }

    void doPreparatoryWork(String toUpperCase);


    ConcurrentSkipListSet<String> getTableSet();
}

AbstractCanalHandler

package com.me.starter.canal.handler;

import com.me.starter.canal.server.AbstractCanalClient;

import javax.annotation.PostConstruct;
import java.util.Set;
import java.util.concurrent.ConcurrentSkipListSet;

/**
 * @author wanbo
 */
public abstract class AbstractCanalHandler implements CanalHandler{

    public  ConcurrentSkipListSet<String> tableSet = new ConcurrentSkipListSet<String>();

    public AbstractCanalHandler() {
        tableSet.addAll(getTableNames());
        allTableSet.addAll(tableSet);
        AbstractCanalClient.registerHandler(this);
    }

    public abstract Set getTableNames();
    @PostConstruct
    protected void postConstruct(){
        init();
    }

    protected  void init(){
        // default nothing to do
    }

    @Override
    public ConcurrentSkipListSet<String> getTableSet() {
        return tableSet;
    }
}

CanalProperties

package com.me.starter.canal.properties;


import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;

@Data
@ConfigurationProperties("starter.canal")
public class CanalProperties {


    private boolean     autoStarted;
    private boolean     enabled;

    private String      filter;
    private String      destination;
    private String      schema;
    private String      posFile;
    private String      zookeeper;
    private String      username;
    private String      password;
    private boolean     saslClient;
    private String      zkAuthConfig;



}

AbstractCanalClient

package com.me.starter.canal.server;

import com.alibaba.otter.canal.protocol.CanalEntry;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.protocol.exception.CanalClientException;
import com.me.starter.canal.handler.CanalHandler;
import com.me.starter.canal.properties.CanalProperties;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.MDC;
import org.springframework.util.Assert;


import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 测试基类
 * 
 * @author jianghang 2013-4-15 下午04:17:12
 * @version 1.0.4
 */
public class AbstractCanalClient extends BaseCanalClient {

    private static HashMap<String , CanalHandler>  handlerMap = new HashMap();
    private CanalProperties properties;

    public CanalProperties getProperties() {
        return properties;
    }

    public void setProperties(CanalProperties properties) {
        this.properties = properties;
        this.destination = properties.getDestination();
    }

//    ExecutorService threadPool = SingleMustDoneThreadPool.newThreadPool();
    private static BlockingQueue<LogBinlogInfo> posQueue = new LinkedBlockingQueue();


    public  HashMap<String, CanalHandler> getHandlerMap() {
        return handlerMap;
    }

    public AbstractCanalClient() {
    }

    /**
     * 注册handler
     * @param handler
     */
    public static void registerHandler(CanalHandler handler){
        handlerMap.put(handler.getHandlerName(),handler);
    }

    protected Thread posMonitor = null;
    public void start() throws InterruptedException {

        while (true){

            if(instance == null ){
                Assert.notNull(connector, "connector is null");
                instance = new Thread(this::process);
                posMonitor = new Thread(this::posMonitor);

                instance.setUncaughtExceptionHandler(handler);
                running.getAndSet(true);
                instance.start();
                posMonitor.start();
            }
            Thread.sleep(5 * 1000);

        }
    }


    public void stop() {
        if (!running.get()) {
            return;
        }
        running.getAndSet(false);
        if (instance != null) {
            try {

                instance.join();
                posMonitor.join();
            } catch (InterruptedException e) {
                // ignore
            }
        }
        instance = null;
        posMonitor = null;
        MDC.remove("destination");
    }

    protected void process() {
        int batchSize = 5 * 1024;
        starUp:while (running.get()) {

            try {
                MDC.put("destination", destination);
                logger.info("destination : " + destination);
                connector.connect();
                if(properties.getFilter()!=null && !"".equals(properties.getFilter())){
                    connector.subscribe(properties.getFilter());
                }else {
                    connector.subscribe();
                }

                StringBuilder stringBuilder = new StringBuilder();

                for (String tableName :CanalHandler.allTableSet){
                    stringBuilder.append(properties.getSchema() + "." + tableName + ",");
                }

                String substring = stringBuilder.substring(0, stringBuilder.length() - 1);
                logger.info("subscribe:" + substring);
                connector.subscribe(substring);

                work:while (running.get()) {

                    Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
                    long batchId = message.getId();
                    int size = message.getEntries().size();
                    boolean flag = true;
                    if (batchId == -1 || size == 0) {

                    } else {
                        //TODO 数据处理
                        for (CanalEntry.Entry entry : message.getEntries()) {
                            if (entry.getEntryType() == CanalEntry.EntryType.ROWDATA) {
                                String schema = entry.getHeader().getSchemaName();
                                logger.info(schema);
                                if(!schema.equalsIgnoreCase(properties.getSchema())){
                                    continue;
                                }
                                CanalEntry.RowChange rowChange = null;
                                try {
                                    rowChange = CanalEntry.RowChange.parseFrom(entry.getStoreValue());
                                } catch (Exception e) {
                                    throw new RuntimeException("parse event has an error , data:" + entry.toString(), e);
                                }

                                CanalEntry.EventType eventType = rowChange.getEventType();

                                if (eventType == CanalEntry.EventType.QUERY || rowChange.getIsDdl()) {
                                    logger.info("ddl : " + rowChange.getIsDdl() + " ,  sql ----> " + rowChange.getSql() + SEP);
                                    continue;
                                }
                                //记录binlog 信息
                                posQueue.put(new LogBinlogInfo(entry.getHeader().getLogfileName(),entry.getHeader().getLogfileOffset()));

                                logger.info(entry.getHeader().getTableName());
                                List<CanalHandler> handlers = getHandlers(entry.getHeader().getTableName());
                                if(handlers != null && handlers.size() > 0 ){
                                    for(CanalHandler handler : handlers){
                                        flag = handler.handle(entry,rowChange);
                                    }
                                }
                            }
                        }

                    }

                    if (batchId != -1  ) {
                        connector.ack(batchId); // 提交确认
                    }
                }
            } catch (Exception e) {
                logger.error("process error!", e);

                try {
                    connector.rollback(); // 处理失败, 回滚数据
                }catch (CanalClientException cce){
                    cce.printStackTrace();
                }
            } finally {

                try {
                    connector.disconnect();
                }catch (CanalClientException cce){
                    cce.printStackTrace();
                }
                MDC.remove("destination");

                logger.error(" sleep 10s and try");
                try {
                    Thread.currentThread().sleep(30000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                continue starUp;
            }
        }

        instance.interrupt();
        instance = null;
    }

    protected void posMonitor()  {

        work:while (running.get()) {
            LogBinlogInfo logBinlogInfo = null;
            try {
                logBinlogInfo = posQueue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            setVodInfo(logBinlogInfo.getBinlogOffset(),logBinlogInfo.getBinlogFileName());
        }
    }

    /**
     * 记录 binlog pos 文件命
     * @param pos
     * @param vodFileName
     */
    public void setVodInfo(long pos,String vodFileName) {

        Writer w = null;
        try {
            if(StringUtils.isEmpty(properties.getPosFile())){
                return;
            }
            File posFile = new File(properties.getPosFile());
            if(!(posFile).exists()){
                return;
            }

            w = new FileWriter(posFile);
            if( w == null){
                return;
            }
            w.append("position=" + pos + "\n");
            w.append("vodFileName=" + vodFileName + "\n");
            w.append("#create_time " + new Date() + "\n");
            // log.error("setPositon: " + pos);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(w != null ){
                    w.flush();
                    w.close();
                }

            } catch (IOException e) {
                logger.error("---------->", e);
            }
        }

    }

    /**
     * 根据变更表名称  获取对应的hanlder
     * @param tableName
     * @return
     */
    private CanalHandler getHandler(String tableName) {
        CanalHandler returnHandler = null;
        for(CanalHandler handler : handlerMap.values()){
            returnHandler = handler.instance(tableName);
            if(returnHandler != null){
                break;
            }
        }
        return returnHandler;
    }

    /**
     * 根据变更表名称  获取对应的hanlder
     * @param tableName
     * @return
     */
    private List<CanalHandler> getHandlers(String tableName) {
        List<CanalHandler> handlers = new ArrayList<CanalHandler>();
        for(CanalHandler handler : handlerMap.values()){
            CanalHandler instance = handler.instance(tableName);
            if( instance != null){
                handlers.add(instance);
            }
        }
        return handlers;
    }


    public static class LogBinlogInfo{
        private String binlogFileName;
        private long binlogOffset;

        public String getBinlogFileName() {
            return binlogFileName;
        }

        public long getBinlogOffset() {
            return binlogOffset;
        }

        public LogBinlogInfo(String binlogFileName, long binlogOffset) {
            this.binlogFileName = binlogFileName;
            this.binlogOffset = binlogOffset;
        }
    }
}

BaseCanalClient

package com.me.starter.canal.server;


import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.protocol.CanalEntry.*;
import com.alibaba.otter.canal.protocol.Message;

import com.google.protobuf.InvalidProtocolBufferException;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.SystemUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

public class BaseCanalClient {

    protected final static Logger             logger             = LoggerFactory.getLogger(BaseCanalClient.class);
    protected static final String             SEP                = SystemUtils.LINE_SEPARATOR;
    protected static final String             DATE_FORMAT        = "yyyy-MM-dd HH:mm:ss";
//    protected volatile boolean                running            = false;
    public AtomicBoolean                      running   = new AtomicBoolean(false);
    protected Thread.UncaughtExceptionHandler handler            = (t, e) -> logger.error("parse events has an error",e);
    protected Thread                          instance = null;
    protected CanalConnector                  connector;
    protected static String                   context_format     = null;
    protected static String                   row_format         = null;
    protected static String                   transaction_format = null;
    protected String                          destination;

    static {
        context_format = SEP + "****************************************************" + SEP;
        context_format += "* Batch Id: [{}] ,count : [{}] , memsize : [{}] , Time : {}" + SEP;
        context_format += "* Start : [{}] " + SEP;
        context_format += "* End : [{}] " + SEP;
        context_format += "****************************************************" + SEP;

        row_format = SEP
                     + "----------------> binlog[{}:{}] , name[{},{}] , eventType : {} , executeTime : {}({}) , gtid : ({}) , delay : {} ms"
                     + SEP;

        transaction_format = SEP
                             + "================> binlog[{}:{}] , executeTime : {}({}) , gtid : ({}) , delay : {}ms"
                             + SEP;

    }

    protected void printSummary(Message message, long batchId, int size) {
        long memsize = 0;
        for (Entry entry : message.getEntries()) {
            memsize += entry.getHeader().getEventLength();
        }

        String startPosition = null;
        String endPosition = null;
        if (!CollectionUtils.isEmpty(message.getEntries())) {
            startPosition = buildPositionForDump(message.getEntries().get(0));
            endPosition = buildPositionForDump(message.getEntries().get(message.getEntries().size() - 1));
        }

        SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
        logger.info(context_format, new Object[] { batchId, size, memsize, format.format(new Date()), startPosition,
                endPosition });
    }

    protected String buildPositionForDump(Entry entry) {
        long time = entry.getHeader().getExecuteTime();
        Date date = new Date(time);
        SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT);
        String position = entry.getHeader().getLogfileName() + ":" + entry.getHeader().getLogfileOffset() + ":"
                          + entry.getHeader().getExecuteTime() + "(" + format.format(date) + ")";
        if (StringUtils.isNotEmpty(entry.getHeader().getGtid())) {
            position += " gtid(" + entry.getHeader().getGtid() + ")";
        }
        return position;
    }

    protected void printEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            long executeTime = entry.getHeader().getExecuteTime();
            long delayTime = new Date().getTime() - executeTime;
            Date date = new Date(entry.getHeader().getExecuteTime());
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
                if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN) {
                    TransactionBegin begin = null;
                    try {
                        begin = TransactionBegin.parseFrom(entry.getStoreValue());
                    } catch (InvalidProtocolBufferException e) {
                        throw new RuntimeException("parse event has an error , data:" + entry.toString(), e);
                    }
                    // 打印事务头信息，执行的线程id，事务耗时
                    logger.info(transaction_format,
                        new Object[] { entry.getHeader().getLogfileName(),
                                String.valueOf(entry.getHeader().getLogfileOffset()),
                                String.valueOf(entry.getHeader().getExecuteTime()), simpleDateFormat.format(date),
                                entry.getHeader().getGtid(), String.valueOf(delayTime) });
                    logger.info(" BEGIN ----> Thread id: {}", begin.getThreadId());
                    printXAInfo(begin.getPropsList());
                } else if (entry.getEntryType() == EntryType.TRANSACTIONEND) {
                    TransactionEnd end = null;
                    try {
                        end = TransactionEnd.parseFrom(entry.getStoreValue());
                    } catch (InvalidProtocolBufferException e) {
                        throw new RuntimeException("parse event has an error , data:" + entry.toString(), e);
                    }
                    // 打印事务提交信息，事务id
                    logger.info("----------------\n");
                    logger.info(" END ----> transaction id: {}", end.getTransactionId());
                    printXAInfo(end.getPropsList());
                    logger.info(transaction_format,
                        new Object[] { entry.getHeader().getLogfileName(),
                                String.valueOf(entry.getHeader().getLogfileOffset()),
                                String.valueOf(entry.getHeader().getExecuteTime()), simpleDateFormat.format(date),
                                entry.getHeader().getGtid(), String.valueOf(delayTime) });
                }

                continue;
            }

            if (entry.getEntryType() == EntryType.ROWDATA) {
                RowChange rowChange = null;
                try {
                    rowChange = RowChange.parseFrom(entry.getStoreValue());
                } catch (Exception e) {
                    throw new RuntimeException("parse event has an error , data:" + entry.toString(), e);
                }

                EventType eventType = rowChange.getEventType();

                logger.info(row_format,
                    new Object[] { entry.getHeader().getLogfileName(),
                            String.valueOf(entry.getHeader().getLogfileOffset()), entry.getHeader().getSchemaName(),
                            entry.getHeader().getTableName(), eventType,
                            String.valueOf(entry.getHeader().getExecuteTime()), simpleDateFormat.format(date),
                            entry.getHeader().getGtid(), String.valueOf(delayTime) });

                if (eventType == EventType.QUERY || rowChange.getIsDdl()) {
                    logger.info("ddl : " + rowChange.getIsDdl() + " ,  sql ----> " + rowChange.getSql() + SEP);
                    continue;
                }

                printXAInfo(rowChange.getPropsList());
                for (RowData rowData : rowChange.getRowDatasList()) {
                    if (eventType == EventType.DELETE) {
                        printColumn(rowData.getBeforeColumnsList());
                    } else if (eventType == EventType.INSERT) {
                        printColumn(rowData.getAfterColumnsList());
                    } else {
                        printColumn(rowData.getAfterColumnsList());
                    }
                }
            }
        }
    }

    protected void printColumn(List<Column> columns) {
        for (Column column : columns) {
            StringBuilder builder = new StringBuilder();
            try {
                if (StringUtils.containsIgnoreCase(column.getMysqlType(), "BLOB")
                    || StringUtils.containsIgnoreCase(column.getMysqlType(), "BINARY")) {
                    // get value bytes
                    builder.append(column.getName() + " : "
                                   + new String(column.getValue().getBytes("ISO-8859-1"), "UTF-8"));
                } else {
                    builder.append(column.getName() + " : " + column.getValue());
                }
            } catch (UnsupportedEncodingException e) {
            }
            builder.append("    type=" + column.getMysqlType());
            if (column.getUpdated()) {
                builder.append("    update=" + column.getUpdated());
            }
            builder.append(SEP);
            logger.info(builder.toString());
        }
    }

    protected void printXAInfo(List<Pair> pairs) {
        if (pairs == null) {
            return;
        }

        String xaType = null;
        String xaXid = null;
        for (Pair pair : pairs) {
            String key = pair.getKey();
            if (StringUtils.endsWithIgnoreCase(key, "XA_TYPE")) {
                xaType = pair.getValue();
            } else if (StringUtils.endsWithIgnoreCase(key, "XA_XID")) {
                xaXid = pair.getValue();
            }
        }

        if (xaType != null && xaXid != null) {
            logger.info(" ------> " + xaType + " " + xaXid);
        }
    }

    public void setConnector(CanalConnector connector) {
        this.connector = connector;
    }

    /**
     * 获取当前Entry的 GTID信息示例
     *
     * @param header
     * @return
     */
    public static String getCurrentGtid(Header header) {
        List<Pair> props = header.getPropsList();
        if (props != null && props.size() > 0) {
            for (Pair pair : props) {
                if ("curtGtid".equals(pair.getKey())) {
                    return pair.getValue();
                }
            }
        }
        return "";
    }

    /**
     * 获取当前Entry的 GTID Sequence No信息示例
     *
     * @param header
     * @return
     */
    public static String getCurrentGtidSn(Header header) {
        List<Pair> props = header.getPropsList();
        if (props != null && props.size() > 0) {
            for (Pair pair : props) {
                if ("curtGtidSn".equals(pair.getKey())) {
                    return pair.getValue();
                }
            }
        }
        return "";
    }

    /**
     * 获取当前Entry的 GTID Last Committed信息示例
     *
     * @param header
     * @return
     */
    public static String getCurrentGtidLct(Header header) {
        List<Pair> props = header.getPropsList();
        if (props != null && props.size() > 0) {
            for (Pair pair : props) {
                if ("curtGtidLct".equals(pair.getKey())) {
                    return pair.getValue();
                }
            }
        }
        return "";
    }

}

CanalSlave

package com.me.starter.canal.server;


import com.alibaba.otter.canal.client.impl.ClusterCanalConnector;
import com.alibaba.otter.canal.client.impl.ClusterNodeAccessStrategy;
import com.alibaba.otter.canal.common.zookeeper.ZkClientx;
import com.me.starter.canal.handler.CanalHandler;
import com.me.starter.canal.properties.CanalProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Set;


@Configuration
@EnableConfigurationProperties({CanalProperties.class})
public class CanalSlave extends AbstractCanalClient {


    @Autowired
    private CanalProperties properties;

    public CanalProperties getProperties() {
        return properties;
    }

    @PostConstruct
    public void init(){
        System.out.println("CanalSlave init");
        super.setProperties(properties);
    }

    public void startUp() {
        super.setProperties(properties);
        String destination = properties.getDestination();


        ClusterCanalConnector connector;
        if(properties.isSaslClient()) {
            System.setProperty("java.security.auth.login.config", properties.getZkAuthConfig());
            System.setProperty("zookeeper.sasl.client", properties.isSaslClient() + "");

        }
        // 基于zookeeper动态获取canal server的地址，建立链接，其中一台server发生crash，可以支持failover
        ZkClientx zkClientx = ZkClientx.getZkClient(properties.getZookeeper());
        connector = new ClusterCanalConnector(properties.getUsername(),
                properties.getPassword(),
                destination,
                new ClusterNodeAccessStrategy(destination, zkClientx));
        connector.setSoTimeout(60 * 1000);
        connector.setIdleTimeout(60 * 60 * 1000);
        this.setConnector(connector);


        try {
            this.start();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                logger.info("## stop the canal client");
                this.stop();
            } catch (Throwable e) {
                logger.warn("##something goes wrong when stopping canal:", e);
            } finally {
                logger.info("## canal client is down.");
            }
        }));
    }

}

CanalSource

暂无实际使用

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.me.starter</groupId>
    <artifactId>spring-boot-starter-canal</artifactId>
    <version>2.7.1-SNAPSHOT</version>
    <name>spring-boot-starter-canal</name>
    <description>spring-boot-starter-canal</description>
    <properties>
        <java.version>8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.otter</groupId>
            <artifactId>canal.client</artifactId>
            <version>1.1.4</version>
        </dependency>
    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version> <!-- 确保使用支持 release的插件版本 -->
<!--                <configuration>-->
<!--                    <release>1.8</release> &lt;!&ndash; 指定release版本 &ndash;&gt;-->
<!--                </configuration>-->
            </plugin>
        </plugins>
    </build>
</project>

4、测试使用

测试项目目录结构

CanalstarterDemoApplication

package com.example.canalstarterDemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CanalstarterDemoApplication {

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

}

SysLogCanalHandler

package com.example.canalstarterDemo.cannelHandler;


import com.alibaba.otter.canal.protocol.CanalEntry;
import com.cntv.starter.canal.handler.AbstractCanalHandler;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.*;


/**
 * @author wanbo
 */
@Service
public class SysLogCanalHandler extends AbstractCanalHandler {

    //增加监控的表 当该表数据变化时执行对应操作
    @Override
    public Set getTableNames() {
        Set<String >  set = new HashSet<>();
        set.add("tb_syslog");
        return set;
    }

    @Override
    public String getHandlerName() {
        return "SyslogHandler";
    }

    @Override
    public boolean handle(CanalEntry.Entry entry, CanalEntry.RowChange rowChange) throws IOException {

        CanalEntry.EventType eventType = rowChange.getEventType();
        for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {

            if (eventType == CanalEntry.EventType.DELETE) {
                System.out.println("do DELETE");
            } else if (eventType == CanalEntry.EventType.INSERT) {
                System.out.println("do INSERT");
            } else {
                System.out.println("do UPDATE");
            }
        }
        return true;

    }

    @Override
    public void doPreparatoryWork(String s) {
        System.out.println("----------------------doPreparatoryWork-----------------------");
    }


}

application.yml

spring:
  application:
    name: op-monitor
starter:
  canal:
    enabled: true
    destination: op-monitor
    username: canal
    schema: vdn
    filter: vdn.tb_syslog
    zookeeper: 10.70.37.xxx:2181,10.70.37.xxx:2181,10.70.37.xxx:2181#根据自己的zk集群
    password: Ekt0Pnjcoxfwsnwb
    auto-started: true
data:
  log:
    path: log/

启动完成，测试成功。

万丿小衫

关注

6
点赞
踩
12

收藏

觉得还不错? 一键收藏
2
评论
springboot集成canal canal starter 小工具

@Override/*** 测试基类* @author jianghang 2013-4-15 下午04:17:12*//*** 注册handler*/if (!return;
复制链接

扫一扫