什么是数据的异构处理。简单说就是为了满足我们业务的扩展性，将数据从某种特定的格式转换到新的数据格式中来。

为什么会有这种需求出现呢？

传统的企业中，主要都是将数据存储在了关系型数据库中，例如说MySQL这种数据库，但是为了满足需求的扩展，查询的维度会不断地增加，那么这个时候我们就需要做数据的异构处理了。

常见的数据异构有哪些？

例如MySQL数据转储到Redis，MySQL数据转储到es等等，也是因为这种数据异构的场景开始出现，陆陆续续有了很多中间件在市场中冒出，例如说rocketMq，kafka，canal这种组件。

下边有一张通俗易懂的数据异构过程图：

在这里插入图片描述

canal进行数据同步

首先，我们需要正确地打开canal服务器去订阅binlog日志。

关于binlog日志查看常用的几条命令如下：

  1. #是否启用了日志
  2. mysql>show variables like 'log_bin';
  3. #怎样知道当前的日志
  4. mysql> show master status;
  5. #查看mysql binlog模式
  6. show variables like 'binlog_format';
  7. #获取binlog文件列表
  8. show binary logs;
  9. #查看当前正在写入的binlog文件
  10. show master statusG
  11. #查看指定binlog文件的内容
  12. show binlog events in 'mysql-bin.000002';

注意binlog日志格式要求为row格式：

ROW格式日志的特点

记录sql语句和每个字段变动的前后情况，能够清楚每行数据的变化历史，占用较多的空间，不会记录对数据没有影响的sql，例如说select语句就不会记录。可以使mysqlbinlog工具去查看内部信息。

STATEMENT模式的日志内容

STATEMENT格式的日志就和它本身的命名有点类似，只是单独地记录了sql的内容，但是没有记录上下文信息，在数据会UI福的时候可能会导致数据丢失。

MIX模式模式的日志内容

这种模式的日志内容比较灵活，当遇到了表结构变更的时候，就会记录为statement模式，如果遇到了数据修改的话就会变为row模式。

如何配置canal的相关信息？

比较简单，首先通过下载好canal的安装包，然后我们需要在canal的配置文件上边做一些手脚：

  1. canal的example文件夹下边的properties文件
  2. canal.instance.master.address=**.***.***.**:3306
  3. # 日志的文件名称
  4. canal.instance.master.journal.name=master-96-bin.000009
  5. canal.instance.dbUsername=****
  6. canal.instance.dbPassword=****

启动我们的canal程序，然后查看日志，如果显示下边这些内容就表示启动成功了：

  1. 2019-10-13 16:00:30.072 [main] ERROR com.alibaba.druid.pool.DruidDataSource - testWhileIdle is true, validationQuery not set
  2. 2019-10-13 16:00:30.734 [main] INFO  c.a.otter.canal.instance.spring.CanalInstanceWithSpring - start CannalInstance for 1-example
  3. 2019-10-13 16:00:30.783 [main] INFO  c.a.otter.canal.instance.core.AbstractCanalInstance - start successful....

ps:关于canal入门安装的教程网上有很多，这里我就不做过多的阐述了。

canal服务器搭建起来之后，我们便进入了java端的程序编码部分：

接着再来查看我们的客户端代码，客户端中我们需要通过java程序获取canal服务器的连接，然后进入监听binlog日志的状态。

