canal DirectToKafka(采集数据到kafka、json解析、写入kafka)

已于 2023-05-23 15:59:44 修改
阅读量1.1k 收藏 1
点赞数
分类专栏： canal 文章标签： kafka json java canal
于 2023-05-23 15:59:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mogeko1/article/details/130626043
版权

canal DirectToKafka
环境的配置：
在mysql的配置文件中：/etc/my.cnf

linux>/etc/my.cnf 
[mysqld]
server-id=1
log-bin=mysql-bin	//binlog
binlog_format=row	//binlog形式row 一行数据
binlog-do-db=testdb //binlog 数据库testdb

在canal中中配置：
在canal.properties中的配置：

linux>vi conf/canal.properties 
canal.serverMode = kafka
canal.instance.parser.parallel = false
canal.destinations = example
canal.mq.servers = 192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092

在example中的配置instance.properties

linux>vi conf/example/instance.properties
canal.instance.mysql.slaveId=21
#mysql的地址
canal.instance.master.address=192.168.58.203:3306
canal.instance.dbUsername=canal
canal.instance.dbPassword=canal

1.启动canal

linux>bin/startup.sh
注意环境应是java8

2.启动一个消费者

linux>bin/kafka-console-consumer.sh --topic example --from-beginning --bootstrap-server 192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092

在mysql中使用insert 语句
如果有数据，说明环境搭建好了（kafka内）

编写spark streaming 程序：
1.使用direct模式对接kafka

 val conf = new SparkConf().setMaster("local[*]").setAppName(this.getClass.getName)
    val ssc = new StreamingContext(conf, Seconds(5))
    ssc.sparkContext.setLogLevel("error")

    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "canal-demo",
      "auto.offset.reset" -> "latest"
      //      "enable.auto.commit" -> (t: java.lang.Boolean)
    )
    val topics = Array("example")
    val stream = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent,
      Subscribe[String, String](topics, kafkaParams)
    )
  1. 使用 fastJson 解析，偏平化
 stream.map(_.value())
      .map(line=>{
        val jsonObject=JSON.parseObject(line)
        val table=jsonObject.getString("table")
        val types=jsonObject.getString("type")
//        val data=jsonObject.getJSONArray("data")
        val data = jsonObject.getJSONArray("data")
//        for( i <- 0 until jSONArray.size()){
                  val id=jSONArray.getJSONObject(i).getString("id")
                  val name=(jSONArray.getJSONObject(i).getString("name"))
                }
        (table,types,data)
      }).print()
  1. transform 算子 关联 维度数据 （黑名单的程序）
 filter.transform(rdd=>{
      //建立数据库的链接
      rdd.map(line=>{

      })
        //执行查询语句，关联维度数据
		（）
      })

json解析测试

package SparkTest.canal
import com.alibaba.fastjson.JSON
object JsonTest {
  //解析本地json 格式 日志分析
  //和TransformationDemo 关连
  def main(args: Array[String]): Unit = {
    // val nums = List(1, 2, 3, 4)
    val value = "{\"data\":[{\"id\":\"1\",\"name\":\"lisi\",\"score\":\"100\"},{\"id\":\"2\",\"name\":\"lisi\",\"score\":\"100\"},{\"id\":\"3\",\"name\":\"lisi\",\"score\":\"100\"}],\"database\":\"scott\",\"es\":1644282564000,\"id\":8,\"isDdl\":false,\"mysqlType\":{\"id\":\"int(11)\",\"name\":\"varchar(30)\",\"score\":\"int(11)\"},\"old\":[{\"name\":\"zhaoliu\"},{\"name\":\"zhaoliu\"},{\"name\":\"zhaoliu\"}],\"sql\":\"\",\"sqlType\":{\"id\":4,\"name\":12,\"score\":4},\"table\":\"student\",\"ts\":1644282564778,\"type\":\"UPDATE\"}"
    try {
      val jsonObject = JSON.parseObject(value)
      println(jsonObject)
      println(jsonObject.getString("table"))
      println(jsonObject.getString("type"))
      println(jsonObject.getJSONArray("data"))
      val jSONArray = jsonObject.getJSONArray("data")

      for (i <- 0 until jSONArray.size()) {
        println(jSONArray.getJSONObject(i).getString("id"))
        println(jSONArray.getJSONObject(i).getString("name"))
      }
      //      val students: = jSONArray.toJavaList[Student](Student.
      //      class)
      // println(students)
    } catch {
      case e: Exception => {
        e.printStackTrace()
      }
    }
  }
}

