flink学习（四）

最新推荐文章于 2022-04-17 19:19:21 发布
最新推荐文章于 2022-04-17 19:19:21 发布
阅读量347 收藏
点赞数
分类专栏： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Daivei_lai/article/details/108657791
版权

学习目标

1.Time与window
2.EventTime与window
3.Flink的容错（checkpoint）
4.Flink的状态管理 state

1.Time与window

1.1Time

Event Time： 数据产生的时间
Ingestion Time： 是数据进入 Flink 的时间。
Processing Time ：算子操作使用的时间

1.2window

Window 可以分成两类：

  1. CountWindow： 按照指定的数据条数生成一个 Window， 与时间无关。
  2. TimeWindow： 按照时间生成 Window。

滚动窗口（ Tumbling Window）

将数据依据固定的窗口长度对数据进行切片。
特点： 时间对齐， 窗口长度固定， 没有重叠 。

滑动窗口（ Sliding Window）

滑动窗口是固定窗口的更广义的一种形式， 滑动窗口由固定的窗口长度和滑动间隔组成。
特点： 时间对齐， 窗口长度固定， 有重叠。
分为三种情况：
窗口大小>滑动距离 =====》有重叠，重复消费数据
窗口大小=滑动距离 =====》没有重复，不重叠，也不丢失
窗口大小<滑动距离 =====》丢失数据

会话窗口（ Session Window）

由一系列事件组合一个指定时间长度的 timeout 间隙组成， 类似于 web 应用的 session，
也 就是一段时间没有接收到新数据就会生成新的窗口。
特点： 时间无对齐。

Window API
CountWindow案例

package com.czxy.flink.stream.window

import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.windows.GlobalWindow

/**
 * 思路步骤：
 * 1.获取执行环境
 * 2.创建 SocketSource
 * 3.对 stream 进行处理并按 key 聚合
 * 4.countWindow 操作
 * 5.执行聚合操作
 * 6.将聚合数据输出
 * 7.执行程序
 */
object StreamCountWindow {
  def main(args: Array[String]): Unit = {
    //1.创建执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment

    //2.构建数据源，创建 SocketSource
    val socketSource: DataStream[String] = env.socketTextStream("node01",9999)

    //3.对 stream 进行处理并按 key 聚合
    import org.apache.flink.api.scala._
    val groupKeyedStream: KeyedStream[(String, Int), String] = socketSource.flatMap(x=>x.split(" ")).map((_,1)).keyBy(_._1)

    //4.引入countWindow 操作,每5条数据计算一次
    val countWindowStream: WindowedStream[(String, Int), String, GlobalWindow] = groupKeyedStream.countWindow(5)

    //5.执行聚合操作
    val resultDataStream: DataStream[(String, Int)] = countWindowStream.sum(1)

    //6.将聚合数据输出
    resultDataStream.print()

    //7.执行程序
    env.execute("StreamCountWindow")
  }

}

TimeWindow案例

package com.czxy.flink.stream.window

import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

/**
 * 思路步骤：
 * 1.获取执行环境
 * 2.创建你 socket 链接获取数据
 * 3.进行数据转换处理并按 key 聚合
 * 4.引入 timeWindow
 * 5.执行聚合操作
 * 6.输出打印数据
 * 7.执行程序
 */
object StreamTimeWindow {
  def main(args: Array[String]): Unit = {
    //1.获取执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.创建你 socket 链接获取数据
    val socketSource = env.socketTextStream("node01",9999)
    //3.进行数据转换处理并按 key 聚合
    import org.apache.flink.api.scala._
    val groupKeyedStream: KeyedStream[(String, Int), String] = socketSource.flatMap(x=>x.split(" ")).map((_,1)).keyBy(_._1)
    //4.引入 滚动窗口timeWindow,每3秒钟计算一次
    //val timeWindowStream: WindowedStream[(String, Int), String, TimeWindow] = groupKeyedStream.timeWindow(Time.seconds(3))
    //4.引入 滑动窗口timeWindow,窗口大小为10秒，滑动距离为5秒=>重复消费
    val timeWindowStream: WindowedStream[(String, Int), String, TimeWindow] = groupKeyedStream.timeWindow(Time.seconds(10),Time.seconds(5))
    //5.执行聚合操作
    val result: DataStream[(String, Int)] = timeWindowStream.sum(1)
    //6.打印输出
    result.print()
    //7.执行程序
    env.execute("StreamTimeWindow")
  }
}

SreamReduceWindow案例

package com.czxy.flink.stream.window

import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

