Flink - 尚硅谷- 大数据高级 Flink 技术精讲 - 3

最新推荐文章于 2024-08-05 16:22:37 发布
最新推荐文章于 2024-08-05 16:22:37 发布
阅读量944 收藏 11
点赞数
分类专栏： Flink 文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MiaoSO/article/details/108204857
版权

注：次文档参考 【尚硅谷】大数据高级 flink技术精讲（2020年6月） 编写。

1.由于视频中并未涉及到具体搭建流程，Flink 环境搭建部分并未编写。
2.视频教程 Flink 版本为 1.10.0，此文档根据 Flink v1.11.1 进行部分修改。
3.文档中大部分程序在 Windows 端运行会有超时异常，需要打包后在 Linux 端运行。
4.程序运行需要的部分 Jar 包，请很具情况去掉 pom 中的 “scope” 标签的再进行打包，才能在集群上运行。
5.原始文档在 Markdown 中编写，此处目录无法直接跳转。且因字数限制，分多篇发布

此文档仅用作个人学习，请勿用于商业获利。

附.项目实战

此处大部分为代码部分，具体操作略

1. 项目整体介绍

1.1 电商用户行为分析

日志分类：

  • 用户
    • 登陆方式
    • 上线时间点和时长
    • 页面停留和跳转
  • 用户对商品的行为数据
    • 收藏/喜欢/评分/评价/打标签
    • 点击/浏览/购买/支付

日志分析有哪几类

  • 统计分析
    • 点击、浏览
    • 热门商品，近期热门商品、分类热门商品、流量统计
  • 偏好统计
    • 收藏、喜欢、评分、打标签
    • 用户画像，推荐列表
  • 风险控制
    • 下订单、支付、登陆
    • 刷单监控、订单失效监控、恶意登陆（短时间内频繁登陆失败）
1.2 项目模块设计

  • 实时统计分析

    • 热门商品
    • 流量统计
      • 热门页面统计
      • PV
      • UV
    • 市场营销指标
      • APP 市场推广
      • 页面广告分析
    • 实时访问流量统计
    • 页面广告点击量统计

  • 业务流程及风险控制

    • 页面广告黑名单过滤
    • 恶意登陆监控
    • 订单支付
      • 超时失效
      • 实时对账

2. 实时热门商品统计

需求

求一段时间内商品访问量的 Top N

需求分析

一段时间 -> 需要使用时间窗进行分组求和

Top N -> 需要对这个窗口内的数据进行统计排序。也就是接收上一步的数据，按窗口分组，然后排序

数据处理流程

source == map、assignAscendingTimestamps ==> 样例类 == filter、keyBy、timeWindow ==> 开窗
== aggregate(new CountAgg(), new ItemCountWindowResult()) ==> 窗口内进行分组求和，并获取窗口信息
== keyBy(windowEnd) ==> 取当前分组内的TopN，通过定时器触发 Sink

Pom

    <properties>
        <flink.version>1.11.1</flink.version>
        <scala.binary.version>2.11</scala.binary.version>
        <kafka.version>2.4.1</kafka.version>
    </properties>

    <dependencies>
        <!--  ======== Flink Core ========  -->
        <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-scala -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-scala_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <!-- 由于集群上已经有该 jar 包,若要上传到集群上执行,则去掉以下注释 -->
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-streaming-scala -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-scala_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <!-- 由于集群上已经有该 jar 包,若要上传到集群上执行,则去掉以下注释 -->
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-clients -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <!--  ======== Flink Sink Connector ========  -->
        <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-connector-kafka -->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
<!--            <scope>provided</scope>-->
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_${scala.binary.version}</artifactId>
            <version>${kafka.version}</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>*.properties</include>
                    <include>*.txt</include>
<!--                    <include>*.csv</include>-->
                </includes>
                <excludes>
                    <exclude>*.xml</exclude>
                    <exclude>*.yaml</exclude>
                </excludes>
            </resource>
        </resources>

        <plugins>
            <!-- 编译 Scala 需要用到的插件 -->
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.4.6</version>
                <configuration>
                    <addScalacArgs>-target:jvm-1.8</addScalacArgs>
                </configuration>
                <executions>
                    <execution>
                        <!-- 声明绑定到 maven 的 compile 阶段 -->
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- 项目打包需要用到的插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

