flink 1.10.1 java版本窗口计算案例（全量、增量、排序）

最新推荐文章于 2024-05-10 08:23:25 发布
最新推荐文章于 2024-05-10 08:23:25 发布
阅读量1.4k 收藏 7
点赞数
分类专栏： Java 大数据技术 文章标签： flink java 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaomingwu/article/details/122929463
版权

本文的基础环境可以参考flink 1.10.1 java版本wordcount演示 (nc + socket)

flink的创建计算方法有多种，根据业务需求的特点，可以进行灵活选择。

apply方法用于对窗口进行全量聚合，窗口每触发一次时，会调用一次apply方法，相当于是对窗口中的全量数据进行计算；

aggregate方法实现增量聚合，同时自定义增量聚合和窗口关闭时的数据输出；

ProcessFunction是一个低级的流处理操作，ProcessFunction可以被认为是增加了keyed state和timers功能的FlatMapFunction。ProcesseFunction可以通过RuntimeContext访问Flink中的Keyed State，通过processElement方法中的Context实例访问流元素的时间戳，以及timerServer(注册定时器)，如果watermark大于等于注册定时器的时间，就会调用onTimer方法（此处相当于一个回调函数）,在调用期间，所有state的范围再次限定在创建定时器的key上，从而允许定时器操作keyed state。

1. 添加依赖

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

2. apply全量聚合

package com.demo.realstatis;

import com.alibaba.fastjson.JSON;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
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;
import org.apache.flink.util.Collector;


public class HotGoodsApply {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 选择EventTime作为Flink的时间
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        // 设置checkPoint时间
        env.enableCheckpointing(60000);
        // 设置并行度
        env.setParallelism(1);

        DataStreamSource<String> lines = env.socketTextStream("192.168.0.181", 9000);


        SingleOutputStreamOperator<MyBehavior> process = lines.process(new ProcessFunction<String, MyBehavior>() {
            @Override
            public void processElement(String input, Context ctx, Collector<MyBehavior> out) throws Exception {

                try {

                    if (input == null || input.length() == 0) {
                        return;
                    }

                    // FastJson 会自动把时间解析成long类型的TimeStamp
                    MyBehavior behavior = JSON.parseObject(input, MyBehavior.class);
                    out.collect(behavior);
                } catch (Exception e) {
                    e.printStackTrace();
                    //TODO 记录出现异常的数据
                }
            }
        });

        //      设定延迟时间
        SingleOutputStreamOperator<MyBehavior> behaviorDSWithWaterMark =
                process.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<MyBehavior>(Time.seconds(0)) {
                    @Override
                    public long extractTimestamp(MyBehavior element) {
                        return element.timestamp;
                    }
                });

        //  某个商品，在窗口时间内，被（点击、购买、添加购物车、收藏）了多少次
        KeyedStream<MyBehavior, Tuple> keyed = behaviorDSWithWaterMark.keyBy("itemId", "type");

        WindowedStream<MyBehavior, Tuple, TimeWindow> window =
                keyed.window(SlidingEventTimeWindows.of(Time.minutes(10), Time.minutes(1)));

        //参数：输入的数据类， 输出的数据类，分组字段tuple， 窗口对象TimeWindow
        SingleOutputStreamOperator<ItemViewCount> result = window.apply(new WindowFunction<MyBehavior, ItemViewCount,
                        Tuple, TimeWindow>() {
            @Override
            public void apply(Tuple tuple, TimeWindow window, Iterable<MyBehavior> input,
                              Collector<ItemViewCount> out) throws Exception {
                //拿出分组的字段
                String itemId = tuple.getField(0);
                String type = tuple.getField(1);


                //拿出窗口的起始和结束时间
                long start = window.getStart();
                long end = window.getEnd();

                // 编写累加的逻辑
                int count = 0;

                for (MyBehavior myBehavior : input) {
                    count += 1;
                }

                //输出结果
                out.collect(ItemViewCount.of(itemId, type, start, end, count));
            }
        });


        result.print();
        env.execute("HotGoodsTopN");

    }

}

3. 增量聚合和Process

package com.demo.realstatis;

