Flink DataStream的多流、键控流、窗口、连接、物理分区转换算子的使用

最新推荐文章于 2023-02-19 00:19:37 发布
最新推荐文章于 2023-02-19 00:19:37 发布
阅读量1.3k 收藏
点赞数
分类专栏： # Flink 文章标签： 多流算子 键控流算子 窗口算子 物理分区算子 连接算子
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yy8623977/article/details/120927471
版权

目录

1. 多流转换算子

1.1 union

package devBase

import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}


object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input1 = senv.fromElements(("Liming",16), ("Zhangsan", 30))
    val input2 = senv.fromElements(("Zhaosi",40), ("Wangwu", 58))

    val output = input1.union(input2)
    output.print()

    senv.execute()

  }

}

执行结果：

3> (Wangwu,58)
4> (Zhangsan,30)
2> (Zhaosi,40)
3> (Liming,16)
  • 支持union多个DataStream: def union(dataStreams: DataStream[T]*): DataStream[T] = ......

1.2 connect

package devBase

import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}


object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input1 = senv.fromElements(("Liming",16), ("Zhangsan", 30))
    val input2 = senv.fromElements(("Zhaosi","Beijing"), ("Wangwu", "Shanghai"))

    // 虽然在同一个流，但两个源数据流的数据格式没变
    val connectedStream = input1.connect(input2)
    // 将流中的数据格式变成一样
    val output = connectedStream.map(
      // 如果是input1的数据，用此转换函数
      input1_stream => (input1_stream._1, input1_stream._2.toString),
      // 如果是input2的数据，用此转换函数
      input2_stream => (input2_stream._1, input2_stream._2)
    )
    output.print()

    senv.execute()

  }

}

执行结果：

2> (Liming,16)
1> (Wangwu,Shanghai)
8> (Zhaosi,Beijing)
3> (Zhangsan,30)

2. 键控流转换算子

2.1 keyBy和min、max、sum、minBy、maxBy

package devBase

import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}


object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input = senv.fromElements(
      ("Liming",20, 21),
      ("Liming",10, 11),
      ("Liming",30, 31),
      ("Zhangsan", 200, 210),
      ("Zhangsan", 100, 110),
      ("Zhangsan", 300, 310)
    )

    val output_min = input.keyBy(tuple => tuple._1).min(1)
    output_min.print("output_min")
    /* 执行结果如下：
    output_min:8> (Zhangsan,200,210)
    output_min:8> (Zhangsan,100,210)
    output_min:2> (Liming,20,21)
    output_min:8> (Zhangsan,100,210)
    output_min:2> (Liming,10,21)
    output_min:2> (Liming,10,21)
     */

    val output_max = input.keyBy(tuple => tuple._1).max(1)
    output_max.print("output_max")
    /* 执行结果如下：
    output_max:8> (Zhangsan,200,210)
    output_max:2> (Liming,20,21)
    output_max:8> (Zhangsan,200,210)
    output_max:2> (Liming,20,21)
    output_max:8> (Zhangsan,300,210)
    output_max:2> (Liming,30,21)
     */

    val output_sum = input.keyBy(tuple => tuple._1).sum(1)
    output_sum.print("output_sum")
    /* 执行结果如下：
    output_sum:2> (Liming,20,21)
    output_sum:8> (Zhangsan,200,210)
    output_sum:2> (Liming,30,21)
    output_sum:2> (Liming,60,21)
    output_sum:8> (Zhangsan,300,210)
    output_sum:8> (Zhangsan,600,210)
     */

    val output_minBy = input.keyBy(tuple => tuple._1).minBy(1)
    output_minBy.print("output_minBy")
    /* 执行结果如下：
    output_minBy:8> (Zhangsan,200,210)
    output_minBy:2> (Liming,20,21)
    output_minBy:8> (Zhangsan,100,110)
    output_minBy:2> (Liming,10,11)
    output_minBy:2> (Liming,10,11)
    output_minBy:8> (Zhangsan,100,110)
     */

    val output_maxBy = input.keyBy(tuple => tuple._1).maxBy(1)
    output_maxBy.print("output_maxBy")
    /* 执行结果如下：
    output_maxBy:8> (Zhangsan,200,210)
    output_maxBy:2> (Liming,20,21)
    output_maxBy:8> (Zhangsan,200,210)
    output_maxBy:2> (Liming,20,21)
    output_maxBy:8> (Zhangsan,300,310)
    output_maxBy:2> (Liming,30,31)
     */

    senv.execute()

  }

}
  • min / max / sum根据选取的字段，迭代求最小 / 最大 / 求和, 其它字段选第一行
  • minBy / maxBy
    1. 根据选取的字段，迭代求最小 / 最大
    2. 其它字段，选第1步迭代求到最小 / 最大的那一行