可以参考下边的程序代码：

  1. package com.sise.client.simple;
  2. import com.alibaba.otter.canal.client.CanalConnector;
  3. import com.alibaba.otter.canal.client.CanalConnectors;
  4. import com.alibaba.otter.canal.protocol.CanalEntry;
  5. import com.alibaba.otter.canal.protocol.Message;
  6. import com.google.protobuf.InvalidProtocolBufferException;
  7. import com.sise.common.dto.TypeDTO;
  8. import com.sise.common.handle.CanalDataHandler;
  9. import java.net.InetSocketAddress;
  10. import java.util.List;
  11. import java.util.stream.Collectors;
  12. /**
  13.  * 简单版本的canal监听客户端
  14.  *
  15.  * @author idea
  16.  * @date 2019/10/12
  17.  */
  18. public class SImpleCanalClient {
  19.     private static String SERVER_ADDRESS = "127.0.0.1";
  20.     private static Integer PORT = 11111;
  21.     private static String DESTINATION = "example";
  22.     private static String USERNAME = "";
  23.     private static String PASSWORD = "";
  24.     public static void main(String[] args) throws InterruptedException {
  25.         CanalConnector canalConnector = CanalConnectors.newSingleConnector(
  26.                 new InetSocketAddress(SERVER_ADDRESS, PORT), DESTINATION, USERNAME, PASSWORD);
  27.         canalConnector.connect();
  28.         canalConnector.subscribe(".*\..*");
  29.         canalConnector.rollback();
  30.         for (; ; ) {
  31.             Message message = canalConnector.getWithoutAck(100);
  32.             long batchId = message.getId();
  33.             if(batchId!=-1){
  34. //                System.out.println(message.getEntries());
  35.                 System.out.println(batchId);
  36.                 printEntity(message.getEntries());
  37.             }
  38.         }
  39.     }
  40.     public static void printEntity(List<CanalEntry.Entry> entries){
  41.         for (CanalEntry.Entry entry : entries) {
  42.             if (entry.getEntryType()!=CanalEntry.EntryType.ROWDATA){
  43.                 continue;
  44.             }
  45.             try {
  46.                 CanalEntry.RowChange rowChange=CanalEntry.RowChange.parseFrom(entry.getStoreValue());
  47.                 for (CanalEntry.RowData rowData : rowChange.getRowDatasList()) {
  48.                     System.out.println(rowChange.getEventType());
  49.                     switch (rowChange.getEventType()){
  50.                     //如果希望监听多种事件，可以手动增加case
  51.                         case INSERT:
  52.                             String tableName = entry.getHeader().getTableName();
  53.                             //测试选用t_type这张表进行映射处理
  54.                             if ("t_type".equals(tableName)) {
  55.                                 TypeDTO typeDTO = CanalDataHandler.convertToBean(rowData.getAfterColumnsList(), TypeDTO.class);
  56.                                 System.out.println(typeDTO);
  57.                             }
  58.                             System.out.println("this is INSERT");
  59.                             break;
  60.                         default:
  61.                             break;
  62.                     }
  63.                 }
  64.             } catch (InvalidProtocolBufferException e) {
  65.                 e.printStackTrace();
  66.             }
  67.         }
  68.     }
  69.     /**
  70.      * 打印内容
  71.      *
  72.      * @param columns
  73.      */
  74.     private static void printColums(List<CanalEntry.Column> columns){
  75.         String line=columns.stream().map(column -> column.getName()+"="+column.getValue())
  76.                 .collect(Collectors.joining(","));
  77.         System.out.println(line);
  78.     }
  79. }

本地监听到了canal的example文件夹中配置的监听的日志信息之后，就会自动将该日志里面记录的数据进行打印读取。

那么这个时候我们还需要做多一步处理，那就是将坚听到的数据转换为可识别的对象，然后进行对象转移处理。

其实光是链接获取到canal的binlog日志并不困难，接着我们还需要将binlog日志进行统一的封装处理，需要编写一个特定的处理器将日志的内容转换为我们常用的DTO类：