import com.alibaba.fastjson.JSON;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.common.typeinfo.TypeHint;
import org.apache.flink.api.common.typeinfo.TypeInformation;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.datastream.WindowedStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
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;
import org.apache.flink.util.Collector;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;


public class HotGoodsAggrAndProcess {

    public static void main(String[] args) throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        // 选择EventTime作为Flink的时间
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        // 设置checkPoint时间
        env.enableCheckpointing(60000);
        // 设置并行度
        env.setParallelism(1);

        DataStreamSource<String> lines = env.socketTextStream("192.168.0.181", 9000);


        SingleOutputStreamOperator<MyBehavior> process = lines.process(new ProcessFunction<String, MyBehavior>() {
            @Override
            public void processElement(String input, Context ctx, Collector<MyBehavior> out) throws Exception {

                try {

                    if (input == null || input.length() == 0) {
                        return;
                    }

                    // FastJson 会自动把时间解析成long类型的TimeStamp
                    MyBehavior behavior = JSON.parseObject(input, MyBehavior.class);
                    out.collect(behavior);
                } catch (Exception e) {
                    e.printStackTrace();
                    //TODO 记录出现异常的数据
                }
            }
        });

        //      设定延迟时间
        SingleOutputStreamOperator<MyBehavior> behaviorDSWithWaterMark =
                process.assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<MyBehavior>(Time.seconds(0)) {
                    @Override
                    public long extractTimestamp(MyBehavior element) {
                        return element.timestamp;
                    }
                });

        //  某个商品，在窗口时间内，被（点击、购买、添加购物车、收藏）了多少次
        KeyedStream<MyBehavior, Tuple> keyed = behaviorDSWithWaterMark.keyBy("itemId", "type");

        WindowedStream<MyBehavior, Tuple, TimeWindow> window =
                keyed.window(SlidingEventTimeWindows.of(Time.minutes(10), Time.minutes(1)));

        SingleOutputStreamOperator<ItemViewCount> windowAggregate = window.aggregate(new MyWindowAggFunction(),
                new MyWindowFunction());

        KeyedStream<ItemViewCount, Tuple> soredKeyed = windowAggregate.keyBy("type", "windowStart",
                "windowEnd");

        SingleOutputStreamOperator<List<ItemViewCount>> sored = soredKeyed.process(new KeyedProcessFunction<Tuple, ItemViewCount, List<ItemViewCount>>() {
            private transient ValueState<List<ItemViewCount>> valueState;


            // 要把这个时间段的所有的ItemViewCount作为中间结果聚合在一块，引入ValueState
            @Override
            public void open(Configuration parameters) throws Exception {
                ValueStateDescriptor<List<ItemViewCount>> VSDescriptor =
                        new ValueStateDescriptor<>("list-state",
                                TypeInformation.of(new TypeHint<List<ItemViewCount>>() {
                                })
                        );


                valueState = getRuntimeContext().getState(VSDescriptor);


            }


            //更新valueState 并注册定时器
            @Override
            public void processElement(ItemViewCount input, Context ctx, Collector<List<ItemViewCount>> out) throws Exception {
                List<ItemViewCount> buffer = valueState.value();
                if (buffer == null) {
                    buffer = new ArrayList<>();
                }
                buffer.add(input);
                valueState.update(buffer);
                //注册定时器,当为窗口最后的时间时，通过加1触发定时器
                ctx.timerService().registerEventTimeTimer(input.windowEnd + 1);


            }


            // 做排序操作
            @Override
            public void onTimer(long timestamp, OnTimerContext ctx, Collector<List<ItemViewCount>> out) throws Exception {


                //将ValueState中的数据取出来
                List<ItemViewCount> buffer = valueState.value();
                buffer.sort(new Comparator<ItemViewCount>() {
                    @Override
                    public int compare(ItemViewCount o1, ItemViewCount o2) {
                        //按照倒序，转成int类型
                        return -(int) (o1.viewCount - o2.viewCount);
                    }
                });
                valueState.update(null);
                out.collect(buffer);
            }
        });
        sored.print();
        env.execute("HotGoodsTopNAdv");
    }

}

4. 辅助类ItemViewCount

package com.demo.realstatis;

import java.sql.Timestamp;