2.2 keyBy和reduce

package devBase

import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}

object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input = senv.fromElements(
      ("Liming",20, 21),
      ("Liming",10, 11),
      ("Liming",30, 31),
      ("Zhangsan", 200, 210),
      ("Zhangsan", 100, 110),
      ("Zhangsan", 300, 310)
    )

    val output_min = input.keyBy(tuple => tuple._1).reduce(
      (v1, v2) => (v1._1, v1._2 + v2._2, v1._3 + v2._3)
    )
    output_min.print()

    senv.execute()

  }

}

执行结果如下：

8> (Zhangsan,200,210)
2> (Liming,20,21)
8> (Zhangsan,300,320)
2> (Liming,30,32)
2> (Liming,60,63)
8> (Zhangsan,600,630)

3. 窗口转换算子

3.1 WindowedStream.apply

package devBase

import apiTest.WordSourceFunction
import org.apache.flink.streaming.api.scala.function.WindowFunction
import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input = senv.addSource(new WordSourceFunction())

    val output = input.map(word => (word, 1))
      .keyBy(tuple => tuple._1)
      .window(TumblingProcessingTimeWindows.of(Time.seconds(10L)))
      .apply(new WindowFunction[(String, Int), (String, Int), String, TimeWindow] {
        override def apply(key: String, window: TimeWindow, input: Iterable[(String, Int)], out: Collector[(String, Int)]): Unit = {

          var count = 0
          for (tuple <- input) {
            count += tuple._2
          }
          out.collect((key, count))

        }
      })

    output.print()

    senv.execute()

  }

}

执行结果

1> (table,1)
8> (stream,1)
7> (flink,1)
7> (batch,2)
4> (sql,2)
5> (world,1)
1> (table,1)
3> (hello,2)
8> (stream,2)
5> (world,3)
7> (batch,1)
4> (sql,3)
8> (stream,1)
3> (hello,2)
4> (sql,1)
5> (world,2)
3> (hello,1)
8> (stream,3)
7> (batch,1)
7> (flink,2)
......省略部分......
  • 1.13版本不用执行senv.setStreamTimeCharacteristic， 因为默认就是EventTime, 且processing time、ingestion time也可以在该时间语义下工作

3.2 AllWindowedStream.apply

package devBase

import apiTest.WordSourceFunction
import org.apache.flink.streaming.api.scala.function.{AllWindowFunction}
import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input = senv.addSource(new WordSourceFunction())

    val output = input.map(word => (word, 1))
      .windowAll(TumblingProcessingTimeWindows.of(Time.seconds(10L)))
      .apply(new AllWindowFunction[(String, Int), (String,Int),TimeWindow] {
        override def apply(window: TimeWindow, input: Iterable[(String, Int)], out: Collector[(String, Int)]): Unit = {

          var window_word = ""
          var count = 0
          for (tuple <- input) {
            window_word = tuple._1
            count += tuple._2
          }
          out.collect((window_word, count))

        }
      })

    output.print()

    senv.execute()

  }

}

执行结果：

2> (stream,9)
3> (world,10)
4> (batch,10)
5> (stream,10)
6> (hello,10)
7> (flink,10)
......省略部分......

3.3 DataStream.coGroup(DataStream)

package devBase

