Spark Streaming（二）

最新推荐文章于 2024-04-23 00:39:17 发布
最新推荐文章于 2024-04-23 00:39:17 发布
阅读量532 收藏
点赞数
分类专栏： Spark 数据计算 文章标签： Spark 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luoyepiaoxue2014/article/details/128077512
版权

声明：
        文章中代码及相关语句为自己根据相应理解编写，文章中出现的相关图片为自己实践中的截图和相关技术对应的图片，若有相关异议，请联系删除。感谢。转载请注明出处，感谢。


By luoyepiaoxue2014

B站：https://space.bilibili.com/1523287361 点击打开链接
微博地址： https://weibo.com/luoyepiaoxue2014 点击打开链接

title: Spark系列

一、Transformation 高级算子

官网链接： https://spark.apache.org/docs/3.1.2/streaming-programming-guide.html#transformations-on-dstreams

1.1 updateStateByKey

在这里插入图片描述

updateStateByKey可以实现累计

package com.aa.sparkscala.streaming

import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
 * @Author AA
 * @Project bigdatapre
 * @Package com.aa.sparkscala.streaming
 */
object UpdateStateByKeyDemo {
  def main(args: Array[String]): Unit = {
    /**
     * 1、程序入口
     */
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf = new SparkConf()
    conf.setMaster("local[2]")
    conf.setAppName("UpdateStateByKeyDemo")
    val ssc = new StreamingContext(conf,Seconds(2))
    ssc.checkpoint("D://UpdateStateByKeyDemo_CheckPointDir")
    /**
     * 2、数据的输入
     */
    val myDStream: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop12",9991)
    /**
     * 3、数据的处理
     */
    val wordDStream = myDStream.flatMap(_.split(" "))//hadoop hadoop hadoop
    val wordAndOneDStream = wordDStream.map((_,1))

    /**
     * updateFunc: (Seq[V], Option[S]) => Option[S]
     * 参数一：Seq[V]
     * hadoop 1
     * hadoop 1
     * hadoop 1
     * 分组：
     * {hadoop,(1,1,1)} -> values  (1,1,1)
     *
     * 参数二： Option[S]
     * 当前的这个key的上一次的状态（历史的状态）
     *
     * Option：
     * Some 有值
     * None 没有值
     * 返回值：
     * 当前key出现的次数
     *
     */
    var resultDStream = wordAndOneDStream.updateStateByKey((values: Seq[Int], state: Option[Int]) => {
      val currentCount = values.sum
      val lastCount = state.getOrElse(0)
      Some(currentCount + lastCount)
    })

    /**
     * 4、数据的输出
     */
    resultDStream.print()

    /**
     * 5、启动程序
     */
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }

}

1.2 mapWithState

代码

package com.aa.sparkscala.streaming
import org.apache.log4j.{Level, Logger}
import org.apache.spark.streaming._
import org.apache.spark.{SparkConf, SparkContext}

/**
 * @Author AA
 * @Project bigdatapre
 * @Package com.aa.sparkscala.streaming
 *
 * MapWithStateAPIDemo 测试
 *
 * updateStateBykey 官网上能看到
 * mapWithState 官方博客上面有，而且说测试过性能更好
 */
