Java版Flink（十）window窗口（二）

于 2024-01-10 19:02:13 发布
阅读量55 收藏
点赞数
文章标签： java flink 开发语言
原文链接：https://blog.csdn.net/qq_41311979/article/details/114931459
版权

一、触发器（Trigger）

1.1、案例一

利用 global window + trigger 计算单词出现三次统计一次（有点像CountWindow）
某台虚拟机或者mac 终端输入：nc -lk 9999

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.GlobalWindows;
import org.apache.flink.streaming.api.windowing.triggers.CountTrigger;
import org.apache.flink.util.Collector;
public class WindowFunction_Global_Trigger {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> inputDataStream = env.socketTextStream("localhost", 9999);
        SingleOutputStreamOperator<Tuple2<String, Integer>> resultDataStream = inputDataStream.flatMap(new CustomFlatMap())
                .keyBy(0)
                .window(GlobalWindows.create()) // 如果不调用trigger 那么程序一直处于数据收集阶段 无法触发计算
                .trigger(CountTrigger.of(3))
                .sum(1);
        resultDataStream.print();
        env.execute();
    }
    public static class CustomFlatMap implements FlatMapFunction<String, Tuple2<String, Integer>> {
        @Override
        public void flatMap(String input, Collector<Tuple2<String, Integer>> collector) throws Exception {
            String[] words = input.split(" ");
            for (String word : words) {
                collector.collect(new Tuple2<>(word, 1));
            }
        }
    }
}

  
  

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

终端输入：
hello flink
hello spark
hello hive
控制台打印：（hello，3）

1.2、案例二

利用global window 自定义一个CountWindow，也是单词出现3次统计一次

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.common.state.ReducingState;
import org.apache.flink.api.common.state.ReducingStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.GlobalWindows;
import org.apache.flink.streaming.api.windowing.triggers.Trigger;
import org.apache.flink.streaming.api.windowing.triggers.TriggerResult;
import org.apache.flink.streaming.api.windowing.windows.GlobalWindow;
import org.apache.flink.util.Collector;
public class WindowFunction_CustomTrigger {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> inputDataStream = env.socketTextStream("localhost", 9999);
        SingleOutputStreamOperator<Tuple2<String, Integer>> resultDataStream = inputDataStream.flatMap(new CustomFlatMap())
                .keyBy(0)
                .window(GlobalWindows.create())
                .trigger(new CustomTrigger(3))
                .sum(1);
        resultDataStream.print();
        env.execute();
    }
    public static class CustomFlatMap implements FlatMapFunction<String, Tuple2<String, Integer>> {
        @Override
        public void flatMap(String input, Collector<Tuple2<String, Integer>> collector) throws Exception {
            String[] words = input.split(" ");
            for (String word : words) {
                collector.collect(new Tuple2<>(word, 1));
            }
        }
    }
    public static class CustomTrigger extends Trigger<Tuple2<String, Integer>, GlobalWindow> {
        private long maxCount;
        public CustomTrigger(long count) {
            this.maxCount = count;
        }
        // 定义一个状态保存 每个 key 对应的 count 值 （涉及到状态编程 后面会具体介绍）
        private ReducingStateDescriptor<Long> stateDescriptor = new ReducingStateDescriptor<Long>("count", new ReduceFunction<Long>() {
            @Override
            public Long reduce(Long input1, Long input2) throws Exception {
                return input1 + input2;
            }
        }, Long.class);
        /**
         * 每来一条数据都会执行
         *
         * @param input          输入类型
         * @param timestamp      处理时间戳
         * @param globalWindow   全窗口类型(所属窗口)
         * @param triggerContext trigger 上下文
         * @return TriggerResult
         * 1. TriggerResult.CONTINUE ：表示对 window 不做任何处理
         * 2. TriggerResult.FIRE ：表示触发 window 的计算
         * 3. TriggerResult.PURGE ：表示清除 window 中的所有数据
         * 4. TriggerResult.FIRE_AND_PURGE ：表示先触发 window 计算，然后删除 window 中的数据
         * @throws Exception
         */
        @Override
        public TriggerResult onElement(Tuple2<String, Integer> input, long timestamp, GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 获取 key 对应之前 count 状态值
            ReducingState<Long> count = triggerContext.getPartitionedState(stateDescriptor);
            // 每来一条数据 累加 1
            count.add(1L);
            if (maxCount == count.get()) {
                // 如果已经达到预期的count
                // 1 清除 count 状态
                count.clear();
                // 2 先触发计算 再清空窗口的数据
                return TriggerResult.FIRE_AND_PURGE;
            }
            // 3 否则不做任务处理
            return TriggerResult.CONTINUE;
        }
        @Override
        public TriggerResult onProcessingTime(long l, GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 基于 processingTime 定时器处理逻辑
            return TriggerResult.CONTINUE;
        }
        @Override
        public TriggerResult onEventTime(long l, GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 基于 EventTime 定时器处理逻辑
            return TriggerResult.CONTINUE;
        }
        @Override
        public void clear(GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 清理状态
            triggerContext.getPartitionedState(stateDescriptor).clear();
        }
    }
}

  
  

  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104