解析服务器上的 kafka日志分析，json 格式

package SparkTest.canal
import com.alibaba.fastjson.JSON
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.apache.spark.streaming.kafka010.KafkaUtils
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
//解析服务器上的 kafka日志分析，json 格式
object TransformationDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local[*]").setAppName(this.getClass.getName)
    val ssc = new StreamingContext(conf, Seconds(5))
    ssc.sparkContext.setLogLevel("error")

    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "canal-demo",
      "auto.offset.reset" -> "latest"
      //      "enable.auto.commit" -> (t: java.lang.Boolean)  //自动提交
    )
    
    val topics = Array("example")
    val stream = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent,
      Subscribe[String, String](topics, kafkaParams)
    )
    /**
     * 从topic中取出的数是key，value格式，一般情况只处理value
     */
     val filter = stream.map(_.value())
    stream.map(_.value())
      .map(line => {
        val jsonObject = JSON.parseObject(line)
        val table = jsonObject.getString("table")
        val types = jsonObject.getString("type")
        //        val data=jsonObject.getJSONArray("data")
        val data = jsonObject.getJSONArray("data")
        /*              for( i <- 0 until jSONArray.size()){
              //          val id=jSONArray.getJSONObject(i).getString("id")
              //          val name=(jSONArray.getJSONObject(i).getString("name"))
              //        }*/
        (table, types, data) //取值 json扁平化
      }).print()
        filter.transform(rdd=>{
          //建立数据库的链接
          rdd.map(line=>{
          })
            //执行查询语句，关联维度数据
          })
    ssc.start()
    ssc.awaitTermination()
  }
}

将数据写入kafka
1，收集到Driver端，构造一个producer 发送数据
2，在每个executor端构造一个producer 发送数据
需要在driver发送到executor 需要序列化 lazy val producer

1.定义类KafkaSink：
2.在driver端：构造一个广播变量，广播到每个executor

 val kafkaProducer: Broadcast[KafkaSink[String, String]] = {
      val kafkaProducerConfig = {
        val p = new Properties()
        p.setProperty("bootstrap.servers", "192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092")
        p.setProperty("key.serializer", classOf[StringSerializer].getName)
        p.setProperty("value.serializer", classOf[StringSerializer].getName)
        p
      }
//      log.warn("kafka producer init done!")
      ssc.sparkContext.broadcast(KafkaSink[String, String](kafkaProducerConfig))
    }

