canal基本使用

最新推荐文章于 2024-08-15 22:29:47 发布
最新推荐文章于 2024-08-15 22:29:47 发布
阅读量1.1k 收藏
点赞数
分类专栏： 大数据

1、pom.xml文件中加入jar
·

com.alibaba.otter
canal.client
1.1.2


2、创建CanalClient.java --用来解析binlog文件变化信息
·import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.protocol.CanalEntry;
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.slf4j.MDC;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

/**

  • 测试基类

  • @author jianghang 2013-4-15 下午04:17:12

  • @version 1.0.4
    */
    public class AbstractCanalClientTest {

    protected final static Logger logger = LoggerFactory.getLogger(AbstractCanalClientTest.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;
    protected Thread.UncaughtExceptionHandler handler = new Thread.UncaughtExceptionHandler() {

                                                                  public void uncaughtException(Thread t, Throwable e) {
                                                                  logger.error("parse events has an error", e);
                                                              }
                                                          };

    protected Thread thread = 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;

    }

    public AbstractCanalClientTest(String destination){
    this(destination, null);
    }

    public AbstractCanalClientTest(String destination, CanalConnector connector){
    this.destination = destination;
    this.connector = connector;
    }

    protected void start() {
    Assert.notNull(connector, “connector is null”);
    thread = new Thread(new Runnable() {

         public void run() {
         process();
     }
 });

 thread.setUncaughtExceptionHandler(handler);
 running = true;
 thread.start();

    }

    protected void stop() {
    if (!running) {
    return;
    }
    running = false;
    if (thread != null) {
    try {
    thread.join();
    } catch (InterruptedException e) {
    // ignore
    }
    }

     MDC.remove("destination");

    }

    protected void process() {
    int batchSize = 5 * 1024;
    while (running) {
    try {
    MDC.put(“destination”, destination);
    connector.connect();
    connector.subscribe();
    while (running) {
    Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
    long batchId = message.getId();
    int size = message.getEntries().size();
    if (batchId == -1 || size == 0) {
    // try {
    // Thread.sleep(1000);
    // } catch (InterruptedException e) {
    // }
    } else {
    printSummary(message, batchId, size);
    printEntry(message.getEntries());
    }

                 connector.ack(batchId); // 提交确认
             // connector.rollback(batchId); // 处理失败, 回滚数据
         }
     } catch (Exception e) {
         logger.error("process error!", e);
     } finally {
         connector.disconnect();
         MDC.remove("destination");
     }
 }

    }

    private 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 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 rowChage = null;
         try {
             rowChage = RowChange.parseFrom(entry.getStoreValue());
         } catch (Exception e) {
             throw new RuntimeException("parse event has an error , data:" + entry.toString(), e);
         }

         EventType eventType = rowChage.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 || rowChage.getIsDdl()) {
             logger.info(" sql ----> " + rowChage.getSql() + SEP);
             continue;
         }

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

    }

    protected void printColumn(List 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 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(CanalEntry.Header header) {
      List props = header.getPropsList();
      if (props != null && props.size() > 0) {
      for (CanalEntry.Pair pair : props) {
      if (“curtGtid”.equals(pair.getKey())) {
      return pair.getValue();
      }
      }
      }
      return “”;
      }

    /**

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

    /**

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

}
3、创建连接
·import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;

import java.net.InetSocketAddress;

/**

  • 单机模式的测试例子

  • @author jianghang 2013-4-15 下午04:19:20

  • @version 1.0.4
    */
    public class SimpleCanalClientTest extends AbstractCanalClientTest {

    public SimpleCanalClientTest(String destination){
    super(destination);
    }

    public static void main(String args[]) {
    // 根据ip，直接创建链接，无HA的功能
    String destination = “example”;
    CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress(“172.26.xx.xx”, 11111),
    destination,
    “”,
    “”);

     final SimpleCanalClientTest clientTest = new SimpleCanalClientTest(destination);
 clientTest.setConnector(connector);
 clientTest.start();
 Runtime.getRuntime().addShutdownHook(new Thread() {

     public void run() {
         try {
             logger.info("## stop the canal client");
             clientTest.stop();
         } catch (Throwable e) {
             logger.warn("##something goes wrong when stopping canal:", e);
         } finally {
             logger.info("## canal client is down.");
         }
     }

 });

    }

}