object StreamReduceWindow {
  def main(args: Array[String]): Unit = {
    //1.获取执行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    //2.构建数据集
    val socketSource = env.socketTextStream("node01",9999)
    //3.分组
    import org.apache.flink.api.scala._
    val group = socketSource.flatMap(x=>x.split(" ")).map((_,1)).keyBy(_._1)

    //4.引入窗口timeWindow
    val timeWindow: WindowedStream[(String, Int), String, TimeWindow] = group.timeWindow(Time.seconds(5))

    //5.聚合操作
    val result: DataStream[(String, Int)] = timeWindow.reduce((v1, v2)=>(v1._1,v1._2+v2._2))

    //6.输出打印
    result.print()
    //7.执行程序
    env.execute()

  }
}

Window Apply案例

package com.czxy.flink.stream.window

import org.apache.flink.streaming.api.scala.function.RichWindowFunction
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.util.Collector

//使用 apply 方法来实现单词统计
object StreamApplyWindow {
  def main(args: Array[String]): Unit = {
    /**
     * 思路步骤：
     * 1) 获取流处理运行环境
     * 2) 构建 socket 流数据源， 并指定 IP 地址和端口号
     * 3) 对接收到的数据转换成单词元组
     * 4) 使用 keyBy 进行分流（ 分组）
     * 5) 使用 timeWindow 指定窗口的长度（ 每 3 秒计算一次）
     * 6) 实现一个 WindowFunction 匿名内部类
     * a. apply 方法中实现聚合计算
     * b. 使用 Collector.collect 收集数据
     * 7) 打印输出
     * 8) 启动执行
     * 9) 在 Linux 中， 使用 nc -lk 端口号 监听端口， 并发送单词
     */

    //1.获取流处理运行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2. 构建 socket 流数据源， 并指定 IP 地址和端口号
    val socketSource: DataStream[String] = env.socketTextStream("node01",9999)
    //3.对接收到的数据转换成单词元组
    import org.apache.flink.api.scala._
    val wordAndOne: DataStream[(String, Int)] = socketSource.flatMap(x=>x.split(" ")).map((_,1))
    //4.使用 keyBy 进行分流（ 分组）
    val groupKeyedStream: KeyedStream[(String, Int), String] = wordAndOne.keyBy(_._1)
    //5.使用 timeWindow 指定窗口的长度（ 每 3 秒计算一次）
    val timeWindow: WindowedStream[(String, Int), String, TimeWindow] = groupKeyedStream.timeWindow(Time.seconds(3))
    //6.实现一个 WindowFunction 匿名内部类
    val result: DataStream[(String, Int)] = timeWindow.apply(new RichWindowFunction[(String, Int), (String, Int), String, TimeWindow] {
      override def apply(key: String, window: TimeWindow, input: Iterable[(String, Int)], out: Collector[(String, Int)]): Unit = {
        //apply 方法中实现聚合计算
        val tuple: (String, Int) = input.reduce((v1, v2) => (v1._1, v1._2 + v2._2))
        //使用 Collector.collect 收集数据
        out.collect(tuple)
      }
    })
    //7.打印输出
    result.print()
    //8.执行程序
    env.execute("StreamApplyWindow")
  }
}

StreamAggregationWindow案例

package com.czxy.flink.stream.window

import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

object StreamAggregationWindow {
  def main(args: Array[String]): Unit = {
    //1.获取流处理运行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2. 构建 socket 流数据源， 并指定 IP 地址和端口号
    val socketSource: DataStream[String] = env.socketTextStream("node01",9999)
    //3.对接收到的数据转换成单词元组
    import org.apache.flink.api.scala._
    val wordAndOne: DataStream[(String, Int)] = socketSource.flatMap(x=>x.split(" ")).map((_,1))
    //4.使用 keyBy 进行分流（ 分组）
    val groupKeyedStream: KeyedStream[(String, Int), String] = wordAndOne.keyBy(_._1)
    //5.使用 timeWindow 指定窗口的长度（ 每 3 秒计算一次）
    val timeWindow: WindowedStream[(String, Int), String, TimeWindow] = groupKeyedStream.timeWindow(Time.seconds(3))
    //6.执行聚合操作
    val result: DataStream[(String, Int)] = timeWindow.max(1)
    //7.打印输出
    result.print()
    //8.执行程序
    env.execute(this.getClass.getSimpleName)

  }
}

2.EventTime 与 Window

2.1EventTime 的引入
如果要使用 EventTime， 那么需要引入 EventTime 的时间属性

在这里插入代码片val env = StreamExecutionEnvironment.getExecutionEnvironment
// 从调用时刻开始给 env 创建的每一个 stream 追加时间特征
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTim

2.2 Watermark
Watermark 是用于处理乱序事件的， 而正确的处理乱序事件， 通常用 Watermark 机制结合 window 来实现 。

2.3EventTimeWindow API

滚动窗口

package com.czxy.flink.stream.waterwindow

import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

object TumblingEventTimeWindowsDemo {
  def main(args: Array[String]): Unit = {
    /**
     * 步骤：
     * 1.创建流处理环境
     * 2.设置EventTime
     * 3.构建数据源
     * 4.设置水印
     * 5.逻辑处理
     * 6.引入滚动窗口TumblingEventTimeWindows
     * 7.聚合操作
     * 8.输出打印
     * 9.执行程序
     */
    //1.创建流处理环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.设置EventTime
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    //3.构建数据源
    //数据格式： 1000 hello
    val socketSource = env.socketTextStream("node01",9999)
    //4.设置水印
    val waterMark: DataStream[String] = socketSource.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(0)) {
      override def extractTimestamp(element: String): Long = {
        val eventTime: Long = element.split(" ")(0).toLong
        eventTime
      }
    })
    //5.逻辑处理
    import org.apache.flink.api.scala._
    val groupStream: KeyedStream[(String, Int), String] = waterMark.map(x=>x.split(" ")(1)).map((_,1)).keyBy(_._1)
    //6.引入滚动窗口TumblingEventTimeWindows
    val windowStream: WindowedStream[(String, Int), String, TimeWindow] = groupStream.window(TumblingEventTimeWindows.of(Time.seconds(3)))
    //7.聚合操作
    val result: DataStream[(String, Int)] = windowStream.sum(1)
    //8.输出打印
    result.print()
    //9.执行程序
    env.execute(this.getClass.getSimpleName)
  }
}

滑动窗口

package com.czxy.flink.stream.waterwindow

import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

object SlidingEventTimeWindowsDemo {
  def main(args: Array[String]): Unit = {
    /** * 步骤：
     * 1.创建流处理环境
     * 2.设置EventTime
     * 3.构建数据源
     * 4.设置水印
     * 5.逻辑处理
     * 6.引入滑动窗口SlidingEventTimeWindows
     * 7.聚合操作
     * 8.输出打印
     * 9.执行程序
     */

    //1.创建流处理环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.设置EventTime
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    //3.构建数据源
    //数据格式为：1000 hello
    val socketSource: DataStream[String] = env.socketTextStream("node01", 9999)
    //4.设置水印
    val waterMark: DataStream[String] = socketSource.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(0)) {
      override def extractTimestamp(element: String): Long = {
        val eventTime: Long = element.split(" ")(0).toLong
        eventTime
      }
    })
    //5.逻辑处理
    import org.apache.flink.api.scala._
    val groupStream: KeyedStream[(String, Int), String] = waterMark.map(x => x.split(" ")(1)).map((_, 1)).keyBy(_._1)
    //6.引入滑动窗口SlidingEventTimeWindows
    val windowStream: WindowedStream[(String, Int), String, TimeWindow] = groupStream.window(SlidingEventTimeWindows.of(Time.seconds(5), Time.seconds(2)))
    //7.聚合计算
    val result: DataStream[(String, Int)] = windowStream.sum(1)
    //8.打印输出
    result.print()
    env.execute(this.getClass.getSimpleName)

  }
}

会话窗口

package com.czxy.flink.stream.waterwindow

import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala.{DataStream, KeyedStream, StreamExecutionEnvironment, WindowedStream}
import org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow

object EventTimeSessionWindowsDemo {
  def main(args: Array[String]): Unit = {
    /**
     * 步骤：
     * 1.创建流处理环境
     * 2.设置EventTime
     * 3.构建数据源
     * 4.设置水印
     * 5.逻辑处理
     * 6.引入会话窗口EventTimeSessionWindows
     * 7.聚合操作
     * 8.输出打印
     */
    //1.创建流处理环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //2.设置EventTime
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)
    //3.构建数据源
    //数据格式为：1000 hello
    val socketSource: DataStream[String] = env.socketTextStream("node01", 9999)
    //4.设置水印
    val waterMark: DataStream[String] = socketSource.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor[String](Time.seconds(0)) {
      override def extractTimestamp(element: String): Long = {
        val eventTime: Long = element.split(" ")(0).toLong
        eventTime
      }
    })
    //5.逻辑处理
    import org.apache.flink.api.scala._
    val groupStream: KeyedStream[(String, Int), String] = waterMark.map(x => x.split(" ")(1)).map((_, 1)).keyBy(_._1)
    //6.引入会话窗口EventTimeSessionWindows
    val windowStream: WindowedStream[(String, Int), String, TimeWindow] = groupStream.window(EventTimeSessionWindows.withGap(Time.seconds(3)))
    //7.聚合计算
    val result = windowStream.sum(1)
    //8.打印输出
    result.print()
    //9.执行程序
    env.execute("EventTimeSessionWindowsDemo")

  }
}