终端输入：
world spark
world flink
world hive
控制台打印：（world，3）

二、移除器（Evictor）

2.1 案例

利用 global window + trigger + evictor 实现每个2个单词统计最近3个单词

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.common.state.ReducingState;
import org.apache.flink.api.common.state.ReducingStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.GlobalWindows;
import org.apache.flink.streaming.api.windowing.evictors.Evictor;
import org.apache.flink.streaming.api.windowing.triggers.Trigger;
import org.apache.flink.streaming.api.windowing.triggers.TriggerResult;
import org.apache.flink.streaming.api.windowing.windows.GlobalWindow;
import org.apache.flink.streaming.runtime.operators.windowing.TimestampedValue;
import org.apache.flink.util.Collector;
import java.util.Iterator;
public class WindowFuncton_CustomEvictor {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        DataStreamSource<String> inputDataStream = env.socketTextStream("localhost", 9999);
        SingleOutputStreamOperator<Tuple2<String, Integer>> resultDataStream = inputDataStream.flatMap(new CustomFlatMap())
                .keyBy(0)
                .window(GlobalWindows.create())
                .trigger(new CustomTrigger(2)) // 每来2条数据触发后面的计算
                .evictor(new CustomEvictor(3))
                .sum(1);
        resultDataStream.print();
        env.execute();
    }
    public static class CustomFlatMap implements FlatMapFunction<String, Tuple2<String, Integer>> {
        @Override
        public void flatMap(String input, Collector<Tuple2<String, Integer>> collector) throws Exception {
            String[] words = input.split(" ");
            for (String word : words) {
                collector.collect(new Tuple2<>(word, 1));
            }
        }
    }
    public static class CustomTrigger extends Trigger<Tuple2<String, Integer>, GlobalWindow> {
        private long maxCount;
        public CustomTrigger(long count) {
            this.maxCount = count;
        }
        // 定义一个状态保存 每个 key 对应的 count 值 （涉及到状态编程 后面会具体介绍）
        private ReducingStateDescriptor<Long> stateDescriptor = new ReducingStateDescriptor<Long>("count", new ReduceFunction<Long>() {
            @Override
            public Long reduce(Long input1, Long input2) throws Exception {
                return input1 + input2;
            }
        }, Long.class);
        /**
         * 每来一条数据都会执行
         *
         * @param input          输入类型
         * @param timestamp      处理时间戳
         * @param globalWindow   全窗口类型(所属窗口)
         * @param triggerContext trigger 上下文
         * @return TriggerResult
         * 1. TriggerResult.CONTINUE ：表示对 window 不做任何处理
         * 2. TriggerResult.FIRE ：表示触发 window 的计算
         * 3. TriggerResult.PURGE ：表示清除 window 中的所有数据
         * 4. TriggerResult.FIRE_AND_PURGE ：表示先触发 window 计算，然后删除 window 中的数据
         * @throws Exception
         */
        @Override
        public TriggerResult onElement(Tuple2<String, Integer> input, long timestamp, GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 获取 key 对应之前 count 状态值
            ReducingState<Long> count = triggerContext.getPartitionedState(stateDescriptor);
            // 每来一条数据 累加 1
            count.add(1L);
            if (maxCount == count.get()) {
                // 如果已经达到预期的count
                // 1 清除 count 状态
                count.clear();
                // 2 先触发计算 不清空窗口的数据
                return TriggerResult.FIRE;
            }
            // 3 否则不做任务处理
            return TriggerResult.CONTINUE;
        }
        @Override
        public TriggerResult onProcessingTime(long l, GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 基于 processingTime 定时器处理逻辑
            return TriggerResult.CONTINUE;
        }
        @Override
        public TriggerResult onEventTime(long l, GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 基于 EventTime 定时器处理逻辑
            return TriggerResult.CONTINUE;
        }
        @Override
        public void clear(GlobalWindow globalWindow, TriggerContext triggerContext) throws Exception {
            // 清理状态
            triggerContext.getPartitionedState(stateDescriptor).clear();
        }
    }
    public static class CustomEvictor implements Evictor<Tuple2<String, Integer>, GlobalWindow> {
        // 定义窗口的数据大小
        private long windowCount;

    <span class="token keyword">public</span> <span class="token function">CustomEvictor</span><span class="token punctuation">(</span><span class="token keyword">long</span> windowCount<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
        <span class="token keyword">this</span><span class="token punctuation">.</span>windowCount <span class="token operator">=</span> windowCount<span class="token punctuation">;</span>
    <span class="token punctuation">}</span>
    <span class="token comment">/**
     * @param iterable       当前窗口的全部数据 （可以认为这些数据是有顺序的（相对队列））
     * @param size           当前窗口的数据大小
     * @param globalWindow
     * @param evictorContext 上下文
     */</span>
    <span class="token annotation punctuation">@Override</span>
    <span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">evictBefore</span><span class="token punctuation">(</span>Iterable<span class="token operator">&lt;</span>TimestampedValue<span class="token operator">&lt;</span>Tuple2<span class="token generics function"><span class="token punctuation">&lt;</span>String<span class="token punctuation">,</span> Integer<span class="token punctuation">&gt;</span></span><span class="token operator">&gt;&gt;</span> iterable<span class="token punctuation">,</span> <span class="token keyword">int</span> size<span class="token punctuation">,</span> GlobalWindow globalWindow<span class="token punctuation">,</span> EvictorContext evictorContext<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
        <span class="token comment">// 如果输入数据窗口大小等于指定窗口大小 没有数据可以移除</span>
        <span class="token keyword">if</span> <span class="token punctuation">(</span>windowCount <span class="token operator">==</span> size<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
            <span class="token keyword">return</span><span class="token punctuation">;</span>
        <span class="token punctuation">}</span> <span class="token keyword">else</span> <span class="token punctuation">{<!-- --></span>
            <span class="token comment">// 临时 count 用来判断移除哪些数据</span>
            <span class="token keyword">int</span> evictorCount <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span>
            Iterator<span class="token operator">&lt;</span>TimestampedValue<span class="token operator">&lt;</span>Tuple2<span class="token generics function"><span class="token punctuation">&lt;</span>String<span class="token punctuation">,</span> Integer<span class="token punctuation">&gt;</span></span><span class="token operator">&gt;&gt;</span> iterator <span class="token operator">=</span> iterable<span class="token punctuation">.</span><span class="token function">iterator</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
            <span class="token keyword">while</span> <span class="token punctuation">(</span>iterator<span class="token punctuation">.</span><span class="token function">hasNext</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
                iterator<span class="token punctuation">.</span><span class="token function">next</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
                evictorCount<span class="token operator">++</span><span class="token punctuation">;</span>
                <span class="token comment">// 判断什么时候可以移除哪些数据</span>
                <span class="token comment">/**
                 * 比如当前窗口共有5条数据 统计最近3条数据 移除2条数据
                 * evictorCount = 1     size = 5     windowCount = 3 (需要移除当前遍历数据)
                 * evictorCount = 2     size = 5     windowCount = 3 (需要移除当前遍历数据)
                 * evictorCount = 3     size = 5     windowCount = 3 (不需要移除当前遍历数据)
                 * ...
                 */</span>
                <span class="token keyword">if</span> <span class="token punctuation">(</span>evictorCount <span class="token operator">&gt;</span> size <span class="token operator">-</span> windowCount<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
                    <span class="token keyword">break</span><span class="token punctuation">;</span>
                <span class="token punctuation">}</span> <span class="token keyword">else</span> <span class="token punctuation">{<!-- --></span>
                    iterator<span class="token punctuation">.</span><span class="token function">remove</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
                <span class="token punctuation">}</span>
            <span class="token punctuation">}</span>
        <span class="token punctuation">}</span>
    <span class="token punctuation">}</span>
    <span class="token annotation punctuation">@Override</span>
    <span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">evictAfter</span><span class="token punctuation">(</span>Iterable<span class="token operator">&lt;</span>TimestampedValue<span class="token operator">&lt;</span>Tuple2<span class="token generics function"><span class="token punctuation">&lt;</span>String<span class="token punctuation">,</span> Integer<span class="token punctuation">&gt;</span></span><span class="token operator">&gt;&gt;</span> iterable<span class="token punctuation">,</span> <span class="token keyword">int</span> i<span class="token punctuation">,</span> GlobalWindow globalWindow<span class="token punctuation">,</span> EvictorContext evictorContext<span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
    <span class="token punctuation">}</span>