小冉_ran
关注
专栏目录
canal使用详解
congge
02-12 2万+
canal实现数据同步
Canal的介绍以及使用Canal的介绍以及使用
06-30
### Canal的基本概念 1. **Producer（生产者）**: Canal服务器，负责监听并捕获MySQL数据库的 binlog（二进制日志）事件，将这些事件转换为结构化的数据格式。 2. **Consumer（消费者）**: 客户端应用，订阅并消费...
Canal AdminGuide
agapple
03-19 747
 背景    先前开源了一个开源项目： 【阿里巴巴开源项目: 基于mysql数据库binlog的增量订阅&消费】     本文主要是介绍一下如何部署&使用   环境要求 1. 操作系统     a.  纯java开发，windows/linux均可支持     b.  jdk建议使用1.6.25以上的版本，稳定可靠，目前阿里巴巴使用基本为此版本.    2. ...
Canal 使用
最新发布
qq_64668270的博客
08-15 414
其中 ：①：指定当前服务的id，必须指定，否则会报错②：设置binlog文件的存放地址和文件名，叫做mysql-bin，此处指定的目录前缀是mysql容器的数据存放目录，所以可以在挂载目录中看到相关的文件，命名格式是mysql-bin.000001开始慢慢叠加③：指定针对哪个数据库记录binlog的events事件，此处记录mall库如果在 MySQL 配置中没有显式地配置 binlog-do-db 参数，那么 MySQL 的二进制日志（binlog）将会记录所有数据库的变更操作。
canal
weixin_52449894的博客
08-15 249
1.在服务器新建文件夹 /opt/mysql/data，新建文件 /opt/mysql/conf.d/my.cnf其中my.cnf 内容如下2.启动数据库3.校验是否开启成功。
canal使用
weixin_44182814的博客
07-08 705
canal 1.描述 Canal是一个很好的数据库同步工具。canal是阿里巴巴旗下的一款开源项目，纯Java开发。基于数据库增量日志解析，提供增量数据订阅&消费，目前主要支持了MySQL 2.准备 canal的原理是基于mysql binlog技术，所以这里一定需要开启mysql的binlog写入功能 1.检查binlog功能是否有开启，如果显示状态为OFF表示该功能未开启，开启binlog功能 mysql> show variables like 'log_bin'; 2.如果显示状态为
Canal使用
Janet的博客
05-20 2355
1. Canal 简介 2. Canal 安装 2.1mysql开启binlog模式 2.2Canal 下载安装 windows下部署canal，服务端+客户端 下载地址：https://github.com/alibaba/canal/releases 3. 项目监控数据变化 3.1 导入 maven <dependency> <groupId>com.xpand</groupId> <artifactId>st...
canal客户端-canal.deployer-1.1.7-SNAPSHOT.tar.gz
02-14
canal.properties是Canal全局配置文件，定义了Canal服务的基本参数，如服务器地址、端口、内存分配等。instance.properties则是每个Canal实例的配置文件，包含了与特定数据库连接相关的配置，如数据库连接信息、...
使用Canal监听数据库配置时所报的异常记录
01-20
在示例中，用户是`canal`，并且似乎已经授予了一些基本的增删改查权限。但为了执行`SHOW MASTER STATUS`，还需要`SUPER`或`REPLICATIONCLIENT`权限。可以通过以下SQL语句来添加权限： ```sql GRANT REPLICATION ...
canal.deployer-1.1.6
06-22
2. **conf**：存放Canal实例的配置文件，如`canal.properties`定义了Canal的基本属性，`instance.properties`配置了具体的数据库连接信息和binlog解析参数。 3. **lib**：存放Canal运行所需的依赖库，包括Canal的...
CanAl入门
01-07
一、为什么要使用canal 1、作用：同步mysql 主要有两种方式： （1）做拉链表 （2）更新redis 2、某些情况无法从日志里获取信息，而又无法利用sqoop等ETL工具对数据实时的监控 二、canal工作原理 1、mysql主备复制的...
Canal部署操作说明及应用场景验证
04-24
Canal部署操作说明及应用场景验证，包括 Canal Client Java Demo 、详细的部署操作流程、应用场景验证结论。非常合适Canal初学者参考
Canal的使用
keepHungery的博客
05-10 2756
Canal的使用 Canal概述 canal是用java开发的基于数据库增量日志解析，提供增量数据订阅&消费的中间件。目前，canal主要支持了MySQL的binlog解析，解析完成后才利用canal client 用来处理获得的相关数据。（数据库同步需要阿里的otter中间件，基于canal）。 使用场景 原始场景：作为异地数据库之间的数据同步 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yV8DrEZV-1589105749424)(C:\Users\txc
Canal的基本使用
m0_37559973的博客
11-09 465
canal主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。
canal使用指南（一）
imVainiycos的博客
12-22 9338
Canal的使用指南。实现一个简单纯净的client-service，暂时不接入mq。 文章目录一、什么是canal二、准备工作三、canal服务端搭建3.1 配置文件3.1.1 canal.properties3.1.2 instance 实例配置3.2 开始启动3.3 查看日志四、客户端实现 一、什么是canal canal [kə’næl]，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费。 早期阿里巴巴因为杭州和美国双机房部署，存在跨机房同步的业务.
Canal使用详解
技术人集结地
12-22 2942
Canal是阿里巴巴开发的MySQL binlog增量订阅&消费组件，Canal是基于MySQL二进制日志的高性能数据同步系统。在阿里巴巴集团中被广泛使用，以提供可靠的低延迟增量数据管道。Canal Server能够解析MySQL Binlog并订阅数据更改，而Canal Client可以将更改广播到任何地方，例如数据库和。Canal支持所有平台，细粒度系统监视，通过不同方式解析和预订MySQL Binlog，以及高性能、实时数据同步。
canal 使用详解
zhouzhiwengang的专栏
02-09 7821
译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，提供增量数据订阅和消费工作原理canal 模拟 MySQL slave 的交互协议，伪装自己为 MySQL slave ，向 MySQL master 发送 dump 协议MySQL master 收到 dump 请求，开始推送 binary log 给 slave (即 canal )canal 解析 binary log 对象(原始为 byte 流)EntryHeaderlogfileName [binlog文件名]
Canal入门使用
小何的博客
04-27 943
Canal入门使用
阿里Canal使用
这人脑子有点不够用
04-10 1414
是阿里巴巴开源的一款基于 MySQL 数据库增量日志解析，提供实时的数据订阅和消费服务的工具。它可以用来读取 MySQL 的 binlog 日志并转换成 JSON 格式的事件消息，然后将这些消息发布到下游的消息中间件，比如 RabbitMQ，以实现数据库变更的实时同步。创建一个专门给 Canal 使用的 MySQL 用户账号，并赋予足够的权限来读取 binlog，通常包括 REPLICATION SLAVE 权限。下载并安装 Canal，根据官方文档配置 Canal 的 server 端。
Windows环境下使用Canal同步MySQL binlog实战
"这篇文章除了介绍在Windows环境下如何使用Canal同步MySQL的binlog日志，还涵盖了Canal的起源、应用场景、工作原理、以及版本更新带来的性能和功能改进。" Canal是一个由阿里巴巴开发的开源项目，主要用于MySQL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值