3.Flink 的容错checkpoint

3.1Checkpoint 介绍

  1. CheckpointCoordinator 周期性的向该流应用的所有 source 算子发送 barrier。
  2. 当某个 source 算子收到一个 barrier 时， 便暂停数据处理过程， 然后将自己的当前状态制作成快照， 并保存到指定的持久化存储中， 最后向CheckpointCoordinator 报告 自己快照制作情况， 同时向自身所有下游算子广播该 barrier， 恢复数据处理 。
  3. 下游算子收到 barrier 之后， 会暂停自己的数据处理过程， 然后将自身的相关状态制作成快照， 并保存到指定的持久化存储中， 最后向 CheckpointCoordinator 报告自身 快照情况， 同时向自身所有下游算子广播该 barrier， 恢复数据处理。
  4. 每个算子按照步骤 3 不断制作快照并向下游广播， 直到最后 barrier 传递到 sink 算子， 快照制作完成。
  5. 当 CheckpointCoordinator 收到所有算子的报告之后， 认为该周期的快照制作成功; 否则， 如果在规定的时间内没有收到所有算子的报告， 则认为本周期快照制作失败。如果一个算子有两个输入源， 则暂时阻塞先收到 barrier 的输入源， 等到第二个输入源相同编号的 barrier 到来时， 再制作自身快照并向下游广播该 barrier。

3.2持久化存储

3.2.1MemStateBackend（默认）
3.2.2FsStateBackend（建议使用）
3.2.3RocksDBStateBackend

3.3Checkpoint 的高级选项

3.4Flink 的重启策略

1.固定延迟重启策略(Fixed Delay Restart Strategy)
2.失败率重启策略
3.失败率重启策略

4.Flink 的状态管理

1.State-Keyed State
2.State-Operator State
3.Broadcast State

奥利给！下次是flink完结了！