public class ItemViewCount {
    public String itemId;     // 商品ID
    public String type;     // 事件类型
    public long windowStart;  // 窗口开始时间戳
    public long windowEnd;  // 窗口结束时间戳
    public long viewCount;  // 商品的点击量


    public static ItemViewCount of(String itemId, String type, long windowStart, long windowEnd, long viewCount) {
        ItemViewCount result = new ItemViewCount();
        result.itemId = itemId;
        result.type = type;
        result.windowStart = windowStart;
        result.windowEnd = windowEnd;
        result.viewCount = viewCount;
        return result;
    }


    @Override
    public String toString() {
        return "{" +
                "itemId='" + itemId + '\'' +
                "type='" + type + '\'' +
                ", windowStart=" + windowStart + " , " + new Timestamp(windowStart) +
                ", windowEnd=" + windowEnd + " , " + new Timestamp(windowEnd) +
                ", viewCount=" + viewCount +
                '}';
    }
}

5. 辅助类MyBehavior

package com.demo.realstatis;

import java.sql.Timestamp;


public class MyBehavior {
    public String userId;           // 用户ID
    public String itemId;           // 商品ID
    public String categoryId;       // 商品类目ID
    public String type;             // 用户行为, 包括("pv", "buy", "cart", "fav")
    public long timestamp;          // 行为发生的时间戳，单位秒
    public long counts = 1;


    public static MyBehavior of(String userId, String itemId, String categoryId, String type, long timestamp) {
        MyBehavior behavior = new MyBehavior();
        behavior.userId = userId;
        behavior.itemId = itemId;
        behavior.categoryId = categoryId;
        behavior.type = type;
        behavior.timestamp = timestamp;
        return behavior;
    }


    public static MyBehavior of(String userId, String itemId, String categoryId, String type, long timestamp,
                                long counts) {
        MyBehavior behavior = new MyBehavior();
        behavior.userId = userId;
        behavior.itemId = itemId;
        behavior.categoryId = categoryId;
        behavior.type = type;
        behavior.timestamp = timestamp;
        behavior.counts = counts;
        return behavior;
    }


    @Override
    public String toString() {
        return "MyBehavior{" + "userId='" + userId + '\'' + ", itemId='" + itemId + '\''
                + ", categoryId='" + categoryId + '\'' + ", type='" + type + '\''
                + ", timestamp=" + timestamp + "," + new Timestamp(timestamp)
                + "counts=" + counts + '}';
    }


    public String getUserId() {
        return userId;
    }
    public String getItemId() {
        return itemId;
    }
    public String getCategoryId() {
        return categoryId;
    }
    public String getType() {
        return type;
    }
    public long getTimestamp() {
        return timestamp;
    }
    public long getCounts() {
        return counts;
    }
}

6. 辅助类MyWindowAggFunction

package com.demo.realstatis;

import org.apache.flink.api.common.functions.AggregateFunction;

//
public class MyWindowAggFunction implements AggregateFunction<MyBehavior, Long, Long> {


    //初始化一个计数器
    @Override
    public Long createAccumulator() {
        return 0L;
    }


    //每输入一条数据就调用一次add方法
    @Override
    public Long add(MyBehavior input, Long accumulator) {
        return accumulator + input.counts;
    }


    @Override
    public Long getResult(Long accumulator) {
        return accumulator;
    }


    //只针对SessionWindow有效，对应滚动窗口、滑动窗口不会调用此方法
    @Override
    public Long merge(Long a, Long b) {
        return null;
    }
}

7. 辅助类MyWindowFunction

package com.demo.realstatis;

import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;

public class MyWindowFunction implements WindowFunction<Long, ItemViewCount, Tuple, TimeWindow> {


    @Override
    public void apply(Tuple tuple, TimeWindow window, Iterable<Long> input, Collector<ItemViewCount> out) throws Exception {
        String itemId = tuple.getField(0);
        String type = tuple.getField(1);


        long windowStart = window.getStart();
        long windowEnd = window.getEnd();


        //窗口集合的结果
        Long aLong = input.iterator().next();


        //输出数据
        out.collect(ItemViewCount.of(itemId, type, windowStart, windowEnd, aLong));
    }
}

8. 测试数据