import apiTest.WordSourceFunction
import org.apache.flink.api.common.functions.CoGroupFunction
import org.apache.flink.streaming.api.scala.function.AllWindowFunction
import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector


import java.lang


object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input = senv.addSource(new WordSourceFunction())

    val output = input.map(word => (word, 1))
      .coGroup(
        input.map(word => (word, word + "666"))
      ).where(tuple => tuple._1).equalTo(tuple => tuple._1)
      .window(TumblingProcessingTimeWindows.of(Time.seconds(10L)))
      .apply(new CoGroupFunction[(String, Int),(String, String), String] {
        override def coGroup(first: lang.Iterable[(String, Int)], second: lang.Iterable[(String, String)], out: Collector[String]): Unit = {
          val first_iter = first.iterator()
          val second_iter = second.iterator()

          while(first_iter.hasNext) {out.collect(first_iter.next()._1)}
          while(second_iter.hasNext) {out.collect(second_iter.next()._2)}

        }
      })

    output.print()

    senv.execute()

  }

}

执行结果：

7> batch
7> batch
7> batch666
7> batch666
3> hello
3> hello666
8> stream
......省略部分......

4. 连接转换算子

4.1 窗口连接

package devBase

import org.apache.commons.lang3.time.FastDateFormat
import org.apache.flink.api.common.eventtime._
import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.util.Collector

class RecordTimestampAssigner extends TimestampAssigner[(String, Int, String)] {
  val fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss")

  override def extractTimestamp(element: (String, Int, String), recordTimestamp: Long): Long = {

    fdf.parse(element._3).getTime

  }

}

class PeriodWatermarkGenerator extends WatermarkGenerator[(String, Int, String)] {
  val fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss")
  var maxTimestamp: Long = _
  val maxOutofOrderness = 0

  override def onEvent(event: (String, Int, String), eventTimestamp: Long, output: WatermarkOutput): Unit = {

    maxTimestamp = math.max(fdf.parse(event._3).getTime, maxTimestamp)

  }

  override def onPeriodicEmit(output: WatermarkOutput): Unit = {

    output.emitWatermark(new Watermark(maxTimestamp - maxOutofOrderness - 1))
  }
}


class MyWatermarkStrategy extends WatermarkStrategy[(String, Int, String)] {

  override def createTimestampAssigner(context: TimestampAssignerSupplier.Context): TimestampAssigner[(String, Int, String)] = {

    new RecordTimestampAssigner()
  }

  override def createWatermarkGenerator(context: WatermarkGeneratorSupplier.Context): WatermarkGenerator[(String, Int, String)] = {
    new PeriodWatermarkGenerator()


  }

}


object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input1 = senv.fromElements(
      ("A", 110, "2021-09-01 08:00:11"),
      ("A", 120, "2021-09-01 08:00:12"),
      ("B", 130, "2021-09-01 08:00:13"),
      ("B", 140, "2021-09-01 08:00:14"),
      ("C", 210, "2021-09-01 08:00:21"),
      ("C", 220, "2021-09-01 08:00:22"),
      ("D", 310, "2021-09-01 08:00:31"),
      ("D", 320, "2021-09-01 08:00:32")
    ).assignTimestampsAndWatermarks(new MyWatermarkStrategy())

    val input2 = senv.fromElements(
      ("A", 110, "2021-09-01 08:00:11"),
      ("A", 120, "2021-09-01 08:00:12"),
      ("B", 130, "2021-09-01 08:00:13"),
      ("B", 140, "2021-09-01 08:00:14"),
      ("C", 210, "2021-09-01 08:00:21")
    ).assignTimestampsAndWatermarks(new MyWatermarkStrategy())

    val output = input1.join(input2)
      .where(event => event._1).equalTo((event => event._1))
      .window(TumblingEventTimeWindows.of(Time.seconds(10L)))
      .apply((left: (String, Int, String), right: (String, Int, String), collector: Collector[(String, Int, String)]) => {
        val maxDatetime = if (left._3 > right._3) left._3 else right._3
        collector.collect(left._1, left._2 + right._2, maxDatetime)
      })


    output.print()


    senv.execute()


  }

}