Daivei_lai
关注
专栏目录
Flink学习指南2022版
03-25
### Flink学习指南2022版：深入了解Flink及其重要性 #### 一、Flink简介 **Flink**，作为Apache基金会旗下的一款开源大数据处理框架，自诞生以来便迅速成为了各大公司实时数据处理领域的首选工具。尤其在国内，以...
Flink窗口-计数窗口（CountWindow）
热门推荐
胖虎儿的博客
05-23 1万+
countWindow的具体使用
function
weixin_46033736的博客
10-22 93
package cn.itcast.streaming.function.window; import cn.itcast.entity.ItcastDataObj; import cn.itcast.entity.TripModel; import com.google.common.collect.Lists; import org.apache.flink.streaming.api.functions.windowing.RichWindowFunction; import org.apache.
Flink 窗口函数（Window Functions）全窗口函数
weixin_45417821的博客
04-17 2960
文章目录1）窗口函数（WindowFunction）2）处理窗口函数（ProcessWindowFunction） 窗口操作中的另一大类就是全窗口函数。与增量聚合函数不同，全窗口函数需要先收集窗口中的数据，并在内部缓存起来，等到窗口要输出结果的时候再取出数据进行计算。 很明显，这就是典型的批处理思路了— —先攒数据，等一批都到齐了再正式启动处理流程。这样做毫无疑问是低效的：因为窗口全部的计算任务都积压在了要输出结果的那一瞬间，而在之前收集数据的漫长过程中却无所事事。这就好比平时不用功，到考试之前通宵抱佛脚，
【Flink】【第八章】 ProcessFunctionAPI
weixin_43589563的博客
01-20 887
1.ProcessFunction介绍 1.1 API上的说明 A function that processes elements of a stream. For every element in the input stream processElement(Object, ProcessFunction.Context, Collector) is invoked. This can produce zero or more elements as output. Implementa
Flink windows窗口之Windows Assigner和Windows Function
风中云彩的博客
11-18 496
Windows窗口计算就是通过按照固定时间将数据切分成不同的窗口，然后对窗口内的数据进行计算。Flink DataStream API 将窗口抽象成独立的operator，并且在Flink DataStream内已经建了大多数窗口算子。每个算子中包含了Windows Assigner、Window Trigger（窗口触发器）、Evictor（数据剔除器）、Lateness（时延设定）、O...
flink学习.zip
07-31
《Flink学习资源详解》 Apache Flink是一个用于处理无界和有界数据的开源流处理框架，它在大数据领域有着广泛的应用。本资源包针对Flink的学习提供了全面的指导，旨在帮助初学者和进阶者更好地理解和掌握Flink的...
flink学习.rar
03-01
《Flink学习与实战》资源概述 Apache Flink是一个开源的流处理和批处理系统，其设计目标是高效、低延迟地处理大规模实时数据。在大数据领域，Flink以其强大的实时计算能力，成为了许多企业和开发者的重要工具。本...
Flink学习教程.zip
10-15
《Flink学习教程》 Apache Flink是一款开源的流处理框架，它在大数据处理领域扮演着重要的角色，尤其在实时数据处理和分析方面表现出色。本教程将带你深入理解Flink的核心概念、工作原理以及实际操作，助你成为...
剑指大数据-Flink学习精要（Java版）
03-18
《剑指大数据——Flink学习精要（Java版）》是一部深入浅出的教程，旨在帮助读者掌握大数据处理工具Flink的核心概念与实践技巧。Flink作为一种强大的流处理框架，以其实时计算、低延迟和高容错性在大数据领域占有...
大数据学习之flink介绍及实战
12-14
四、Flink的扩展 Flink具有很好的可扩展性，能够轻松集成多种存储和计算资源，如Hadoop YARN、Mesos和Kubernetes，同时支持自定义函数、侧输出流和窗口等高级功能。 五、Flink抽象API Flink提供了DataStream API和...
Flink消费Kafka数据1
08-03
Flink消费Kafka数据 Flink 是一种大数据处理引擎，可以消费 Kafka 数据。本文将介绍如何使用 Flink 消费 ...通过本实验，可以学习到 Flink 和 Kafka 的基本使用方法，并且可以应用于大数据处理和实时数据处理等领域。
flink样例完整代码
最新发布
05-31
《Flink样例完整代码详解》 Apache Flink是一个开源的流处理和批处理框架，其强大的实时数据处理能力和灵活性使其在大数据领域...因此，对于初学者和进阶者来说，研究并理解Flink的样例代码都是不可或缺的学习步骤。
flink技术参考手册
03-20
四、Flink 运行架构 Flink 运行架构包括 Client、JobManager、TaskManager、ResourceManager 等组件。这些组件之间的交互和协作实现了 Flink 的分布式处理能力。 五、Flink 流处理 API Flink 流处理 API 提供了多种...
FLink 中的Window及各种WindowFunction
TRX的博客
02-26 2695
streaming 流式计算是一种被设计用于处理无限数据集的数据处理引擎，而无限数据集是指一种不断增长的本质上无限的数据集，而 window 是一种切割无限数据为有限块进行处理的手段。 Window 是无限数据流处理的核心，Window 将一个无限的 stream 拆分成有限大小的”buckets”桶，我们可以在这些桶上做计算操作。 一、Window可以分为两类： CountWindow：按照指定的数据条数生成一个Window，与时间无关。 TimeWindow：按照时间生成Window。 对于Ti
Flink（25）：Flink之WindowFunction的使用
yang_shibiao的博客
07-12 762
目录 0. 相关文章链接 1. 使用Java求日活的WindowFunction使用 2. 使用Scala演示WindowFunction的使用 0. 相关文章链接 1. 使用Java求日活的WindowFunction使用 // 设置时间语议，并过滤其中的首页曝光数据 DataStream<AppLogBean> homeExposureStream = appExposureStream .assignTimestampsAndWatermarks(new Bo
Flink学习笔记-WindowsFunction（篇二）
yangxiaobo118的博客
07-28 4131
Flink学习笔记-WindowsFunction（篇二）ProcessWindowFunctionProcessWindowFunction抽象类ProcessWindowFunction简单例子ProcessWindowFunction with Incremental AggregationAggregateFunction combined with ProcessWindowFuncti...
Flink之聚合、WindowFunction
heroking
02-01 1379
一、WindowFunction Flink提供了四种类型Window Function，其中有ReduceFunction、AggregateFunction、FlodFunction和ProcessWindowFunction。其中ReduceFunction、AggregateFunction、FlodFunction根据计算原理，属于增量聚合函数，而ProcessWindowFunctio...
Flink面试深度解析：核心技术与实战要点
"Flink面试大全总结，包含了Flink的基础知识、核心概念以及详细的面试问题，总计136页，6万字，110个知识点，涵盖了从Flink的基本概念到高级特性的全面解析，适合准备Flink相关面试或者深入学习Flink的人士参考。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值