下边这个工具类可以借鉴一下：

  1. package com.sise.common.handle;
  2.  
  3. import com.alibaba.otter.canal.protocol.CanalEntry;
  4. import com.sise.common.dto.CourseDetailDTO;
  5. import lombok.extern.slf4j.Slf4j;
  6.  
  7. import java.lang.reflect.Field;
  8. import java.util.HashMap;
  9. import java.util.List;
  10. import java.util.Map;
  11.  
  12. /**
  13.  * 基于canal的数据处理器
  14.  *
  15.  * @author idea
  16.  * @data 2019/10/13
  17.  */
  18. @Slf4j
  19. public  class CanalDataHandler extends TypeConvertHandler {
  20.  
  21.     /**
  22.      * 将binlog的记录解析为一个bean对象
  23.      *
  24.      * @param columnList
  25.      * @param clazz
  26.      * @param <T>
  27.      * @return
  28.      */
  29.     public static <T> T convertToBean(List<CanalEntry.Column> columnList, Class<T> clazz) {
  30.         T bean = null;
  31.         try {
  32.             bean = clazz.newInstance();
  33.             Field[] fields = clazz.getDeclaredFields();
  34.             Field.setAccessible(fields, true);
  35.             Map<String, Field> fieldMap = new HashMap<>(fields.length);
  36.             for (Field field : fields) {
  37.                 fieldMap.put(field.getName().toLowerCase(), field);
  38.             }
  39.             if (fieldMap.containsKey("serialVersionUID")) {
  40.                 fieldMap.remove("serialVersionUID".toLowerCase());
  41.             }
  42.             System.out.println(fieldMap.toString());
  43.             for (CanalEntry.Column column : columnList) {
  44.                 String columnName = column.getName();
  45.                 String columnValue = column.getValue();
  46.                 System.out.println(columnName);
  47.                 if (fieldMap.containsKey(columnName)) {
  48.                     //基础类型转换不了
  49.                     Field field = fieldMap.get(columnName);
  50.                     Class<?> type = field.getType();
  51.                     if(BEAN_FIELD_TYPE.containsKey(type)){
  52.                         switch (BEAN_FIELD_TYPE.get(type)) {
  53.                             case "Integer":
  54.                                 field.set(bean, parseToInteger(columnValue));
  55.                                 break;
  56.                             case "Long":
  57.                                 field.set(bean, parseToLong(columnValue));
  58.                                 break;
  59.                             case "Double":
  60.                                 field.set(bean, parseToDouble(columnValue));
  61.                                 break;
  62.                             case "String":
  63.                                 field.set(bean, columnValue);
  64.                                 break;
  65.                             case "java.handle.Date":
  66.                                 field.set(bean, parseToDate(columnValue));
  67.                                 break;
  68.                             case "java.sql.Date":
  69.                                 field.set(bean, parseToSqlDate(columnValue));
  70.                                 break;
  71.                             case "java.sql.Timestamp":
  72.                                 field.set(bean, parseToTimestamp(columnValue));
  73.                                 break;
  74.                             case "java.sql.Time":
  75.                                 field.set(bean, parseToSqlTime(columnValue));
  76.                                 break;
  77.                         }
  78.                     }else{
  79.                         field.set(bean, parseObj(columnValue));
  80.                     }
  81.                 }
  82.  
  83.             }
  84.         } catch (InstantiationException | IllegalAccessException e) {
  85.             log.error("[CanalDataHandler]convertToBean，初始化对象出现异常，对象无法被实例化,异常为{}", e);
  86.         }
  87.         return bean;
  88.     }
  89.  
  90.     public static void main(String[] args) throws IllegalAccessException {
  91.         CourseDetailDTO courseDetailDTO = new CourseDetailDTO();
  92.         Class clazz = courseDetailDTO.getClass();
  93.         Field[] fields = clazz.getDeclaredFields();
  94.         Field.setAccessible(fields, true);
  95.         System.out.println(courseDetailDTO);
  96.         for (Field field : fields) {
  97.             if ("java.lang.String".equals(field.getType().getName())) {
  98.                 field.set(courseDetailDTO, "name");
  99.             }
  100.         }
  101.         System.out.println(courseDetailDTO);
  102.     }
  103.  
  104.     /**
  105.      * 其他类型自定义处理
  106.      *
  107.      * @param source
  108.      * @return
  109.      */
  110.     public static Object parseObj(String source){
  111.         return null;
  112.     }
  113.  
  114. }