执行结果：

7> (A,220,2021-09-01 08:00:11)
7> (A,230,2021-09-01 08:00:12)
7> (A,230,2021-09-01 08:00:12)
7> (A,240,2021-09-01 08:00:12)
2> (B,260,2021-09-01 08:00:13)
2> (B,270,2021-09-01 08:00:14)
2> (B,270,2021-09-01 08:00:14)
2> (B,280,2021-09-01 08:00:14)
2> (C,420,2021-09-01 08:00:21)
2> (C,430,2021-09-01 08:00:22)
  • 对于键B，在窗口[08:00:10, 08:00:20)中，apply函数的所有结果元素的timestamp为最大的timestamp 08:00:14
  • 滑动窗口：SlidingEventTimeWindows.of(Time.seconds(10L),Time.seconds(1L))
  • 会话窗口：EventTimeSessionWindows.withGap(Time.seconds(10L))

4.2 间隔连接

package devBase

import org.apache.commons.lang3.time.FastDateFormat
import org.apache.flink.api.common.eventtime._
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction
import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.util.Collector

class RecordTimestampAssigner extends TimestampAssigner[(String, Int, String)] {
  val fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss")

  override def extractTimestamp(element: (String, Int, String), recordTimestamp: Long): Long = {

    fdf.parse(element._3).getTime

  }

}

class PeriodWatermarkGenerator extends WatermarkGenerator[(String, Int, String)] {
  val fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss")
  var maxTimestamp: Long = _
  val maxOutofOrderness = 0

  override def onEvent(event: (String, Int, String), eventTimestamp: Long, output: WatermarkOutput): Unit = {

    maxTimestamp = math.max(fdf.parse(event._3).getTime, maxTimestamp)

  }

  override def onPeriodicEmit(output: WatermarkOutput): Unit = {

    output.emitWatermark(new Watermark(maxTimestamp - maxOutofOrderness - 1))
  }
}


class MyWatermarkStrategy extends WatermarkStrategy[(String, Int, String)] {

  override def createTimestampAssigner(context: TimestampAssignerSupplier.Context): TimestampAssigner[(String, Int, String)] = {

    new RecordTimestampAssigner()
  }

  override def createWatermarkGenerator(context: WatermarkGeneratorSupplier.Context): WatermarkGenerator[(String, Int, String)] = {
    new PeriodWatermarkGenerator()


  }

}


object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    val input1 = senv.fromElements(
      ("A", 110, "2021-09-01 08:00:11"),
      ("A", 120, "2021-09-01 08:00:12"),
      ("B", 130, "2021-09-01 08:00:13"),
      ("B", 140, "2021-09-01 08:00:14"),
      ("C", 210, "2021-09-01 08:00:21"),
      ("C", 220, "2021-09-01 08:00:22"),
      ("D", 310, "2021-09-01 08:00:31"),
      ("D", 320, "2021-09-01 08:00:32")
    ).assignTimestampsAndWatermarks(new MyWatermarkStrategy())

    val input2 = senv.fromElements(
      ("A", 110, "2021-09-01 08:00:11"),
      ("A", 120, "2021-09-01 08:00:12"),
      ("B", 130, "2021-09-01 08:00:13"),
      ("B", 140, "2021-09-01 08:00:14"),
      ("C", 210, "2021-09-01 08:00:21")
    ).assignTimestampsAndWatermarks(new MyWatermarkStrategy())

    val output = input1.keyBy(_._1)
      .intervalJoin(input2.keyBy(_._1))
      .between(Time.seconds(-2L), Time.seconds(2L))
      .lowerBoundExclusive().upperBoundExclusive()
      .process(new ProcessJoinFunction[(String, Int, String), (String, Int, String), (String, Int, String)] {
        override def processElement(in1: (String, Int, String), in2: (String, Int, String), context: ProcessJoinFunction[(String, Int, String), (String, Int, String), (String, Int, String)]#Context, collector: Collector[(String, Int, String)]): Unit = {

          val maxDatetime = if (in1._3 > in2._3) in1._3 else in2._3
          collector.collect((in1._1, in1._2 + in2._2, maxDatetime))
        }
      })


    output.print()


    senv.execute()


  }

}