object MapWithStateAPIDemo {
  def main(args: Array[String]): Unit = {
    Logger.getLogger("org").setLevel(Level.ERROR)

    val sparkConf = new SparkConf().setAppName("NetworkWordCount").setMaster("local[2]")
    val sc = new SparkContext(sparkConf)
    val ssc = new StreamingContext(sc, Seconds(2))

    ssc.checkpoint("D://MapWithStateAPIDemo_CheckPointDir")

    val lines = ssc.socketTextStream("hadoop12", 9992)

    val words = lines.flatMap(_.split(" "))
    val wordsDStream = words.map(x => (x, 1))

    val initialRDD = sc.parallelize(List(("flink", 100L), ("spark", 50L))) //初始的一些值

    /**示例，假如输入 hadoop hadoop hadoop
     * 切分之后变成了：
     * hadoop 1
     * hadoop 1
     * hadoop 1
     *
     * 经过 mapWithState 里面的bykey操作 之后，变成了如下：
     * {hadoop,(1,1,1)  => 3}
     *
     *  hadoop 3
     *
     *  hadoop 10
     *
     * key:hadoop  当前的key
     * value:3  当前的key出现的次数
     * lastState： 当前的这个key的历史的状态
     *
     * hadoop:3
     *
     * hadoop,10
     *
     * hadoop,13
     *
     */
    // currentBatchTime :  表示当前的Batch的时间
    // key:     表示需要更新状态的key
    // value:   表示当前batch的对应的key的对应的值
    // lastState :   对应key的当前的状态
    val stateSpec =StateSpec.function((currentBatchTime: Time, key: String, value: Option[Int], lastState: State[Long]) => {

      val sum = value.getOrElse(0).toLong + lastState.getOption.getOrElse(0L) //求和

      val output = (key, sum)
      //更改状态
      //如果你的数据没有超时
      if (!lastState.isTimingOut()) {
        lastState.update(sum)
      }
      //最后一行代码是返回值
      Some(output) //返回值要求是key-value类型
    }).initialState(initialRDD)
      .numPartitions(2).timeout(Seconds(15))
    //timeout:超时。 当一个key超过这个时间没有接收到数据的时候，这个key以及对应的状态会被移除掉。也就是重新统计。

    /**
     * reduceByKey
     *
     * udpateStateByKey
     * mapWithState // 里面也有bykey操作 -> 在bykey分组的时候顺带就完成了合并的操作
     */
    val result = wordsDStream.mapWithState(stateSpec)
    //result.print() //打印出来发生变化的那些数据
    result.stateSnapshots().print()  //打印出来的是全量的数据

    //启动Streaming处理流
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }

}

1.3 Transform实现黑名单过滤

package com.aa.sparkscala.streaming
import org.apache.log4j.{Level, Logger}
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}
/**
 * @Author AA
 * @Project bigdatapre
 * @Package com.aa.sparkscala.streaming
 */
object TransformDemo {
  def main(args: Array[String]): Unit = {
    //0、打印日志
    Logger.getLogger("org").setLevel(Level.WARN)
    //1、程序入口
    val sparkConf = new SparkConf().setAppName("TransformDemo").setMaster("local[*]")
    val sc = new SparkContext(sparkConf)
    val ssc = new StreamingContext(sc, Seconds(2))

    //2、数据的输入
    val lines = ssc.socketTextStream("hadoop12", 9993)
    lines.print()

    val words = lines.flatMap(_.split(" "))
    val wordsDStream = words.map(x => (x, 1))

    /**
     * 3、数据的处理
     *
     * 首先要获取到黑名单，企业中可以从Mysql，Redis里面去获取。
     * 我们这里 造一个  黑名单的的规则
     * 其实也就是一个 过滤的小小的规则
     * 比如： "$","?","!"
     */
    val filterRDD: RDD[(String, Boolean)] = ssc.sparkContext.parallelize(List("$","?","!")).map((_,true))
    //1、给过滤的规则数据广播出去
    val filterBroadBast = ssc.sparkContext.broadcast(filterRDD.collect())
    //mapRDD
    val filterResultRDD: DStream[(String, Int)] = wordsDStream.transform(rdd => {
      val filterRDD = ssc.sparkContext.parallelize(filterBroadBast.value)
      //左连接 join，如果join不上的数据  大家可以想一下是不是需要的数据
      /**
       * (String(key), (Int(1), Option[Boolean]))
       * 通过这个option没值 来进行判断
       */
      val result: RDD[(String, (Int, Option[Boolean]))] = rdd.leftOuterJoin(filterRDD)
      val joinResult = result.filter(tuple => {
        tuple._2._2.isEmpty //过滤出来我们需要的数据
      })
      //在Scala里面最后一行就是方法的返回值  这个都是小知识  大家应该知道
      //hadoop,1
      joinResult.map(tuple => (tuple._1, tuple._2._1))
    })

    //4、数据的输出
    val result = filterResultRDD.reduceByKey(_+_)
    result.print()

    //5、启动 程序
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()

  }
}

1.4 Window操作