{"userId": "u001", "itemId": "p1001", "categoryId": "c11", type: "pv", "timestamp": "2020-03-08 11:11:11"}
{"userId": "u002", "itemId": "p1001", "categoryId": "c11", type: "pv", "timestamp": "2020-03-08 11:11:11"}
{"userId": "u003", "itemId": "p1001", "categoryId": "c11", type: "pv", "timestamp": "2020-03-08 11:11:11"}
{"userId": "u003", "itemId": "p1001", "categoryId": "c11", type: "cart", "timestamp": "2020-03-08 11:11:11"}
{"userId": "u011", "itemId": "p2222", "categoryId": "c22", type: "pv", "timestamp": "2020-03-08 11:11:11"}
{"userId": "u012", "itemId": "p2222", "categoryId": "c22", type: "pv", "timestamp": "2020-03-08 11:11:11"}
{"userId": "u012", "itemId": "p2222", "categoryId": "c22", type: "pv", "timestamp": "2020-03-08 11:12:01"}
{"userId": "u001", "itemId": "p1001", "categoryId": "c11", type: "pv", "timestamp": "2020-03-08 11:12:01"}
{"userId": "u002", "itemId": "p1001", "categoryId": "c11", type: "pv", "timestamp": "2020-03-08 11:12:01"}
{"userId": "u003", "itemId": "p1001", "categoryId": "c11", type: "pv", "timestamp": "2020-03-08 11:12:01"}
{"userId": "u003", "itemId": "p1001", "categoryId": "c11", type: "cart", "timestamp": "2020-03-08 11:12:01"}
{"userId": "u011", "itemId": "p2222", "categoryId": "c22", type: "pv", "timestamp": "2020-03-08 11:12:01"}
{"userId": "u012", "itemId": "p2222", "categoryId": "c22", type: "pv", "timestamp": "2020-03-08 11:12:01"}
{"userId": "u011", "itemId": "p2222", "categoryId": "c22", type: "pv", "timestamp": "2020-03-08 11:13:01"}

9. 测试输出

{itemId='p1001'type='pv', windowStart=1583636520000 , 2020-03-08 11:02:00.0, windowEnd=1583637120000 , 2020-03-08 11:12:00.0, viewCount=3}
{itemId='p1001'type='cart', windowStart=1583636520000 , 2020-03-08 11:02:00.0, windowEnd=1583637120000 , 2020-03-08 11:12:00.0, viewCount=1}
{itemId='p2222'type='pv', windowStart=1583636520000 , 2020-03-08 11:02:00.0, windowEnd=1583637120000 , 2020-03-08 11:12:00.0, viewCount=2}
{itemId='p1001'type='cart', windowStart=1583636580000 , 2020-03-08 11:03:00.0, windowEnd=1583637180000 , 2020-03-08 11:13:00.0, viewCount=2}
{itemId='p1001'type='pv', windowStart=1583636580000 , 2020-03-08 11:03:00.0, windowEnd=1583637180000 , 2020-03-08 11:13:00.0, viewCount=6}
{itemId='p2222'type='pv', windowStart=1583636580000 , 2020-03-08 11:03:00.0, windowEnd=1583637180000 , 2020-03-08 11:13:00.0, viewCount=5}