执行结果

2> (B,260,2021-09-01 08:00:13)
2> (B,270,2021-09-01 08:00:14)
2> (B,270,2021-09-01 08:00:14)
2> (B,280,2021-09-01 08:00:14)
7> (A,220,2021-09-01 08:00:11)
2> (C,420,2021-09-01 08:00:21)
7> (A,230,2021-09-01 08:00:12)
7> (A,230,2021-09-01 08:00:12)
7> (A,240,2021-09-01 08:00:12)
2> (C,430,2021-09-01 08:00:22)
  • 连接条件是：left_key == right_key && left_timestamp - 2 < right_timestamp < left_timestamp + 2，默认是包含上下界的
  • 只支持EventTime模式
  • processElement函数的结果元素timestamp为in1、in2的最大timestamp，即ProcessJoinFunction.Context.getTimestamp函数的返回结果

5. 物理分区算子

package devBase

import org.apache.flink.api.common.functions.Partitioner
import org.apache.flink.streaming.api.scala.{StreamExecutionEnvironment, createTypeInformation}

class StringHashPartitioner extends Partitioner[String] {
  override def partition(key: String, numPartitions: Int): Int = {

    (key.hashCode) % numPartitions

  }
}

object TranformationOperatorTest {

  def main(args: Array[String]): Unit = {

    val senv = StreamExecutionEnvironment.getExecutionEnvironment
    println("parallelism: " + senv.getParallelism)    // parallelism: 8

    val input = senv.fromElements(("key1","value1"),("key2","value2"),("key3","value3"))
    input.print("input")
    /*
    input:5> (key1,value1)
    input:7> (key3,value3)
    input:6> (key2,value2)
     */

    val partitionCustom_output = input.partitionCustom(new StringHashPartitioner(),tuple => tuple._1)
    partitionCustom_output.print("partitionCustom_output")
    /*
    partitionCustom_output:5> (key3,value3)
    partitionCustom_output:3> (key1,value1)
    partitionCustom_output:4> (key2,value2)
     */


    val shuffle_output = input.shuffle
    shuffle_output.print("shuffle_output")
    /*
    shuffle_output:8> (key2,value2)
    shuffle_output:7> (key3,value3)
    shuffle_output:3> (key1,value1)
     */

    val rebalance_output = input.rebalance
    rebalance_output.print("rebalance_output")
    /*
    rebalance_output:1> (key2,value2)
    rebalance_output:8> (key1,value1)
    rebalance_output:2> (key3,value3)
    */

    val rescale_output = input.rescale
    rescale_output.print("rescale_output")
    /*
    rescale_output:1> (key1,value1)
    rescale_output:2> (key2,value2)
    rescale_output:3> (key3,value3)
     */

    val broadcast_output = input.broadcast
    broadcast_output.print("broadcast_output")
    /*
    broadcast_output:1> (key1,value1)
    broadcast_output:1> (key2,value2)
    broadcast_output:1> (key3,value3)
    broadcast_output:8> (key1,value1)
    broadcast_output:8> (key2,value2)
    broadcast_output:8> (key3,value3)
    ......省略16条输出......
    */

    senv.execute()


  }

}
  • shuffle将元素进行随机分区，可能会导致某些分区随机的数据量多
  • rebalance进行轮询分区，不用计算随机数，性能更好
  • rescale只在同一服务器进行轮询分区，不产生网络传输
  • broadcast将元素进行广播，例如dataStreamA有3条数据，senv环境有8个分区，则广播后有24条数据