接着是canal的核心处理器,主要的目的是将binlog转换为我们所希望的实体类对象，该类目前主要考虑兼容的数据类型为目前8种，比较有限，如果读者后续在实际开发中还遇到某些特殊的数据类型可以手动添加到map中。

  1. package com.sise.common.handle;
  2.  
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.HashMap;
  7. import java.util.Map;
  8.  
  9. /**
  10.  * 类型转换器
  11.  *
  12.  * @author idea
  13.  * @data 2019/10/13
  14.  */
  15. public class TypeConvertHandler {
  16.  
  17.     public static final Map<Class, String> BEAN_FIELD_TYPE;
  18.  
  19.     static {
  20.         BEAN_FIELD_TYPE = new HashMap<>(8);
  21.         BEAN_FIELD_TYPE.put(Integer.class, "Integer");
  22.         BEAN_FIELD_TYPE.put(Long.class, "Long");
  23.         BEAN_FIELD_TYPE.put(Double.class, "Double");
  24.         BEAN_FIELD_TYPE.put(String.class, "String");
  25.         BEAN_FIELD_TYPE.put(Date.class, "java.handle.Date");
  26.         BEAN_FIELD_TYPE.put(java.sql.Date.class, "java.sql.Date");
  27.         BEAN_FIELD_TYPE.put(java.sql.Timestamp.class, "java.sql.Timestamp");
  28.         BEAN_FIELD_TYPE.put(java.sql.Time.class, "java.sql.Time");
  29.     }
  30.  
  31.     protected static final Integer parseToInteger(String source) {
  32.         if (isSourceNull(source)) {
  33.             return null;
  34.         }
  35.         return Integer.valueOf(source);
  36.     }
  37.  
  38.     protected static final Long parseToLong(String source) {
  39.         if (isSourceNull(source)) {
  40.             return null;
  41.         }
  42.         return Long.valueOf(source);
  43.     }
  44.  
  45.     protected static final Double parseToDouble(String source) {
  46.         if (isSourceNull(source)) {
  47.             return null;
  48.         }
  49.         return Double.valueOf(source);
  50.     }
  51.  
  52.     protected static final Date parseToDate(String source) {
  53.         if (isSourceNull(source)) {
  54.             return null;
  55.         }
  56.         if (source.length() == 10) {
  57.             source = source + " 00:00:00";
  58.         }
  59.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  60.         Date date;
  61.         try {
  62.             date = sdf.parse(source);
  63.         } catch (ParseException e) {
  64.             return null;
  65.         }
  66.         return date;
  67.     }
  68.  
  69.     protected static final java.sql.Date parseToSqlDate(String source) {
  70.         if (isSourceNull(source)) {
  71.             return null;
  72.         }
  73.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  74.         java.sql.Date sqlDate;
  75.         Date utilDate;
  76.         try {
  77.             utilDate = sdf.parse(source);
  78.         } catch (ParseException e) {
  79.             return null;
  80.         }
  81.         sqlDate = new java.sql.Date(utilDate.getTime());
  82.         return sqlDate;
  83.     }
  84.  
  85.     protected static final java.sql.Timestamp parseToTimestamp(String source) {
  86.         if (isSourceNull(source)) {
  87.             return null;
  88.         }
  89.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  90.         Date date;
  91.         java.sql.Timestamp timestamp;
  92.         try {
  93.             date = sdf.parse(source);
  94.         } catch (ParseException e) {
  95.             return null;
  96.         }
  97.  
  98.         timestamp = new java.sql.Timestamp(date.getTime());
  99.         return timestamp;
  100.     }
  101.  
  102.     protected static final java.sql.Time parseToSqlTime(String source) {
  103.         if (isSourceNull(source)) {
  104.             return null;
  105.         }
  106.         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
  107.         Date date;
  108.         java.sql.Time time;
  109.         try {
  110.             date = sdf.parse(source);
  111.         } catch (ParseException e) {
  112.             return null;
  113.         }
  114.         time = new java.sql.Time(date.getTime());
  115.         return time;
  116.     }
  117.  
  118.     private static boolean isSourceNull(String source) {
  119.         if (source == "" || source == null) {
  120.             return true;
  121.         }
  122.         return false;
  123.     }
  124.  
  125. }

ps: t_type表是一张我们用于做测试时候使用的表，这里我们可以根据自己实际的业务需要定制不同的实体类对象

现在我们已经可以通过binlog转换为实体类了，那么接下来就是如何将实体类做额外的传输和处理了。数据的传输我们通常会借助mq这类型的中间件来进行操作，关于这部分的内容我会在后续的文章中做详细的输出。

推荐阅读(点击即可跳转阅读)

1.SpringBoot内容聚合

2.面试题内容聚合

3.设计模式内容聚合

4.Mybatis内容聚合

5.多线程内容聚合