程序猿20
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink系列Table API和SQL之：普通Top N和窗口Top N
zhengzaifeidelushang的博客
12-31 689
Flink系列Table API和SQL之：普通Top N和窗口Top N
java8stream源码-flink_sort:相当排序
06-04
java8流源码Apache Flink Apache Flink 是一个开源的流处理框架，具有强大的流处理和批处理能力。 了解更多关于 Flink 的信息 特征 支持批处理和数据流程序的流优先运行时 Java 和 Scala 中优雅流畅的 API 同时支持非常高的吞吐量和低事件延迟的运行时 基于Dataflow 模型，支持 DataStream API 中的事件时间和乱序处理 跨不同时间语义（事件时间、处理时间）的灵活窗口（时间、计数、会话、自定义触发器） 具有完全一次处理保证的容错 流媒体程序中的自然背压 图处理（批处理）、机器学习（批处理）和复杂事件处理（流）库 数据集（批处理）API 中对迭代程序 (BSP) 的内置支持 自定义内存管理，可在内存和核外数据处理算法之间进行高效、稳健的切换 Apache Hadoop MapReduce 和 Apache Storm 的兼容层 与 YARN、HDFS、HBase 和 Apache Hadoop 生态系统的其他组件集成 流媒体示例 case class WordWithCount ( word : String , count :
Flink ValueStateDescriptor使用实例
最新发布
linweidong的专栏
05-10 313
在Apache Flink中，是用于定义状态的一种数据结构，它允许你为每个键（key）存储一个值（value）。状态是 Flink 流处理模型的核心概念之一，它允许你在任务失败和恢复时保持数据的一致性。
使用java写一个对接flink的例子
牛肉胡辣汤
02-27 1682
方法生成 1000 个从 0 到 999 的数字作为模拟数据，将它们转化为字符串并拼接成键值对，然后使用 Flink 的 Kafka 生产者将数据写入到 Kafka 的。方法开启了检查点，并设置了检查点间隔和模式。它使用了 Flink 的 Kafka 消费者从 Kafka 主题。中读取数据，然后将每个键值对解析成。都需要替换为实际使用的版本号。这个程序使用 Flink 的。这个程序使用 Flink 的。
Flink基于Java的WordCount，根据滑动窗口动态排序实现
weixin_43260123的博客
12-17 2950
Flink基于Java实现wordcount的动态排序
Flink对keyBy汇总后的数据排序
xkxdqj的博客
03-02 3940
val env = StreamExecutionEnvironment.getExecutionEnvironment env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime) env.setParallelism(1) val sourceStream = env.fromCollection(List( "a,1646150400000", "a,1646150403000",.
Flink 实践教程-进阶（5）：排序（乱序调整）
cloudbigdata的博客
12-29 2338
配合使用 Windowing TVF 调整乱序数据
基于Flink CDC使用datastream方式全量增量同步mysql to mysql
03-04
基于Flink CDC使用datastream方式全量增量同步mysql to mysql 使用的是java语言，只需配置完源数据库和目标数据库信息，运行MysqlCDC中的main函数，即可实现多库多表同步。
flink-1.10.1-bin-scala_2.12.tgz.zip
09-14
标题中的"flink-1.10.1-bin-scala_2.12.tgz.zip"标识了这是一个Apache Flink的特定版本安装包，版本号为1.10.1，且是针对Scala 2.12编译的二进制发行版。Flink是一个开源的流处理和批处理框架，广泛应用于大数据处理...
cdh.6.3.2 编译成功的flink1.10.1
11-24
本文将详细探讨在CDH6.3.2（Cloudera Data Hub）环境下成功编译的Flink1.10.1版本，该版本是专为CDH6.x系列设计，确保与CDH组件的兼容性，以满足企业级的大数据需求。 首先，我们来理解CDH6.3.2。Cloudera Data Hub...
基于Java的实时流计算Flink SQL Web平台设计源码
04-07
实时流计算Flink SQL Web平台：基于Java开发，包含808个文件，包括215个Java类文件、192个JavaScript文件、148个Vue组件文件、58个CSS样式文件、46个SVG图像文件、29个Markdown文档、24个XML配置文件、18个PNG图像...
flink-1.10.1-bin-scala_2.12.tgz
06-06
Flink 1.10.1 版本的发布，进一步提升了系统的稳定性和易用性，为开发者提供了更多优化的功能。 在 Flink 1.10.1 中，主要包含了以下几个关键知识点： 1. **流处理模型**：Flink 基于DataStream API提供了一种强大...
Flink流处理案例：实时数据排序
禅与计算机程序设计艺术
01-25 1338
1.背景介绍 1. 背景介绍 Apache Flink是一个流处理框架，用于实时数据处理和分析。它可以处理大规模数据流，并提供低延迟、高吞吐量和强一致性等特性。Flink流处理框架支持多种数据源和接口，如Kafka、HDFS、TCP等，可以处理各种复杂的数据流操作，如窗口操作、连接操作、聚合操作等。 在实际应用中，Flink流处理框架可以应用于各种场景，如实时数据分析、实时监控、实时推荐等。...
Flink的流中的自定义排序操作
禅与计算机程序设计艺术
01-21 1047
1.背景介绍 在大数据处理领域，流处理是一种实时的数据处理方法，用于处理大量的、高速的、实时的数据流。Apache Flink是一个流处理框架，可以用于实现流处理任务。在Flink中，自定义排序操作是一种常见的流处理任务，用于对流中的数据进行排序。本文将详细介绍Flink的流中自定义排序操作的背景、核心概念、算法原理、最佳实践、实际应用场景、工具和资源推荐以及未来发展趋势与挑战。 1. 背景介...
【Flink】Flink 快速排序在Flink中的应用案例 QuickSort
九师兄
12-25 590
在这篇文章中，我们看到FLink引入快速排序的原因。
Flink Window 排序
测试0901-1
03-02 3134
Flink Window 排序 概述 对增量Window进行输出排序 WordCount增量(按单词名称排序) WordCount增量(按单词个数，再单词名称排序) 源码 https://github.com/opensourceteams/fink-maven-scala-2 源码分析 WordCount 程序(增量按单词升序排序) DataSt...
Flink如何处理乱序数据？
justlpf的专栏
02-22 3711
参考文章：Flink如何处理乱序数据？ 本章主要针对Flink Time中的Event Time、Ingestion Time、Processing Time以及Watermark进行详细讲解。 1 Time Stream数据中的Time（时间）分为以下3种。 Event Time：事件产生的时间，它通常由事件中的时间戳描述。 Ingestion Time：事件进入Flink的时间。 Processing Time：事件被处理时当前系统的时间。 这几种时间的对应关系如图1所示。 图1　
Flink DataSet聚合、分区、排序、关联转换算子的使用
Bulut0907
10-23 2788
目录1. 聚合转换算子1.1 reduce1.2 aggregate1.3 distinct2. 分区转换算子2.1 partitionByHash、partitionByRange、sortPartition2.2 mapPartition3. 排序转换算子3.1 MinBy / MaxBy、First-N4. 关联转换算子4.1 join、leftOuterJoin、rightOuterJoin、fullOuterJoin、cross、coGroup 1. 聚合转换算子 1.1 reduce pack
Flink 实时统计热门商品的TopN
yang灬仔
06-14 1795
文章目录 一、需求说明 1、以案例驱动理解 二、技术点 三、代码实现（一） 1、调用底层的Process（可做类似map的操作），将Json字符串解析成MyBehavior对象 2、提取EventTime,转换成Timestamp格式,生成WaterMark 3、按照指定事件分组 4、把分好组的数据，划分窗口：假设窗口总长10分钟， 步长1分钟滑动一次 5、窗口内的数据进...
flink sql 窗口函数
07-28
Flink SQL支持窗口函数，可以在流式数据或批处理数据上进行窗口操作。窗口函数主要用于在指定的窗口范围内进行聚合计算。 在Flink SQL中，窗口函数可以通过以下方式使用： 1. 定义窗口：在查询语句中使用`WINDOW`子句来定义窗口。窗口可以基于事件时间、处理时间或者是无界的。 例如，定义一个滑动时间窗口可以使用以下语法： ``` SELECT ... FROM ... WINDOW TUMBLE (SIZE INTERVAL '1' HOUR, SLIDE INTERVAL '30' MINUTE) ... ``` 2. 使用窗口函数：在查询语句中使用内置的窗口函数来进行计算。常见的窗口函数包括`SUM`、`COUNT`、`AVG`、`MIN`、`MAX`等。 例如，计算每个窗口内某个字段的总和可以使用以下语法： ``` SELECT SUM(field) OVER (PARTITION BY ... ORDER BY ...) AS sum_field FROM ... ``` 3. 指定窗口范围：使用窗口函数时，可以通过`PARTITION BY`和`ORDER BY`子句来指定分区和排序方式。分区决定了窗口的划分，排序用于确定事件在窗口中的顺序。 例如，按照某个字段进行分区和排序可以使用以下语法： ``` SELECT ... FROM ... WINDOW TUMBLE (SIZE INTERVAL '1' HOUR) PARTITION BY field1 ORDER BY field2 ... ``` 这只是窗口函数的简要介绍，Flink SQL还支持更多高级的窗口操作和函数。你可以查阅Flink官方文档以获取更详细的信息和示例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值