1.4.1 代码

package com.aa.sparkscala.streaming

import org.apache.log4j.{Level, Logger}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/**
 * @Author AA
 * @Project bigdatapre
 * @Package com.aa.sparkscala.streaming
 */
object WindowDemo {
  def main(args: Array[String]): Unit = {
    //0、打印日志
    Logger.getLogger("org").setLevel(Level.WARN)

    //1、程序入口
    val sparkConf = new SparkConf().setAppName("WindowDemo").setMaster("local[2]")
    val sc = new SparkContext(sparkConf)
    val ssc = new StreamingContext(sc, Seconds(2))

    //2、数据的输入
    val lines = ssc.socketTextStream("hadoop12", 9994)

    //3、数据的处理
    val words = lines.flatMap(_.split(" "))
    val wordsDStream = words.map(x => (x, 1))
    /**
     * reduceFunc: (V, V) => V,
     * windowDuration: Duration,
     * slideDuration: Duration 滑动窗口的单位
     *
     * 请注意：窗口大小和滑动间隔必须是间隔的整数倍
     * 间隔： val ssc = new StreamingContext(sc, Seconds(2))
     * 窗口大小： Seconds(6)
     * 滑动间隔： Seconds(4)
     *
     * 下面的代码的意思是 每隔2秒计算一下，最近6秒的单词出现的次数。
     * reduceByKeyAndWindow((x:Int,y:Int) => x+y,Seconds(6),Seconds(1))
     */
    val result = wordsDStream.reduceByKeyAndWindow((x:Int,y:Int) => x+y,Seconds(6),Seconds(4))

    //4、数据的输出
    result.print()

    //5、程序的启动
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }
}

1.4.2 可能遇到的错误及解决方案

Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties
Exception in thread "main" java.lang.Exception: The slide duration of windowed DStream (3000 ms) must be a multiple of the slide duration of parent DStream (2000 ms)
	at org.apache.spark.streaming.dstream.WindowedDStream.<init>(WindowedDStream.scala:41)
	at org.apache.spark.streaming.dstream.DStream.$anonfun$window$1(DStream.scala:768)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)
	at org.apache.spark.SparkContext.withScope(SparkContext.scala:786)
	at org.apache.spark.streaming.StreamingContext.withScope(StreamingContext.scala:264)
	at org.apache.spark.streaming.dstream.DStream.window(DStream.scala:768)
	at org.apache.spark.streaming.dstream.PairDStreamFunctions.$anonfun$reduceByKeyAndWindow$4(PairDStreamFunctions.scala:277)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)
	at org.apache.spark.SparkContext.withScope(SparkContext.scala:786)
	at org.apache.spark.streaming.StreamingContext.withScope(StreamingContext.scala:264)
	at org.apache.spark.streaming.dstream.PairDStreamFunctions.reduceByKeyAndWindow(PairDStreamFunctions.scala:278)
	at org.apache.spark.streaming.dstream.PairDStreamFunctions.$anonfun$reduceByKeyAndWindow$2(PairDStreamFunctions.scala:233)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)
	at org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)
	at org.apache.spark.SparkContext.withScope(SparkContext.scala:786)
	at org.apache.spark.streaming.StreamingContext.withScope(StreamingContext.scala:264)
	at org.apache.spark.streaming.dstream.PairDStreamFunctions.reduceByKeyAndWindow(PairDStreamFunctions.scala:233)
	at com.aa.sparkscala.streaming.WindowDemo$.main(WindowDemo.scala:36)
	at com.aa.sparkscala.streaming.WindowDemo.main(WindowDemo.scala)

Process finished with exit code 1

出现上面的错误的原因是因为窗口大小和滑动间隔必须是间隔的整数倍

  例如：
     * 间隔： val ssc = new StreamingContext(sc, Seconds(2))
     * 窗口大小： Seconds(6)
     * 滑动间隔： Seconds(4)

1.5 关于测试nc -lk的说明

在测试的时候可以在linux中使用nc -lk进行模拟数据的输入

[root@hadoop12 ~]# nc -lk 9992
flink
hbase
hadoop
....

二、Output 高级算子