数据的异构实战（一） 基于canal进行日志的订阅和转换的更多相关文章

  1. ASP.NET Core 实战：基于 Dapper 扩展你的数据访问方法

    一.前言 在非静态页面的项目开发中,必定会涉及到对于数据库的访问,最开始呢,我们使用 Ado.Net,通过编写 SQL 帮助类帮我们实现对于数据库的快速访问,后来,ORM(Object Relatio ...

  2. 开源基于Canal的开源增量数据订阅&消费中间件

    CanalSync canal 是阿里巴巴开源的一款基于数据库增量日志解析,提供增量数据订阅&消费,目前主要支持了MySQL(也支持mariaDB). 我开发的这个CanalSync项目 ht ...

  3. 基于canal的client-adapter数据同步必读指南

    本文将介绍canal项目中client-adapter的使用,以及落地生产中需要考虑的可靠性.高可用与监控报警.(基于canal 1.1.4版本) canal作为mysql的实时数据订阅组件,实现了对 ...

  4. 从SQL Server到MySQL，近百亿数据量迁移实战

    从SQL Server到MySQL,近百亿数据量迁移实战 狄敬超(3D) 2018-05-29 10:52:48 212 沪江成立于 2001 年,作为较早期的教育学习网站,当时技术选型范围并不大:J ...

  5. Java生鲜电商平台-SpringCloud微服务开发中的数据架构设计实战精讲

    Java生鲜电商平台-SpringCloud微服务开发中的数据架构设计实战精讲 Java生鲜电商平台:   微服务是当前非常流行的技术框架,通过服务的小型化.原子化以及分布式架构的弹性伸缩和高可用性, ...

  6. 基于Canal和Kafka实现MySQL的Binlog近实时同步

    前提 近段时间,业务系统架构基本完备,数据层面的建设比较薄弱,因为笔者目前工作重心在于搭建一个小型的数据平台.优先级比较高的一个任务就是需要近实时同步业务系统的数据(包括保存.更新或者软删除)到一个另 ...

  7. 大数据存储:MongoDB实战指南——常见问题解答

    锁粒度与并发性能怎么样? 数据库的读写并发性能与锁的粒度息息相关,不管是读操作还是写操作开始运行时,都会请求相应的锁资源,如果请求不到,操作就会被阻塞.读操作请求的是读锁,能够与其它读操作共享,但是当 ...

  8. 《Wireshark数据包分析实战》 - http背后，tcp/ip抓包分析

    作为网络开发人员,使用fiddler无疑是最好的选择,方便易用功能强. 但是什么作为爱学习的同学,是不应该止步于http协议的,学习wireshark则可以满足这方面的需求.wireshark作为抓取 ...

  9. 【Todo】【读书笔记】大数据Spark企业级实战版 & Scala学习

    下了这本<大数据Spark企业级实战版>, 另外还有一本<Spark大数据处理:技术.应用与性能优化(全)> 先看前一篇. 根据书里的前言里面,对于阅读顺序的建议.先看最后的S ...

随机推荐

  1. Python初步接触与学习

    Python的发展史与特点 诞生与发展史 1989,为了度过圣诞假期,Guido开始编写Python语言编译器.Python这个名字来自Guido的喜爱的电视连续剧<蒙蒂蟒蛇的飞行马戏团> ...

  2. mybatis拦截器实现通用权限字段添加

    实现效果 日常sql中直接使用权限字段实现权限内数据筛选,无需入参,直接使用,使用形式为:select * from crh_snp.channelinfo where short_code in ( ...

  3. Android 开发系列教程之（一）Android基础知识

    什么是Android Android一词最早是出现在法国作家维里耶德利尔·亚当1986年发表的<未来夏娃>这部科幻小说中,作者利尔·亚当将外表像人类的机器起名为Android,这就是And ...

  4. .Net基础篇_学习笔记_第四天_switch-case

    swith-case 用来处理多条件的定值的判断. 语法: switch(变量或者表达式的值) { case 值1:要执行的代码: break: case 值2:要执行的代码: break: case ...

  5. Cabloy全栈JS框架微创新之一：不一样的“移动优先 PC适配”

    前言 目前流行的前端UI组件库都支持移动设备优先的响应式布局特性.但基于Mobile和PC两个场景的不同用户体验,也往往会实现Mobile和PC两个版本. PC场景下的Web工程,如大量的后台前端管理 ...

  6. Day4 总结

  7. mysql集群基于docker 在centos上

    新博客https://blog.koreyoshi.work/ mysql集群(PXC)基于docker 在centos上 常用设计方案 Replication(复制) 速度快 弱一致性 低价值 场景 ...

  8. linux双网卡绑定为逻辑网卡

    网卡bond是通过多张网卡绑定为一个逻辑网卡,实现本地网卡的冗余,带宽扩容和负载均衡,在生产场景中是一种常用的技术. 生产环境服务器为:DELL 网卡为:光纤 bond需要修改涉及的网卡配置文件 /e ...

  9. CocosCreator实现动物同化

    获取源码 关注微信公众号『一枚小工 』,发送『动物同化 』获取完整游戏源码. 游戏玩法 游戏目标是将游戏区域的动物全部同化成同一种动物.游戏从左上角开始,从右边点击需要变成的目标动物头像,如果被同化动 ...

  10. 全文搜索引擎 Elasticsearch

    写在前面 最近在学Elasticsearch , 我相信只要是接触过开发的都会听过Elasticsearch或ELK这么一个技术. 主要用来做全文检索或大数据分析等,之前一直处理了解状态. 所以打算系 ...