Bulut0907
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink流计算状态与容错【键控状态、操作状态、托管状态】
踏雪无痕
06-25 618
有状态的函数和运算符在处理单个元素/事件的过程中存储数据，从而使状态成为任何类型的更精细操作的关键构建块。 包括： 当应用程序搜索某些事件模式时，状态将存储到目前为止遇到的事件序列。 在每分钟/小时/天汇总事件时，状态将保留待处理的汇总。 在数据点流上训练机器学习模型时，状态保持模型参数的当前版本。 当需要管理历史数据时，该状态允许有效访问过去发生的事件。 Flink需要了解状态，以便使用检查点使状态容错并允许流应用程序的保存点。 状态还允许重新缩放Flink应用程序，这意味着Flink负责在并行实例之
flink_DataStream:利用DataStream处理流数据
04-20
标题中的"flink_DataStream:利用DataStream处理流数据"指的是Apache Flink的DataStream API，它是一个用于处理无界和有界数据流的高级抽象。在本文中，我们将深入探讨Flink如何通过DataStream API来实现高效的流数据...
Flink--Transform(键控流转换算子)
MINGZHEFENG的博客
12-07 232
若现做聚合操作，必须先分组，所以keyby很重要 keyby算子比较特使，并不是一步具体的执行操作 不是真正意义上的 aoprete 它就是定义了一下两个任务之间 数据的传输模式 keyby 基于定义的key做分组 基于每个key的hashcode 进行一个重分区 当同一个key进行重分区的时候必然会放入带同一个分区。当前分区一定有这个key的所有数据。同一个分区可以有多种key keyby的转换涉及到一个数据结构的专转换 datastream == keyedStream 这个 keyedStream
Flink进阶教程：如何在两个DataStream上进行Join操作
皮皮鲁的AI星球
01-18 2485
批处理经常要解决的问题是将两个数据源做关联Join操作。比如，很多手机APP都有一个用户数据源User，同时APP会记录用户的行为，我们称之为Behavior，两个表按照userId来进行Join。在流处理场景下，Flink也支持了Join，只不过Flink是在一个时间窗口上来进行两个表的Join。 目前，Flink支持了两种Join：Window Join（窗口连接）和Interval Joi...
Flink---分流
shall潇の菜园
07-06 454
Flink中将一个流拆分成多个流的方法有两个：split(已过时)，process（推荐） 文章目录splitprocess split package Flink.transform; import Flink.beans.SensorReading; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.common.functions.RichMapFunction; impor.
Flink状态和键控流
qq_43523503的博客
03-18 484
6.8 Flink状态编程 有状态的计算是流处理框架要实现的重要功能，因为稍复杂的流处理场景都需要记录状态，然后在新流入数据的基础上不断更新状态。 6.8.1 Flink中的状态分类 Flink包括两种基本类型的状态Managed State和Raw State Managed State Raw State 状态管理方式 Flink Runtime托管, 自动存储, 自动恢复, 自动伸缩 用户自己管理 状态数据结构 Flink提供多种常用数据结构, 例如:ListState,
基于Flink DataStream API的流批一体处理.pdf
03-21
基于Flink DataStream API的流批一体处理
基于Flink CDC使用datastream方式全量增量同步mysql to mysql
03-04
基于Flink CDC使用datastream方式全量增量同步mysql to mysql 使用的是java语言，只需配置完源数据库和目标数据库信息，运行MysqlCDC中的main函数，即可实现多库多表同步。
flink datastream api 示例大全
最新发布
10-19
Flink DataStream API是Apache Flink流处理框架的核心部分，用于处理无界和有界数据流。这个API提供了丰富的操作符来构建复杂的数据处理管道。以下是对标题和描述中涉及的知识点的详细解释： 1. **异步IO...
通俗易懂之Flink DataStream API开发
02-07
l 掌握DataStream的算子操作（source、transformation、sink） l 掌握水印使用及其原理 l 掌握状态和容错机制 l 掌握异步io的使用和原理 l 掌握端对端一次性语义的使用和原理 l 掌握Streaming file sink的使用 l ...
Flink API - 键控流转换算子与滚动聚合算子
weixin_44760145的博客
02-19 338
Flink keyBy 和 聚合算子
Flink 窗口算子知识点扫盲
胖虎儿的博客
05-19 6735
什么是窗口？为什么需要窗口？有哪些窗口?如何使用窗口？
Flink 多流转换 （四） 窗口联结（Window Join）
weixin_45417821的博客
04-19 2055
文章目录窗口联结的调用窗口联结实例 Flink 为这种场景专门提供了一个窗口联结（window join）算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理。类似于SQL中的Join 窗口联结的调用 窗口联结在代码中的实现，首先需要调用 DataStream 的.join()方法来合并两条流，得到一个 JoinedStreams；接着通过.where()和.equalTo()方法指定两条流中联结的 key；然后通过.window()开窗口，并调用.apply()传入联结
Flink窗口及其分类-详细说明
勇敢牛牛，不怕困难！
11-19 5311
Flink 是一种流式计算引擎，主要是来处理无界数据流的，数据源源不断、无穷无尽。想要更加方便高效地处理无界流，一种方式就是将无限数据切割成有限的“数据块”进行处理，这就是所谓的“窗口”（Window）。所以在 Flink 中，窗口其实并不是一个“框”，流进来的数据被框住了就只能进这一个窗口。相比之下，我们应该把窗口理解成一个“桶”。在 Flink 中，窗口可以把流切割成有限大小的多个“存储桶”（bucket)；每个数据都会分发到对应的桶中，当到达窗口结束时间时，就对每个桶中收集的数据进行计算处理。
【fink】dataStreamAPI开发
依旧的博客
01-27 5304
一、Time与Window （一）Time Event Time：是事件创建的时间。它通常由事件中的时间戳描述，例如采集的日志数据中， 每一条日志都会记录自己的生成时间，Flink 通过时间戳分配器访问事件时间戳。 Ingestion Time：是数据进入 Flink 的时间。 Processing Time：是每一个执行基于时间操作的算子的本地系统时间，与机器相关，默认 的时间属性就是 Processing Time。 例如，一条日志进入 Flink 的时间为 2019-08-
（十）Flink Datastream API 编程指南 算子-2 Windows窗口计算
京河小蚁的博客
06-05 644
窗口是处理无限流的核心。Windows将流分成有限大小的“桶”，我们可以在桶上应用计算。本文主要讨论如何在Flink中执行窗口操作，以及程序员如何最大限度地利用Flink提供的功能。一个带窗口的Flink程序的总体结构如下所示。第一个片段引用键控流，第二个片段引用非键控流。可以看到，唯一的区别是键控流的keyBy(…)调用和非键控流的window(…)调用，后者变成windowall(…)。这也将作为页面其余部分的路线图。Keyed Windows Non-Keyed Windows 上面的方括号([…])
配合状态(state)使用的键控流(KeyedDataStream)
唤不醒的梦
11-03 894
Keyed DataStream 键控流(KeyedDataStream)概念：在flink中数据集为DataStream，对其进行分区时，会产生一个KeyedDataStream，然后允许使用键控流的operator以及特有的state(如mapstate、valuestate等) 如果想使用key state，需要对DataStream指明一个key进行分区，也可以使用keyby创建一个KeyedDataStream，对这个KeyedDataStream可以使用keyed state。 keyby
Flink DataStream转换（翻译官方文档）
jyj019的博客
03-02 1807
最近准备用flink对之前项目进行重构，这是一个有挑战（但我很喜欢）的工作。几个月过去了，flink社区比起我做技术调研那阵发生了很多变化（包括blink的版本回推），我这边的版本也由1.4-&gt;1.7.2。现在网上有很多大方向的解析（阿里的几次直播），也有大神对框架的深入解析。我准备实际使用中mark一些关键的知识点/api。以下就是我翻译的flink流计算DataStream 发现了一个翻译好的文档地址https://flink.sojb.cn/，其完整性和正确性比我翻译好太多，故不再更新
Pandas玩转数据（六) -- 通过apply对数据进行处理
越看越喜欢啊
07-19 2728
import pandas as pd import numpy as np from pandas import Series, DataFrame # 打开一个csv文件对其中一列分成几列，把data列进行分组 f = open('apply_demo.csv') df = pd.read_csv(f) df.head() Out[8]: time ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值