拿核心算子讲解

2.1 foreachRDD

2.1.1 添加pom依赖

这是因为我们要给测试的输出的结果添加到mysql中去。所以要添加mysql的相关依赖。

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>

2.1.2 代码

package com.aa.sparkscala.streaming
import org.apache.log4j.{Level, Logger}

import java.sql.DriverManager
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}
/**
 * @Author AA
 * @Project bigdatapre
 * @Package com.aa.sparkscala.streaming
 *
 * ForeachDemo 多种案例
 */
object ForeachDemo {
  def main(args: Array[String]) {
    //0、打印日志
    Logger.getLogger("org").setLevel(Level.WARN)

    //1、程序入口
    val sparkConf = new SparkConf().setAppName("ForeachDemo").setMaster("local[2]")
    val sc = new SparkContext(sparkConf)
    val ssc = new StreamingContext(sc, Seconds(4))

    //2、数据的输入
    val lines = ssc.socketTextStream("hadoop12", 9995)

    //3、数据的处理
    val words = lines.flatMap(_.split(" "))
    val wordCounts = words.map(x => (x, 1)).reduceByKey(_ + _)

    //4、数据的输出   将结果保存到Mysql 代码可以运行。
    wordCounts.foreachRDD { (rdd, time) =>

      rdd.foreach { record =>
        //为每一条数据都创建了一个连接。
        //连接使用完了以后就关闭。 频繁的创建和关闭连接。其实对数据性能影响很大。 这个就是可以优化的点  同学们自己考虑，自己动手解决
        //executor,worker
        Class.forName("com.mysql.jdbc.Driver")
        val conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/spark", "root", "111111")
        val statement = conn.prepareStatement(s"insert into wordcount(ts, word, count) values (?, ?, ?)")
        statement.setLong(1, time.milliseconds.toLong)
        statement.setString(2, record._1)
        statement.setInt(3, record._2)
        statement.execute()
        statement.close()
        conn.close()
      }
    }

    //启动Streaming处理流
    ssc.start()
    //等待Streaming程序终止
    ssc.awaitTermination()
    ssc.stop()
  }

}

2.1.3 测试结果

在shell窗口中输入对应的数据

[root@hadoop12 ~]# nc -lk 9995
hello hadoop world spark flink hadoop hello hadoop

在这里插入图片描述

查看mysql中的结果

在这里插入图片描述

三、Checkpoint

package com.aa.sparkscala.streaming

import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
 * @Author AA
 * @Project bigdatapre
 * @Package com.aa.sparkscala.streaming
 * 为了保证 Driver 的 HA
 */
object UpdateStateByKeyDemo {
  def main(args: Array[String]): Unit = {
    /**
     * 1、程序入口
     */
    Logger.getLogger("org").setLevel(Level.ERROR)
    val conf = new SparkConf()
    conf.setMaster("local[2]")
    conf.setAppName("UpdateStateByKeyDemo")
    val ssc = new StreamingContext(conf,Seconds(2))
    ssc.checkpoint("D://UpdateStateByKeyDemo_CheckPointDir")
    /**
     * 2、数据的输入
     */
    val myDStream: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop12",9996)
    /**
     * 3、数据的处理
     */
    val wordDStream = myDStream.flatMap(_.split(" "))//hadoop hadoop hadoop
    val wordAndOneDStream = wordDStream.map((_,1))

    /**
     * updateFunc: (Seq[V], Option[S]) => Option[S]
     * 参数一：Seq[V]
     * hadoop 1
     * hadoop 1
     * hadoop 1
     * 分组：
     * {hadoop,(1,1,1)} -> values  (1,1,1)
     *
     * 参数二： Option[S]
     * 当前的这个key的上一次的状态（历史的状态）0
     *
     * Option：
     * Some 有值
     * None 没有值
     * 返回值：
     * 当前key出现的次数
     *
     */
    var resultDStream = wordAndOneDStream.updateStateByKey((values: Seq[Int], state: Option[Int]) => {
      val currentCount = values.sum
      val lastCount = state.getOrElse(0)
      Some(currentCount + lastCount)
    })

    /**
     * 4、数据的输出
     */
    resultDStream.print()

    /**
     * 5、启动程序
     */
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }

}