Code

package com.mso.hotitems_analysis

import java.sql.Timestamp
import java.util.Properties

import org.apache.flink.api.common.functions.AggregateFunction
import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.api.common.state.{ListState, ListStateDescriptor}
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.KeyedProcessFunction
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.scala.function.WindowFunction
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.api.windowing.windows.TimeWindow
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer
import org.apache.flink.util.Collector

import scala.collection.mutable.ListBuffer

// 定义输入数据的样例类
case class UserBehavior(userId: Long, itemId: Long, categoryId: Int, behavior: String, timestamp: Long)

// 定义窗口聚合结果样例类
case class ItemViewCount(itemId: Long, windowEnd: Long, count: Long)

/**
 * 热门商品统计。
 *
 * 设置滑动事件窗口。窗口大小 1h，滑动步长 5min
 * 窗口聚合：定义窗口聚合规则 和 输出数据结构 - .aggregate( new CountAgg(), new WindowResultFunction())
 * 进行统计整理：按照关窗的时间分组，使用状态编程，并定义定时器定时输出 - keyBy("windowEnd")
 *
 * 最终排序输出 - keyedProcessFunction ：
 * - 针对有状态流的 API
 * - KeyedProcessFunction 会对分区后的每一条子流进行处理
 * - 以 windowEnd 作为 key，保证分流以后每一条流的数据都在一个时间窗口内
 * - 从 ListState 中读取当前流的状态，存储数据进行排序输出
 *
 * 用 ProcessFunction 来定义 KeyedStream 的处理逻辑
 * 分区之后，每个 KeyedStream 都有其自己的生命周期
 * - open : 初始化，在这里可以获取当前流的状态
 * - processElement : 处理流中每一个元素时调用
 * - onTimer : 定时调用，注册定时器 Timer 并触发之后的回调操作
 */
object HotItems {
  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    environment.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

    // 1. Source - data file : UserBehavior.csv
    //    val parameterTool: ParameterTool = ParameterTool.fromArgs(args)
    //    val inputStream: DataStream[String] = environment.readTextFile(parameterTool.get("input-path"))
    val properties = new Properties()
    properties.setProperty("bootstrap.servers", "test01:9092")
    properties.setProperty("group.id", "consumer-group")
    properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
    properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer")
    properties.setProperty("auto.offset.reset", "latest")
    val inputStream: DataStream[String] = environment.addSource(new FlinkKafkaConsumer[String]("HotItems", new SimpleStringSchema(), properties))

    // 2. 将数据转换为样例类，并提取 timestamp 定义为 watermark
    val dataStream: DataStream[UserBehavior] = inputStream
      .map((data: String) => {
        val dataArray: Array[String] = data.split(",")
        UserBehavior(dataArray(0).toLong, dataArray(1).toLong, dataArray(2).toInt, dataArray(3), dataArray(4).toLong)
      })
      .assignAscendingTimestamps((_: UserBehavior).timestamp * 1000L) // 此处的测试数据为升序排序，因此不定义延迟时间

    // 3. Transform
    val processedStream: DataStream[String] = dataStream.filter((_: UserBehavior).behavior == "pv")
      .keyBy((data: UserBehavior) => data.itemId)
      .timeWindow(Time.hours(1), Time.minutes(5))
      .aggregate(new CountAgg(), new ItemCountWindowResult())
      .keyBy((data: ItemViewCount) => data.windowEnd)
      .process(new TopNHotItems(5))

    // 4、sink，控制台输出
    processedStream.print()
    environment.execute("HotItems Job")
  }
}

// 自定义聚合函数，来一条数据就 +1，
// * @param <IN>  The type of the values that are aggregated (input values)
// * @param <ACC> The type of the accumulator (intermediate aggregate state).
// * @param <OUT> The type of the aggregated result
class CountAgg() extends AggregateFunction[UserBehavior, Long, Long] {
  override def createAccumulator(): Long = 0L

  override def add(value: UserBehavior, accumulator: Long): Long = accumulator + 1

  override def getResult(accumulator: Long): Long = accumulator

  override def merge(a: Long, b: Long): Long = a + b
}