3.在executor端使用：
	 stream.foreachRDD { rdd =>
      if (!rdd.isEmpty) {
        rdd.foreach(record => {
          kafkaProducer.value.send("example", record.key(),record.value())
          // do something else
        })
      }

1.启动一个生产者，生产数据 wordcount

linux>bin/kafka-console-producer.sh  --broker-list 192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092 --topic wordcount

运行SparkStreamingKafkaDemo后 随便输入数据
2.启动一个消费者，example

linux>bin/kafka-console-consumer.sh  --topic example --from-beginning --bootstrap-server 192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092

DirectToKafka

package SparkTest.canal
import java.util.Properties
//6-4 最终
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.{StringDeserializer, StringSerializer}
import org.apache.spark.SparkConf
import org.apache.spark.broadcast.Broadcast
import org.apache.spark.streaming.{Durations, StreamingContext}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.apache.spark.streaming.kafka010.{CanCommitOffsets, HasOffsetRanges, KafkaUtils, OffsetRange}
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent

object SparkStreamingKafkaDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()
    conf.setMaster("local[*]")
    conf.setAppName("submitoffset")
    val ssc = new StreamingContext(conf, Durations.seconds(5))
    //设置日志级别
    ssc.sparkContext.setLogLevel("Error")

    val kafkaProducer: Broadcast[KafkaSink[String, String]] = { //定义的广播变量
      val kafkaProducerConfig = {
        val p = new Properties()
        p.setProperty("bootstrap.servers", "192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092")
        p.setProperty("key.serializer", classOf[StringSerializer].getName)
        p.setProperty("value.serializer", classOf[StringSerializer].getName)
        p
      }
      //      log.warn("kafka producer init done!")
      ssc.sparkContext.broadcast(KafkaSink[String, String](kafkaProducerConfig))  //调用方法做广播变量（List）
    }

    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "192.168.58.201:9092,192.168.58.202:9092,192.168.58.203:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "test", //

      /**
       * 当没有初始的offset，或者当前的offset不存在，如何处理数据
       * earliest ：自动重置偏移量为最小偏移量
       * latest：自动重置偏移量为最大偏移量【默认】
       * none:没有找到以前的offset,抛出异常
       */
      "auto.offset.reset" -> "earliest",
      /**
       * 当设置 enable.auto.commit为false时，不会自动向kafka中保存消费者offset.需要异步的处理完数据之后手动提交
       */
      "enable.auto.commit" -> (true: java.lang.Boolean) //默认是true 每5s提交一次
    )
    //    从wordcount读出数据，写入example：
    //      1.启动一个生产者，生产数据 wordcount
    //      2.启动一个消费者，example
    val topics = Array("wordcount")
    // 原始的stream 中包含了 offset的信息
    val stream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent,
      Subscribe[String, String](topics, kafkaParams)
    )
    // 获取 record 中 value
    //    val valueStream: DStream[String] = stream.map(record => {
    //
    //      println("receive message key = " + record.key)
    //      println("receive message value = " + record.value)
    //      record.value
    //    })
    //    val words: DStream[String] = valueStream.flatMap(line => {
    //      line.split(" ")
    //    })
    //    val result: DStream[(String, Int)] = words.map((_, 1)).reduceByKey(_ + _)
    //    result.print()

    /**
     * 以上业务处理完成之后，异步的提交消费者offset,这里将 enable.auto.commit 设置成false,就是使用kafka 自己来管理消费者offset
     * 注意这里，获取 offsetRanges: Array[OffsetRange] 每一批次topic 中的offset时，必须从 源头读取过来的 stream中获取，不能从经过stream转换之后的DStream中获取。
     */
    //    stream.map(_.value()).transform(rdd=>{
    //      rdd
    //    })
    stream.foreachRDD { rdd =>
      if (!rdd.isEmpty) {
        rdd.foreach(record => {
          //    从wordcount读出数据，写入example：
          //    1.启动一个生产者，生产数据 wordcount
          //    2.启动一个消费者，example
          kafkaProducer.value.send("example", record.key(),record.value())
          // do something else
        })
      }
      //      val offsetRanges: Array[OffsetRange] = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      //      // some time later, after outputs have completed
      //      // 业务处理完，收动提交offset
      //      stream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
    }
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }
}
CDC 数据入湖方案：Flink CDC ＞ Kafka ＞ Hudi
Laurence的技术博客
02-20 913
本方案的技术链路为：使用 Flink CDC 将 MySQL 的 CDC 数据 （Json 格式）接入到 Kafka ，然后通过 Flink Hudi Connector 将摄取的 CDC 数据写入到 Hudi 表中。文本是本博客的 CDC 数据入湖系列方案中最为基础的一套堆栈，架构上也比较简单，适合作为 POC 快速搭建 CDC 实时处理链路。如果寻求更加适用于生产环境的解决方案，请参考
Canal 监听 Mysql 自动写入 Kafka 并消费 配置 Windows 版
03-18
Canal 监听 Mysql 自动写入 Kafka 并消费 配置 Windows 版
Canal入门（二）
h_big_tiger的博客
08-22 628
Canal入门（二） canal kafka quickStart 这两天看了一下canal的github文档，有了一些笔记，在这里记录一下： https://github.com/alibaba/canal 1、基本说明 canal 1.1.1版本之后, 默认支持将canal server接收到的binlog数据直接投递到MQ, 目前默认支持的MQ系统有:kafka，RocketMQ 2、环境版...
Canal搭建 idea设置及采集数据到kafka
Mogeko1的博客
05-18 867
Canal搭建 idea设置及采集数据到kafka
canal 投递 数据 只进kafka 0分区
weixin_43564627的博客
07-21 730
canal 投递 数据 只进kafka 0分区 首先要确保其余kafka 有多个分区 在 instance.properties 加入以下配置即可 二者缺一不可 下面一段摘至官网： mq顺序性问题 1.canal目前选择支持的kafka/rocketmq，本质上都是基于本地文件的方式来支持了分区级的顺序消息的能力，也就是binlog写入mq是可以有一些顺序性保障，这个取决于用户的一些参数选择 2.canal支持MQ数据的几种路由方式：单topic单分区，单topic多分区、多topic单分区、多topi
将json格式数据写到kafka（csv转json）
mianhuatang__的博客
04-26 2860
很简单的一个小demo，没有封装，通俗易懂 public class test1 { public static void main(String[] args) throws IOException { // kafka生产者配置 Properties properties = new Properties(); properties.setProperty("bootstrap.servers", "dap01:9092");
canal 同步数据 从mysql到kafka
02-11
- Canal监听并解析binlog，获取到数据变更事件。 - 将事件转化为特定格式（如JSON），发送到Kafka的特定主题。 - Kafka接收到消息后，存储在分区中，并等待消费者消费。 5. **配置与部署**： - 安装Canal：通常...
实时数仓-mysql业务数据采集到kafka的ODS层(Canal+Protobuf+Kafka)
weixin_43861104的博客
01-13 1250
1.简介 本篇使用Cnal监控mysql中binglog日志的变化，解析二进制日志为map类型的数据，并引入Protobuf实现对象的序列化，写入到kafka，生成实时数仓ODS层的原始数据。 2.代码实现 2.1项目的入口 package com.bigdata.app; import com.bigdata.client.CanalClient; /** * @ description: 项目启动类 * @ author: spencer * @ date: 2021/1/12 13:41
Kafka相关配置，canal检测数据发送kafka同步数据到ES
weixin_42772168的博客
02-25 981
文章目录前言1.application.yml2.kafka的配置类config2.kafka的consumer总结 前言 Kafka是最初由Linkedin公司开发，是一个分布式、分区的、多副本的、多订阅者，基于zookeeper协调的分布式日志系统（也可以当做MQ系统），常见可以用于web/nginx日志、访问日志，消息服务等等，Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。 主要应用场景是：日志收集系统和消息系统。 Kafka主要设计目标如下： 以时间复杂度为O(1)的方
使用canal保持mysql与kafka数据同步
欢迎大神交流讨论
01-18 2200
1.下载canel https://github.com/alibaba/canal/releases 2.开启MySQL的binlog配置 如果你忘记了my.cnf的路径 find / -name my.cnf cd /etc vi my.cnf #打开my.cnf（window my.ini） 在【mysqld】块中添加 server-id=1 log-bin=mysql-bin binlog_format=row binlog-do-db=你数据库的名字 多个用逗号隔开(这里是
Canal推送到kafka
窗外小雨
02-22 592
cannal, kafka
Canal数据格式及写入Kafka数据样例
qq_39285950的博客
12-28 1853
canal中ts,es区别具体insert/update/delete的变更数据，可为多条，1个binlog event事件可对应多条变更，如批处理.操作类型(INSERT,UPDATE,DELETE,QUERY,TRUNCATE)时间戳(13位),canal收到这个binlog,构造自己协议对象的时间.是否是ddl变更操作，比如create table/drop table。mysql binlog里原始的时间戳,也就是数据原始变更的时间。修改前的字段数据(id变更前的值)data中每个字段对应的格式类型
Kafka生产者示例：发送JSON数据到Kafka Topic
2301_79367634的博客
08-13 2180
Kafka生产者示例：发送JSON数据到Kafka TopicKafka是一个高性能、分布式的流处理平台，广泛应用于大数据领域。本文将深入浅出地介绍如何使用Kafka生产者发送JSON数据到Kafka Topic，并附带相应的源代码。
大数据项目实战(7) | 从Canal读取数据到Kafka
Knight
09-24 649
目录从Canal读取数据准备数据库数据代码实现读取数据发送到Kafka 从Canal读取数据 添加依赖 <!-- https://mvnrepository.com/artifact/com.alibaba.otter/canal.client --> <!--canal 客户端, 从 canal 服务器读取数据--> <dependency> <groupId>com.alibaba.otter&
实时同步：使用 Canal 和 Kafka 解决 MySQL 与缓存的数据一致性问题
最新发布
xaiobit_hl的博客
07-25 2070
由此可见，对数据库的每一个修改操作，都是对应固定格式的一个数据，所以可以监听对应的 topic 并针对 data 中的数据进行一个提取，得到一个 cacheKey，然后删除对应的缓存，使得下一次的查询去访问数据库，并同步缓存。canal 监控 binlog 日志，binlog 日志的传输默认使用 MySQL 的复制协议（基于 TCP/IP），执行修改操作：将 “如何学习Spring？”修改成 “如何学习Spring？将 canal 下 plugin 下的所有 jar 包拷贝到 lib 目录下。
python向kafka储存数据_对python操作kafka写入json数据的简单demo分享
weixin_39882589的博客
02-03 830
如下所示： 安装kafka支持库pip install kafka-python from kafka import KafkaProducerimport json'''生产者demo向test_lyl2主题中循环写入10条json数据注意事项：要写入json数据需加上value_serializer参数，如下代码'''producer = KafkaProducer(value_seriali...
SparkStreaming 解析Kafka JSON格式数据
热门推荐
shirukai
12-22 2万+
SparkStreaming 解析Kafka JSON格式数据 项目记录：在项目中，SparkStreaming整合Kafka时，通常Kafka发送的数据是以JSON字符串形式发送的，这里总结了五种SparkStreaming解析Kafka中JSON格式数据并转为DataFrame进行数据分析的方法。 需求：将如下JSON格式的数据 转成如下所示的DataFrame 1 使用Python脚...
基于Canal与Flink实现数据实时增量同步(二)
麒思妙想
06-11 971
点击“蓝字”关注我吧背景在数据仓库建模中，未经任何加工处理的原始业务层数据，我们称之为ODS(Operational Data Store)数据。在互联网企业中，常见的ODS数据有业务日...
3.canal解析binlog送入kafka
PacosonSWJTU的博客
09-17 1360
1.本文介绍了 canal把日志解析后送入到kafka的配置；2.canal抽取增量binlog日志的架构图，参见2.canal服务器配置及java客户端_PacosonSWJTU的博客-CSDN博客mysql master节点可以开启biglog日志记录功能，开启后每次向mysql服务端发送写操作命令，会把命令记录在一种特殊的文件中，这个特殊的文件称为biglog日志。若服务器异常退出，借用binlog可以恢复数据！二进制日志索引文件（文件名后缀为.index）用于记录所有的二进制文件；
Canal深度解析：MySQL数据采集到Kafka的实战教程
此外，教程还涉及TCP模式下的数据解析和自定义数据格式的实现。提供全套视频教程、教辅文档、源代码和相关软件，旨在全面掌握Canal的使用。" 在大数据领域，Canal是一款由阿里巴巴开源的数据库实时增量同步工具，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值