<span class="token punctuation">}</span>

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162

终端输入：
flink A
flink B
(此时控制台已经打印（flink，2) ）
flink C
flink D
(此时控制台已经答应 （flink，3）)
flink E
flink F
(此时控制台已经答应 （flink，3）)
以此类推

三、迟到数据和侧输出流

迟到数据：这些数据根据 EventTime已经分配好了所在窗口执行，但是所在窗口已经执行计算了，并且这些数据不会被当前窗口所收集和计算。
侧输出流：把迟到的数据放入到侧输出流中，单独进行计算。
由于该案例涉及到 EventTime（日志产生时间）、ingestTime（数据进入程序时间）、processTime（数据处理时间）的关系和 watermark（水位线）的概念描述，该案例放到下面具体介绍。

wukong3158
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Flink时间和窗口
L
07-24 1207
如图所示，由事件生成器（Event Producer）生成事件，生成的事件数据被收集起来，首先进入分布式消息队列（Message Queue），然后被 Flink 系统中的 Source 算子（Data Source）读取消费，进而向下游的窗口算子（Window Operator）传递，最终由窗口算子进行计算处理。​ 有两个非常重要的时间点：（1）一个是数据产生的时刻，我们把它叫作“事件时间”（Event Time）；
Flink SQL 窗口表值函数 Window TVF 实战
SmartSi
10-04 775
窗口 TVF 是 Flink 定义的多态表函数(缩写 PTF)。PTF 是 SQL 2016 标准的一部分，是一个特殊的表函数，可以将表作为参数。因为 PTF 在语义上像表一样使用，所以它们的调用发生在 SELECT 语句的 FROM 子句中。窗口 TVF 是传统 Grouped Window 函数的替代品。窗口 TVF 更符合 SQL 标准，也更强大，可以支持复杂的基于窗口的计算，例如 Window TopN, Window Join。但是，Grouped Window 函数只能支持窗口聚合。
Java版Flink（九）window窗口（一）
qq_41311979的博客
03-17 544
一、window 概述 Flink 通常处理流式、无限数据集的计算引擎，窗口是一种把无限流式数据集切割成有限的数据集进行计算。window窗口在Flink中极其重要。 二、window 类型 window 注意分为两大类型：CountWindow 和 TimeWindow 2.1、CountWindow CountWindow 是与时间没有关系的，比如 数据收集的一定大小（1w）的时候就会触发窗口函数进行计算。 2.2、TimeWindow TimeWindow 就是时间窗口，它与时间非常紧密。主要分为三大
【Flink部署】java部署、本地部署(maven-shade工具)、平台部署（windows部署、 linux部署）；端口号修改
最新发布
qq_47450919的博客
08-22 668
1.flink的java部署 01.直接main方法启动 02.idea中可以直接创建web界面并提交直接启动(了解) 2.flink的本地部署(打包成jar包,在黑窗口中运行) 01.maven-shade工具进行打包操作 3.flink的平台部署 01.windows部署(了解) 02.linux部署(掌握) 端口号修改
FlinkWindow类型介绍和API操作
互联网知识分享
08-03 106
是中用于处理流数据的窗口类型。窗口是将无限流数据划分为有限大小的时间段或者元素个数的方法，以便对数据进行聚合、分组或者其他操作。Flink提供了多种窗口类型，如滚动窗口、滑动窗口、会话窗口等，可以根据具体需求选择合适的窗口类型。3.1参数介绍window()：设置窗口大小和滑动间隔，接收一个Time类型的参数，表示窗口大小或滑动间隔。every()：用于滑动窗口，设置滑动间隔，接收一个Time类型的参数，表示滑动间隔。：设置窗口大小，接收一个整数参数，表示窗口大小。
Flink Java 之 window（滚动， 滑动， 计数， 会话）
weixin_46376562的博客
07-04 557
来源于flink官网
Flink 基础学习之窗口 Window
Java极客技术
12-04 1130
01、前言前面讲了时间 Time 的概念和实际解决问题后，本篇来看下经常搭配使用的另一个关键工具：窗口 Window。窗口也有三种类型可供选择使用：Tumbling Windows：滚动...
Flink之window窗口
m0_64115815的博客
09-07 508
flink相关内容
Flink之滑动窗口（SlidingEventTimeWindows）
01-07
def main(args: Array[String]): Unit = { // 环境 val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime...
flink session window窗口合并
wflh323的专栏
04-30 1407
flink session window窗口的条件是元素间隔大于gap 还是 大于等于gap?session window是怎么进行合并的？还是通过官方示例：org.apache.flink.streaming.examples.windowing.SessionWindowing 进行分析: 主要是修改了下数据源，首先添加8这条数据执行结果如下: 从结果可以看出 b 都在同一个窗...
Flink countWindow 使用
xsdxs的博客
09-16 9699
1. 说明 countWindows 包括滚动窗口类型和滑动窗口类型。以下通过代码和输出来说明 countWindows()逻辑。数据源代码： public static class StreamDataSource extends RichParallelSourceFunction&amp;lt;Tuple2&amp;lt;String, String&amp;gt;&amp;gt; { pr...
Flink原理与实现：Window的实现原理
weixin_34199335的博客
10-19 378
Flink原理与实现系列文章： Flink 原理与实现：架构和拓扑概览Flink 原理与实现：如何生成 StreamGraphFlink 原理与实现：如何生成 JobGraphFlink原理与实现：如何生成ExecutionGraph及物理执行图Flink原理与实现：Operator Chain原理Flink原理与实现：详解Flink中的状态管理 在阅读...
Flink之窗口的使用(java)
fy1235的博客
11-24 1087
Flink之窗口的使用 前言 我们前面其实一直都有在使用窗口，那么我们现在来针对窗口的各种类型做一个演示。 1.1 窗口简述 聚合事件（比如计数、求和）在流上的工作方式与批处理不同。比如，对流中的所有元素进行计数是不可能的，因为通常流是无限的（无界的）。所以，流上的聚合需要由 window 来划定范围，比如 “计算过去的5分钟” ，或者 “最后100个元素的和” 。window是一种可以把无限数据切割为有限数据块的手段。 1.2 窗口类型 tumbling window：滚动窗口 sliding w
windows环境Java操作Flink入门指南
u010479989的博客
03-01 1603
所需jar包 <dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-java</artifactId> <version>1.11.1</version> </dependency> <dependency> <groupId>org.apache.flink</gro
Flink的window机制(一)
JasonLee实时计算
12-14 2570
Flink中的window操作是非常丰富的,不得不承认这一点要比spark做的好很多,由于Flink的window机制是比较复杂的,也比较的难理解,所以我会分几篇去介绍他,下面我们一起揭开它神秘的面纱,听我细细道来. 什么是Windows? 窗口是无限流处理的核心部分,窗口把无限的流分成了有限大小的桶,我们可以在桶上面进行计算,这篇文章会教大家在Flink中如何进行窗口操作,以及开发者如何从F...
flink中对于window和watermark的一些理解
xiao_jun_0820的专栏
04-02 5766
首先window的时间范围是一个自然时间范围，比如你定义了一个TumblingEventTimeWindows.of(Time.seconds(3))窗口，那么会生成类似如下的窗口(左闭右开)：[2018-03-03 03:30:00,2018-03-03 03:30:03)[2018-03-03 03:30:03,2018-03-03 03:30:06)...[2018-03-03 03:30:...
Flink window 的类型
java 帝国
06-22 473
一、Window Type 1、Global windows     2、Tumbling windows     3、Sliding windows     4、Session windows     5、WindowAll    二、Physical Partitioning   1、Custom   2、Random   3、Rebalancin...
Flink 中 timeWindow 滚动窗口边界和数据延迟问题调研
热门推荐
xsdxs的博客
09-05 1万+
1. 说明 好久不写 CSDN blog，早转战Gitbook的。这次记录文章同时，顺带刷下存在感。下面进入正题： 本文主要关于Flink timeWindow 窗口边界和以及延时数据处理的调研。读这篇文章需要对Flink Eventtime + WaterMark + Windows 机制有个基础了解。其次最好先阅读Flink流计算编程–watermark（水位线）简介 这篇文章。本文是在阅...
Flink window 以及windowFunction
weixin_45764675的博客
03-12 1773
Windows Windows是处理无限流的核心。Windows将流分成有限大小的“存储桶”，我们可以在其上应用计算。本文档重点介绍如何在Flink中执行窗口化，以及程序员如何从其提供的功能中获得最大收益。 窗口式Flink程序的一般结构如下所示。第一个片段指的是键控流，第二个片段指的是非**键控流。正如人们所看到的，唯一的区别是keyBy(…)呼吁密钥流和window(…)成为windowAll...
java Flink如何用window写wordcount？
07-08
在Java Flink中使用窗口（Window）来编写WordCount程序，可以通过以下步骤实现： 1. 导入所需的 Flink 库和类： ```java import org.apache.flink.api.java.tuple.Tuple2; import org.apache.flink.streaming.api....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值