// 自定义窗口函数，结合 window 信息，包装成样例类
class ItemCountWindowResult extends WindowFunction[Long, ItemViewCount, Long, TimeWindow] {
  override def apply(key: Long, window: TimeWindow, input: Iterable[Long], out: Collector[ItemViewCount]): Unit = {
    out.collect(ItemViewCount(key, window.getEnd, input.iterator.next()))
  }
}

// 自定义 KeyedProcessFunction。 对窗口聚合结果进行分组，并做排序取 TopN 输出
class TopNHotItems(topSize: Int) extends KeyedProcessFunction[Long, ItemViewCount, String] {
  // 定义一个 ListState，用来保存当前窗口所有的 count 结果
  private var itemCountListState: ListState[ItemViewCount] = _

  override def open(parameters: Configuration): Unit = {
    itemCountListState = getRuntimeContext.getListState(new ListStateDescriptor[ItemViewCount]("itemCount-ListState", classOf[ItemViewCount]))
  }

  override def processElement(value: ItemViewCount, ctx: KeyedProcessFunction[Long, ItemViewCount, String]#Context, out: Collector[String]): Unit = {
    // 每来一条数据就添加到状态中
    itemCountListState.add(value)
    // 注册定时器，在 windowEnd + 1 触发
    ctx.timerService().registerEventTimeTimer(value.windowEnd + 1)
  }

  // 定时器触发时，从状态中取数据，然后排序输出
  override def onTimer(timestamp: Long, ctx: KeyedProcessFunction[Long, ItemViewCount, String]#OnTimerContext, out: Collector[String]): Unit = {
    // 将所有state中的数据取出，放到一个List Buffer中
    val allItemCountList: ListBuffer[ItemViewCount] = new ListBuffer()
    import scala.collection.JavaConversions._
    for (itemCount <- itemCountListState.get()) {
      allItemCountList += itemCount
    }

    // 按照 count 大小排序，并取前 n 个
    val sortedItemsCountList: ListBuffer[ItemViewCount] = allItemCountList.sortBy((_: ItemViewCount).count)(Ordering.Long.reverse).take(topSize)

    // 清空状态
    itemCountListState.clear()
    // 将排名结果格式化输出
    val result: StringBuilder = new StringBuilder()
    result.append("Time : ").append(new Timestamp(timestamp - 1)).append("\n")
    // 遍历 sorted 列表，输出每一个商品的信息
    for (i <- sortedItemsCountList.indices) {
      val currentItemCount: ItemViewCount = sortedItemsCountList(i)
      result.append("No").append(i + 1).append(":")
        .append(" 商品ID=").append(currentItemCount.itemId)
        .append(" 浏览量=").append(currentItemCount.count)
        .append("\n")
    }
    result.append("================================")
    out.collect(result.toString())

    // 由于测试是历史数据，所有数据都会一次性输出，此处需要控制输出频率
    Thread.sleep(500)
  }
}

// 自定义预聚合函数计算平均数，状态为 (sum, count)
class AverageAgg() extends AggregateFunction[UserBehavior, (Long, Int), Double] {
  override def createAccumulator(): (Long, Int) = (0L, 0)

  override def add(value: UserBehavior, accumulator: (Long, Int)): (Long, Int) =
    (accumulator._1 + value.timestamp, accumulator._2 + 1)

  override def getResult(accumulator: (Long, Int)): Double = accumulator._1 / accumulator._2.toDouble

  override def merge(a: (Long, Int), b: (Long, Int)): (Long, Int) =
    (a._1 + b._1, a._2 + b._2)
}

KafkaUtil Code

package com.mso.hotitems_analysis

import java.io.InputStream
import java.util.Properties

import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord}

object KafkaProducerUtil {
  def main(args: Array[String]): Unit = {
    writeToKafka("HotItems")
  }