四、SparkStreaming和SparkSQL整合

SparkStreaming和SparkSQL整合之后，就非常的方便，可以使用SQL的方式操作相应的数据。很方便。

package com.aa.sparkscala.streaming

import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.SparkSession
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.{Seconds, StreamingContext}

/**
 * @Author AA
 * @Project bigdatapre
 * @Package com.aa.sparkscala.streaming
 */
object StreamAndSQLDemo {
  def main(args: Array[String]): Unit = {
    //0、打印日志
    Logger.getLogger("org").setLevel(Level.WARN)

    //1、程序入口
    val sparkConf = new SparkConf().setAppName("StreamAndSQLDemo").setMaster("local[2]")
    val sc = new SparkContext(sparkConf)
    val ssc = new StreamingContext(sc, Seconds(5)) //SS其实是准实时   flink是真正的实时

    //2、数据的输入
    val lines = ssc.socketTextStream("hadoop12", 9997)

    //3、数据的处理
    val words = lines.flatMap(_.split(" "))
    //  获取到一个一个的单词
    words.foreachRDD( rdd =>{
      val spark = SparkSession.builder().config(rdd.sparkContext.getConf).getOrCreate()
      import spark.implicits._
      // 隐式转换
      val wordDataFrame = rdd.toDF("word")
      // 注册一个临时视图
      wordDataFrame.createOrReplaceTempView("words")

      //4、数据的输出
      spark.sql("select word,count(*) as totalCount from words group by word")
        .show()
    })

    //5、程序的启动
    ssc.start()
    ssc.awaitTermination()
    ssc.stop()
  }

}
落叶飘雪2014
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark streaming
03-14
spark streaming streaming
Spark Streaming 示例
04-03
包含kafka消息中间件的使用和Spark Streaming的示例。
SparkStreaming编程讲解
01-30
1.什么是SparkStreaming？2.SparkStreaming可以接受那些数据源？3.Dstream，我们可以进行哪两种操作？Sparkstreaming:构建在Spark上处理Stream数据的框架，基本的原理是将Stream数据分成小的时间片断（几秒），以类似batch批量处理的方式来处理这小部分数据。Spark Streaming构建在Spark上，一方面是因为Spark的低延迟执行引擎（100ms+）可以用于实时计算，另一方面相比基于Record的其它处理框架（如Storm），RDD数据集更容易做高效的容错处理。
SparkStreaming入门案例
06-22
本文SparkStream从磁盘文件、HDFS、KAFKA获取数据源，以单词频次统计作为入门案例，介绍了SparkStream模块API的使用。同时介绍了SparkStream的特点
第4.3章：StarRocks数据导出--Spark Connector
流木的博客
03-01 3404
通过Spark Connector，我们可以使用Spark来快速读取StarRocks中存储的数据。Spark Connector在使用上和咱们之前介绍的Flink Connector Source类似，二者都具备并行读取StarRocks的BE节点数据的能力，相对于jdbc的方式大大提高了数据读取效率。 Spark Connector目前只能用来读取数据，Sink部分需要咱们自己基于Stream Load实现。此外，Spark Connector版本更新较慢，所以相对更推荐使用Flink Connect
spark通过connector的方式读写starrocks
YiRan_Zhao的博客
03-29 2074
2，导入官方github里的sparkdemo下的文件到自己的目录下，如下。3，spark写数据到starrocks样例代码可以根据官方demo改。上面的包可以在下面git里的resource里下载。然后在resources下面加上这个包。--starrocks的包-->1，添加maven依赖。参考官方github。
✨ StarRocks 9 月社区动态
StarRocks的博客
10-11 765
让我们一起来回顾 StarRocks 9 月的高光时刻！
Spark jdbc读写的数据对账功能和问题解决
lilyjoke的专栏
03-29 492
3. 当某一条数据写入错误时，整个spark任务是失败状态，但是发现有部分数据已经成功写到表，有部分数据回退的情况。1. 注册JdbcRelationProvider，实现createRelation， 通过调用JdbcUtils.saveTable()方法实现写表功能。可以发现，savePartition是有做事务的，发生错误之后可以回退。2. saveTable的内部实现，可以看到主要实现方法是，拼接了一个insert的执行对象，然后根据写入的分区遍历写入。这个时候，其实是异步的，并不是串行的。
从Spark序列化问题理解闭包
Cool0的博客
05-19 823
从Spark序列化问题理解闭包 问题描述 在一次开发中，遇到这个问题 Caused by: java.io.NotSerializableException: Object of org.apache.spark.streaming.kafka010.DirectKafkaInputDStream is being serialized possibly as a part of closure of an RDD operation. This is because the DStream object
第3.8章：StarRocks数据导入--Spark Load
流木的博客
02-23 3579
Spark Load是通过外部的Spark资源实现对导入数据的预处理，进而提高StarRocks大数据量的导入性能，同时也可以节省StarRocks集群的计算资源。Spark Load的操作本身不复杂，但涉及的技术栈比较多，架构相对较重，所以主要用于初次迁移、构建全局字典、大数据量导入等场景（数据量可到TB级别）。 通常来说，Spark Load的整体逻辑是：读Hadoop数据源中的数据文件-->使用Spark自己的计算资源进行ETL-->将ETL后的文件保存到计算资源中配置的Hadoop中-
sparkstreaming.zip
11-27
java的sparkstreaming连接kafka的例子，kafka生产者生产消息，消费者读取消息，sparkstreaming读取kafka小区并进行存储iotdb数据库。
基于Scala和Java的Spark Streaming二次封装开源框架设计源码
04-08
Spark Streaming二次封装开源框架 - 基于Scala和Java构建，包含1157个文件，提供实时流任务调度、Kafka偏移量管理、Web后台管理、Web API控制等功能。该框架简化业务开发流程，让开发者专注于业务逻辑，无需担心底层...
sparkSql写入starRocks
qq_42389487的博客
03-20 656
sparkSql写入starRocks
spark线上环境写入starRocks中文乱码
qq_42389487的博客
03-20 299
starRocks中文乱码
StarRocks 自增ID实现分页优化
齐天大圣数据候的博客
09-13 2620
目前StarRocks在不支持自增ID的情况下，对于明细模型的分页查询场景，由于要保证每一次分页查询出来的数据的唯一性，需要我们人为去指定order by的列，无法利用到StarRocks自身的排序键等特性，造成分页查询场景下，性能并不是很好。有没有一种替代方案能够在外部实现一种自增id，保证每个批次提交的数据都比之前批次的数据的ID大，同时，该ID具有唯一性。并且是一个友好的数据类型（数值型），用来做明细模型的第一列，利用StarRocks的排序键来为分页场景加速。
Spark Streaming的WindowedDStream
OopsOutOfMemory盛利的博客
04-15 4487
Spark Streaming的 窗口操作的类WindowedDStream 下面我们一起探究一下，Spark Streaming怎么实现chu
SparkStreaming local模式部署下遇到的requirement failed的问题
V_Gbird的博客
01-29 2458
最近在local模式下部署了一个数据筛选的sparkstreaming程序，主要是对一些用户的交易数据进行实时处理，环境配置如下： spark ：2.1.0，目前是采用单个节点的Standalone部署模式 scala：2.10.4 jdk：1.7.079 该程序在执行时没有出现异常，但是在执行一段时间之后会报 IllegalArgumentException：Requirement fa
大数据编程实验四：SparkStreaming编程
北天的博客
12-02 2237
大数据编程实验，学习有关Spark Streaming的基本编程方法和利用Spark Streaming处理来自不同数据源的数据以及DStream的各种转换、DStream的数据输出保存到文本文件或MySQL数据库中操作。
ELK日志系统的搭建
最新发布
adminstate的博客
04-23 1035
ELK日志系统搭建
sparkstreaming数据库
03-15
Spark Streaming是Apache Spark的一个组件，用于实时处理和分析大规模数据流。它提供了高可靠性、高吞吐量和低延迟的实时数据处理能力。 Spark Streaming可以从多种数据源（如Kafka、Flume、HDFS等）接收数据流，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值