  def writeToKafka(topic: String): Unit = {
    val properties = new Properties()
    properties.put("bootstrap.servers", "test01:9092")
    properties.setProperty("key.serializer", "org.apache.kafka.common.serialization.StringSerializer")
    properties.setProperty("value.serializer", "org.apache.kafka.common.serialization.StringSerializer")

    // 定义一个 kafka producer
    val producer = new KafkaProducer[String, String](properties)

    val stream: InputStream = getClass.getResourceAsStream("/UserBehavior.csv")
    val lines: Iterator[String] = scala.io.Source.fromInputStream(stream).getLines
    for (line <- lines) {
      val record = new ProducerRecord[String, String](topic, line)
      producer.send(record)
    }
最低0.47元/天 解锁文章
「已注销」
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Flink - 尚硅谷- 大数据高级 Flink 技术精讲 - 2
MiaoSO的博客
08-24 869
七、Flink 时间语义与 Watermark 7.1 Flink 中的时间语义 7.2 设置 Event Time 7.3 水位线 - Watermark 7.3.1 基本概念 7.3.2 WaterMark 传递 7.3.3 WaterMark 注意点 7.3.4 Watermark Demo 八、ProcessFunction API（底层 API） 8.1 KeyedProcessFunction 和 定时器（Timers） 8.2 侧输出流（SlideOutput） 8.3 CoP.
Flink - 尚硅谷- 大数据高级 Flink 技术精讲 - 1
MiaoSO的博客
08-24 3980
Flink - 尚硅谷- 大数据高级 Flink 技术精讲 Flink - 尚硅谷- 大数据高级 Flink 技术精讲 一、Flink 简介 二、Quick Start 2.1 环境 2.1 Flink 安装包 2.2 nc 2.3 pom 配置 2.2 批处理 2.3 流处理 三、Flink 部署 3.1 Standalone 模式 3.2 Yarn 模式 3.2.1 Flink on Yarn 3.2.2 Session Cluster 3.2.3 Per Job Cluster
大学四年我这样学习大数据技术，成为了别人眼中的大神
热门推荐
yuan_more的博客
05-15 1万+
在大学里，千万不要老师教什么，你就只学什么，这是远远不够的，对于我们大数据专业，甚至整个计算机专业的同学来说，大学四年最重要的能力就是自学。大学的课程不像高中那么紧，留给我们自学的时间还是比较多的，作为大数据专业的过来人，我真诚的劝学弟学妹们一句：一定要把握住课余时间，尽量不参与或者少参与无用的社团，将这些时间都用来学习计算机相关的知识，每天都坚持学，等你毕业找工作了，或者工作几年之后回过头来看，你会感谢我的。 对于我们计算机相关的专业来说，课堂上老师教的内容只占我们要学习内容的二分之一甚至三分之一，其他
记录免费的学习资源-视频教程
丨Anna丨的博客
06-10 4506
名称 分类 全新小迪Web渗透工程师第十四期 Web安全 边界安全渗透测试工程师培训教程 Web安全 米斯特白帽子WEB安全第二期培训教程 Web安全 价值1800元的爱安全渗透测试全套培训 Web安全 2016全新小迪WEB安全培训教程 Web安全 价值1273美元！2017年最新 EthicalHacking A-Z黑客教程合集 Web安全 Kali Linux Web安全初级入门 Web安全 Web...
大数据学习路线
qq_43573663的博客
02-03 328
文章目录大数据学习路线 大数据学习路线
B站精品课程
cts618
09-30 812
B站精品课程
【备忘】2017零基础自学云计算分析hadoop/storm/spark大数据开发视频教程
qq_38473587的博客
07-06 739
day01 软件安装、Linux相关、shell     day02 自动化部署高级文本命令     day03 集群部署zookeeper     day04 并发动态大数据机制、Java反射、动态代理     day05 RPC高性能框架、JVM     day06 Hadoop     day07 Hadoop、Hdfs     day08 hadoop、mapreduce
【无标题】
熊孩子的博客
03-23 2043
39.九章系统架构设计 System Design 2021 版 38.小程序音乐项目开发实战-大神coderwhy新课【完结】 37.大喵前端七期最新 36.百知精英Java【价值9999元】 35. 狸猫技术窝 34-高并发高性能高可用MySQL实战（完结） 33.Android 高级开发瓶颈突破系列课【Hencoder Plus】 32-Vite 从入门到精通，玩转新时代前端构建法则（完结） 31-2021后端校招面试直通车，提前锁定大厂offer[11章] 30-2021前端校招直通车，实现Offe
怒肝3W字Java学习路线！从入门到封神全包了（建议收藏）
一行Java的博客
10-21 3729
大家好！我是一航！ 长文警告！！！预计阅读耗时30分钟，你忍一下，但相信看完你不会后悔的；如果没有充足的时间，可以考虑先收藏着；公众号【一行Java】后台回复【Java路线】，即可获取完整的思维导图。 最近和各位小伙伴儿私下聊的比较多，各个阶段的朋友都有；因为大环境的内卷，导致大家在求学、求职、提升自己的各个方面都多多少少有些迷茫焦虑； 这些其实是一个非常普遍且正常的现象，会焦虑的人，往往都是对自己要求比较严苛的好同志；如果躺平了，何来焦虑可言！ 鉴于其中关于学习方向，学习路线的问题，其实网络如此发达.
flink-1.14.0-bin-scala_2.11.tgz
07-18
首先，我们来看看标题“flink-1.14.0-bin-scala_2.11.tgz”，这表明这是一个针对 Scala 2.11 的 Flink 1.14.0 安装包。Scala 是一种多范式编程语言，广泛用于构建分布式系统，特别是大数据处理框架。它与 Flink 的...
flink-1.13.6_cdc
07-07
3. "flink-1.13.6-bin-scala_2.12.tgz"：这是Flink 1.13.6的二进制发行版，基于Scala 2.12编译。这个tgz文件通常包含Flink的完整运行时环境，包括启动脚本、依赖库和示例程序，用于在本地或集群上部署和运行Flink...
flink-shaded-hadoop-3下载
05-19
flink-shaded-hadoop-3下载
flink-table-planner-2.12-1.14.3-API文档-中文版.zip
04-07
赠送jar包：flink-table-planner_2.12-1.14.3.jar 赠送原API文档：flink-table-planner_2.12-1.14.3-javadoc.jar 赠送源代码：flink-table-planner_2.12-1.14.3-sources.jar 包含翻译后的API文档：flink-table-...
尚硅谷大数据之flink教程1
08-08
Apache Flink 是一款开源的流...通过学习尚硅谷的大数据之Flink教程，开发者可以深入了解如何利用Flink进行流处理应用的开发，掌握其核心概念、API使用以及最佳实践，从而在大数据实时分析领域发挥出Flink的强大功能。
3、Flink 与 DataStream API 集成之批运行模式详解
猫猫爱吃小鱼粮
08-05 290
Flink 与 DataStream API 集成之批运行模式详解
[flink]部署模式
最新发布
胖胖的博客
08-05 368
它们的区别主要在于：集群的生命周期（创建和停止集群的时间）以及资源的分配方式（一个独享还是多人共享）；而这也就代表着，我们需要为每一个提交的应用单独启动一个JobManager，也就是创建一个集群。我们需要先启动一个集群，保持一个会话，在这个会话中通过客户端提交作业。集群启动时所有资源就都已经确定，所以所有提交的作业会竞争集群中的资源。在一些应用场景中，对于集群资源分配和占用的方式，可能会有特定的需求。会话模式和单作业模式下，应用的代码都是在客户端上执行的。作业完成后，集群就会关闭，所有资源也会释放。
Flink 如何处理背压
goTsHgo的博客
08-05 544
初次接触Flink的同学会对背压有很多的疑问。本文就是我学习的一些心得和体会，以及借鉴一些文章的感想。Flink 如何处理背压效应。答案很简单：Flink 没有使用任何复杂的机制，因为它不需要。由于是纯数据流引擎，它可以优雅地响应背压。我们介绍了背压问题。然后我们深入研究 Flink 的运行时如何在任务之间传输数据缓冲区，并展示流数据传输如何自然地作为背压机制加倍。Flink 与像 Kafka 这样的持久源一起，可以让你免费处高效地理背压，并且不会丢失数据。
Flink 实时数仓（四）【DWD 层搭建（二）流量域事实表】
梦想是动物管理员
08-02 795
Flink 实时数仓，交易域事实表创建
Flink-CDC实时数据捕获详解与优势
本文主要介绍了如何使用Flink-CDC实现监控数据源的实时变更数据捕获，涵盖了技术定义、应用场景、技术选型、优势及Flink-CDC的特点和生态。 1. CDC技术介绍： CDC（Change Data Capture）是数据库中用于捕获和跟踪...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值