flink水位线案例

已于 2024-03-31 12:42:16 修改
阅读量478 收藏 1
点赞数 15
分类专栏： 案例试题 文章标签： flink 大数据
于 2024-03-30 11:58:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78959404/article/details/137169228
版权

前言：

        结合上个水位线知识点做出的题目案例给予以下代码作为参考。

例题：

1.创建Flink流处理环境。

//创建流环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();


env.execute();

2.从“access.txt”文件中获取数据源。

        资源中查询数据源

3.从中过滤出包含有page字段的数据。

//过滤数据，转换数据
        SingleOutputStreamOperator<UserEvent> stream1 = stream.filter(new FilterFunction<String>() {
            @Override
            public boolean filter(String value) throws Exception {
                //value是一个json字符串
                JSONObject jsonObject = JSONObject.parseObject(value);
                JSONObject page = jsonObject.getJSONObject("page");
                JSONObject common = jsonObject.getJSONObject("common");
                //只保留page和common不为空数据
                return page != null && common != null;
            }
        }).map(new MapFunction<String, UserEvent>() {
            @Override
            public UserEvent map(String value) throws Exception {
                //value是一个JSON字符串
                JSONObject jsonObject = JSONObject.parseObject(value);
                //先取uid
                String uid = jsonObject.getJSONObject("common").getString("uid");
                //再取page_id
                String pageId = jsonObject.getJSONObject("page").getString("page_id");
                //取ts
                Long ts = jsonObject.getLong("ts");
                return new UserEvent(uid, pageId, ts);
            }
        });

4.设置时间戳及单调递增水位线。

SingleOutputStreamOperator<UserEvent> stream2 = stream1.assignTimestampsAndWatermarks(
                WatermarkStrategy.<UserEvent>forMonotonousTimestamps()
                        .withTimestampAssigner((event, ts) -> event.getTs())
        );

5.统计每十秒钟的用户访客量pv，以及窗口开始时间和结束时间，并输出至控制台。

SingleOutputStreamOperator<Tuple3<String, String, Long>> stream1001 = stream2.windowAll(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(new ProcessAllWindowFunction<UserEvent, Tuple3<String, String, Long>, TimeWindow>() {
                    /**
                     *
                     * @param context 上下文对象 -- 拿到窗口信息
                     * @param iterable 10秒钟累积的数据
                     * @param collector 采集器
                     * @throws Exception
                     */
                    @Override
                    public void process(Context context, Iterable<UserEvent> iterable, Collector<Tuple3<String, String, Long>> collector) throws Exception {
                        TimeWindow window = context.window();//窗口对象
                        long start = window.getStart();//窗口开始时间戳
                        long end = window.getEnd();//窗口结束时间戳
                        long pv = 0L;
                        for (UserEvent event : iterable) {
                            pv++;//统计页面浏览量
                        }
                        //格式话成字符串输出
                        String strStart = DateFormatUtils.format(start, "yyyy-MM-dd HH:mm:ss");
                        String strEnd = DateFormatUtils.format(end, "yyyy-MM-dd HH:mm:ss");
                        //采集器输出
                        collector.collect(Tuple3.of(strStart, strEnd, pv));
                    }
                });
        stream1001.print();

6.统计每十秒钟的独立用户访客量uv，以及窗口开始时间和结束时间，并输出至控制台。

SingleOutputStreamOperator<Tuple3<String, String, Long>> stream1002 = stream2.keyBy(value -> value.getUid()).window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(new ProcessWindowFunction<UserEvent, Tuple3<String, String, Long>, String, TimeWindow>() {
                    /**
                     *
                     * @param s 键名（组名）
                     * @param context
                     * @param iterable
                     * @param collector
                     * @throws Exception
                     */
                    @Override
                    public void process(String s, Context context, Iterable<UserEvent> iterable, Collector<Tuple3<String, String, Long>> collector) throws Exception {
                        TimeWindow window = context.window();//窗口对象
                        long start = window.getStart();//窗口开始时间戳
                        long end = window.getEnd();//窗口结束时间戳
                        long uv = 1;
                        //格式话成字符串输出
                        String strStart = DateFormatUtils.format(start, "yyyy-MM-dd HH:mm:ss");
                        String strEnd = DateFormatUtils.format(end, "yyyy-MM-dd HH:mm:ss");
                        //采集器输出三元组
                        collector.collect(Tuple3.of(strStart, strEnd, 1L));
                    }
                }).keyBy(value -> value.f0).sum(2);
        stream1002.print();

7.根据窗口开始和结束时间，使用join或者union将pv，uv数据进行汇总。

stream1001.join(stream1002)
                .where(value1 -> value1.f0)
                .equalTo(value2 -> value2.f0)
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .apply(new JoinFunction<Tuple3<String, String, Long>, Tuple3<String, String, Long>, String>() {
                    @Override
                    public String join(Tuple3<String, String, Long> first, Tuple3<String, String, Long> second) throws Exception {
                        return "开始时间："+first.f0+"结束时间："+first.f1+"，PV="+first.f2+",UV="+second.f2;
                    }
                }).print();

 8.统计每十秒钟较前十秒PV的变化，如果增加则输出正数，减少则输出负数

//另外编写一个方法 调用即可
public static class pvSumFunction extends ProcessAllWindowFunction<UserEvent, String, TimeWindow>{

        private transient ValueState<Long> lastPvValueState;
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);

            //定义描述器对象
            ValueStateDescriptor<Long> descriptor = new ValueStateDescriptor<Long>(
                    "lastPv", // the state name
//                    TypeInformation.of(new TypeHint<Long>() {}), // 描述类型
                    Types.LONG

            );
            //在这里初始化状态对象
            lastPvValueState = getRuntimeContext().getState(descriptor);
        }

        //处理函数
        @Override
        public void process(Context context, Iterable<UserEvent> iterable, Collector<String> collector) throws Exception {
            //统计当前窗口的pv
            Long pv = 0L;
            for (UserEvent event : iterable) {
                pv++;
            }
            //上一个窗口的pv
            Long lastPv = 0L;
            Long value = lastPvValueState.value();
            if (value!=null){
                lastPv = value;
            }
            //差值
            long chaZhi = pv - lastPv;
            //把当前窗口的pv写回去
            lastPvValueState.update(pv);
            //输出结果（开始时间，结束时间）
            String start = DateFormatUtils.format(context.window().getStart(), "yyyy-MM-dd HH:mm:ss");
            String ebd = DateFormatUtils.format(context.window().getEnd(), "yyyy-MM-dd HH:mm:ss");
            collector.collect("["+start+"-->"+ebd+")的pv是："+pv+"-->与上一个10秒的差值是"+chaZhi);
        }
    }

9.统计每个十秒pv的前三值

public static class pvTopNFunction extends ProcessAllWindowFunction<UserEvent, String, TimeWindow>{

        //所有窗口的pv值都存里面
        private transient MapState<Long,Long> pvMapState;
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            //初始化
            pvMapState = getRuntimeContext().getMapState(new MapStateDescriptor<Long, Long>(
                    "pvMapState",
                    Types.LONG,
                    Types.LONG
            ));
        }

        @Override
        public void process(Context context, Iterable<UserEvent> iterable, Collector<String> collector) throws Exception {
            //map是通过键来存取的
            //拿到窗口开始的时间戳
            long start = context.window().getStart();

            //计算本窗口的pv
            Long pv=0L;
            for (UserEvent event : iterable) {
                pv++;
            }
            //获取pvMapState里面的值
            pvMapState.put(start,pv);

            //排序并且获取Top3
            Iterable<Map.Entry<Long, Long>> entries = pvMapState.entries();//取出map的键值对
            //定义一个Map
            Map<Long,Long>pvMap=new HashMap<>();

            for (Map.Entry<Long, Long> entry : entries) {
                pvMap.put(entry.getKey(),entry.getValue());
            }
            //排序(用的是Java里面的stream Api)
            List<Map.Entry<Long, Long>> top3 = pvMap.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))//comparingByValue按值排序，reverseOrder降序排序
                    .limit(3)//取前3条
                    .collect(Collectors.toList());//采集

            //转换为字符串输出
            String rs="前三名是：\n";
            for (Map.Entry<Long, Long> longLongEntry : top3) {
                Long startMilli=longLongEntry.getKey();
                String strStart = DateFormatUtils.format(startMilli, "yyyy-MM-dd HH:mm:ss");
                rs+="开始时间是："+strStart+",pv是："+longLongEntry.getValue()+"\n";
            }
            collector.collect(rs);
        }

    }

代码总结：

public class UvPvDemo1 {
    public static void main(String[] args) throws Exception {
        //创建流环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //设置平行度
        env.setParallelism(5);
        //把处理方式设置为批处理模式
//        env.setRuntimeMode(RuntimeExecutionMode.BATCH);
        //读取文件
        DataStreamSource<String> stream = env.readTextFile("D:\\workidea\\Flink1001\\input\\access.txt");
        //过滤数据，转换数据
        SingleOutputStreamOperator<UserEvent> stream1 = stream.filter(new FilterFunction<String>() {
            @Override
            public boolean filter(String value) throws Exception {
                //value是一个json字符串
                JSONObject jsonObject = JSONObject.parseObject(value);
                JSONObject page = jsonObject.getJSONObject("page");
                JSONObject common = jsonObject.getJSONObject("common");
                //只保留page和common不为空数据
                return page != null && common != null;
            }
        }).map(new MapFunction<String, UserEvent>() {
            @Override
            public UserEvent map(String value) throws Exception {
                //value是一个JSON字符串
                JSONObject jsonObject = JSONObject.parseObject(value);
                //先取uid
                String uid = jsonObject.getJSONObject("common").getString("uid");
                //再取page_id
                String pageId = jsonObject.getJSONObject("page").getString("page_id");
                //取ts
                Long ts = jsonObject.getLong("ts");
                return new UserEvent(uid, pageId, ts);
            }
        });

        //设置水位线策略
        SingleOutputStreamOperator<UserEvent> stream2 = stream1.assignTimestampsAndWatermarks(
                WatermarkStrategy.<UserEvent>forMonotonousTimestamps()
                        .withTimestampAssigner((event, ts) -> event.getTs())
        );

        //开窗(统计每十秒钟的用户访客量pv，以及窗口开始时间和结束时间，并输出至控制台)
        SingleOutputStreamOperator<Tuple3<String, String, Long>> stream1001 = stream2.windowAll(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(new ProcessAllWindowFunction<UserEvent, Tuple3<String, String, Long>, TimeWindow>() {
                    /**
                     *
                     * @param context 上下文对象 -- 拿到窗口信息
                     * @param iterable 10秒钟累积的数据
                     * @param collector 采集器
                     * @throws Exception
                     */
                    @Override
                    public void process(Context context, Iterable<UserEvent> iterable, Collector<Tuple3<String, String, Long>> collector) throws Exception {
                        TimeWindow window = context.window();//窗口对象
                        long start = window.getStart();//窗口开始时间戳
                        long end = window.getEnd();//窗口结束时间戳
                        long pv = 0L;
                        for (UserEvent event : iterable) {
                            pv++;//统计页面浏览量
                        }
                        //格式话成字符串输出
                        String strStart = DateFormatUtils.format(start, "yyyy-MM-dd HH:mm:ss");
                        String strEnd = DateFormatUtils.format(end, "yyyy-MM-dd HH:mm:ss");
                        //采集器输出
                        collector.collect(Tuple3.of(strStart, strEnd, pv));
                    }
                });
//        stream1001.print();

        //(开始时间，结束数据，1)-》分组聚合(开始时间，结束时间，uv总和)
        //（统计每十秒钟的独立用户访客量uv，以及窗口开始时间和结束时间，并输出至控制台）
        SingleOutputStreamOperator<Tuple3<String, String, Long>> stream1002 = stream2.keyBy(value -> value.getUid()).window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .process(new ProcessWindowFunction<UserEvent, Tuple3<String, String, Long>, String, TimeWindow>() {
                    /**
                     *
                     * @param s 键名（组名）
                     * @param context
                     * @param iterable
                     * @param collector
                     * @throws Exception
                     */
                    @Override
                    public void process(String s, Context context, Iterable<UserEvent> iterable, Collector<Tuple3<String, String, Long>> collector) throws Exception {
                        TimeWindow window = context.window();//窗口对象
                        long start = window.getStart();//窗口开始时间戳
                        long end = window.getEnd();//窗口结束时间戳
                        long uv = 1;
                        //格式话成字符串输出
                        String strStart = DateFormatUtils.format(start, "yyyy-MM-dd HH:mm:ss");
                        String strEnd = DateFormatUtils.format(end, "yyyy-MM-dd HH:mm:ss");
                        //采集器输出三元组
                        collector.collect(Tuple3.of(strStart, strEnd, 1L));
                    }
                }).keyBy(value -> value.f0).sum(2);
//        stream1002.print();
//
        //（根据窗口开始和结束时间，使用join或者union将pv，uv数据进行汇总）
        stream1001.join(stream1002)
                .where(value1 -> value1.f0)
                .equalTo(value2 -> value2.f0)
                .window(TumblingEventTimeWindows.of(Time.seconds(10)))
                .apply(new JoinFunction<Tuple3<String, String, Long>, Tuple3<String, String, Long>, String>() {
                    @Override
                    public String join(Tuple3<String, String, Long> first, Tuple3<String, String, Long> second) throws Exception {
                        return "开始时间："+first.f0+"结束时间："+first.f1+"，PV="+first.f2+",UV="+second.f2;
                    }
                }).print();



        env.execute();
    }
}
public class UvPvDemo2 {
    public static void main(String[] args) throws Exception {
        //创建流环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //设置平行度
        env.setParallelism(1);
        //把处理方式设置为批处理模式
        env.setRuntimeMode(RuntimeExecutionMode.BATCH);
        //读取文件
        DataStreamSource<String> stream = env.readTextFile("D:\\workidea\\Flink1001\\input\\access.txt");
        //过滤数据，转换数据
        SingleOutputStreamOperator<UserEvent> stream1 = stream.filter(new FilterFunction<String>() {
            @Override
            public boolean filter(String value) throws Exception {
                //value是一个json字符串
                JSONObject jsonObject = JSONObject.parseObject(value);
                JSONObject page = jsonObject.getJSONObject("page");
                JSONObject common = jsonObject.getJSONObject("common");
                //只保留page和common不为空数据
                return page != null && common != null;
            }
        }).map(new MapFunction<String, UserEvent>() {
            @Override
            public UserEvent map(String value) throws Exception {
                //value是一个JSON字符串
                JSONObject jsonObject = JSONObject.parseObject(value);
                //先取uid
                String uid = jsonObject.getJSONObject("common").getString("uid");
                //再取page_id
                String pageId = jsonObject.getJSONObject("page").getString("page_id");
                //取ts
                Long ts = jsonObject.getLong("ts");
                return new UserEvent(uid, pageId, ts);
            }
        });

        //设置水位线策略
        SingleOutputStreamOperator<UserEvent> stream2 = stream1.assignTimestampsAndWatermarks(
                WatermarkStrategy.<UserEvent>forMonotonousTimestamps()
                        .withTimestampAssigner((event, ts) -> event.getTs())
        );

        //统计每十秒钟较前十秒PV的变化，如果增加则输出正数，减少则输出负数
        stream2
                //滚动窗口
                .windowAll(TumblingEventTimeWindows.of(Time.seconds(10)))
                //滑动窗口
//                .windowAll(SlidingEventTimeWindows.of(Time.seconds(10),Time.seconds(5)))
                //会话窗口，需要指定会话中断间隔时间
//                .windowAll(EventTimeSessionWindows.withGap(Time.seconds(3)))
                .process(new pvTopNFunction()).print();

//        stream2.print();


        env.execute();
    }

    public static class pvSumFunction extends ProcessAllWindowFunction<UserEvent, String, TimeWindow>{

        private transient ValueState<Long> lastPvValueState;
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);

            //定义描述器对象
            ValueStateDescriptor<Long> descriptor = new ValueStateDescriptor<Long>(
                    "lastPv", // the state name
//                    TypeInformation.of(new TypeHint<Long>() {}), // 描述类型
                    Types.LONG

            );
            //在这里初始化状态对象
            lastPvValueState = getRuntimeContext().getState(descriptor);
        }

        //处理函数
        @Override
        public void process(Context context, Iterable<UserEvent> iterable, Collector<String> collector) throws Exception {
            //统计当前窗口的pv
            Long pv = 0L;
            for (UserEvent event : iterable) {
                pv++;
            }
            //上一个窗口的pv
            Long lastPv = 0L;
            Long value = lastPvValueState.value();
            if (value!=null){
                lastPv = value;
            }
            //差值
            long chaZhi = pv - lastPv;
            //把当前窗口的pv写回去
            lastPvValueState.update(pv);
            //输出结果（开始时间，结束时间）
            String start = DateFormatUtils.format(context.window().getStart(), "yyyy-MM-dd HH:mm:ss");
            String ebd = DateFormatUtils.format(context.window().getEnd(), "yyyy-MM-dd HH:mm:ss");
            collector.collect("["+start+"-->"+ebd+")的pv是："+pv+"-->与上一个10秒的差值是"+chaZhi);
        }
    }

    public static class pvTopNFunction extends ProcessAllWindowFunction<UserEvent, String, TimeWindow>{

        //所有窗口的pv值都存里面
        private transient MapState<Long,Long> pvMapState;
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            //初始化
            pvMapState = getRuntimeContext().getMapState(new MapStateDescriptor<Long, Long>(
                    "pvMapState",
                    Types.LONG,
                    Types.LONG
            ));
        }

        @Override
        public void process(Context context, Iterable<UserEvent> iterable, Collector<String> collector) throws Exception {
            //map是通过键来存取的
            //拿到窗口开始的时间戳
            long start = context.window().getStart();

            //计算本窗口的pv
            Long pv=0L;
            for (UserEvent event : iterable) {
                pv++;
            }
            //获取pvMapState里面的值
            pvMapState.put(start,pv);

            //排序并且获取Top3
            Iterable<Map.Entry<Long, Long>> entries = pvMapState.entries();//取出map的键值对
            //定义一个Map
            Map<Long,Long>pvMap=new HashMap<>();

            for (Map.Entry<Long, Long> entry : entries) {
                pvMap.put(entry.getKey(),entry.getValue());
            }
            //排序(用的是Java里面的stream Api)
            List<Map.Entry<Long, Long>> top3 = pvMap.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))//comparingByValue按值排序，reverseOrder降序排序
                    .limit(3)//取前3条
                    .collect(Collectors.toList());//采集

            //转换为字符串输出
            String rs="前三名是：\n";
            for (Map.Entry<Long, Long> longLongEntry : top3) {
                Long startMilli=longLongEntry.getKey();
                String strStart = DateFormatUtils.format(startMilli, "yyyy-MM-dd HH:mm:ss");
                rs+="开始时间是："+strStart+",pv是："+longLongEntry.getValue()+"\n";
            }
            collector.collect(rs);
        }

    }
}

Aaa～茹
关注
  • 15
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
flink水位线案例 中的数据源
03-30
数据源
Flink面试题（二）
luo981695830的博客
07-04 704
flink面试题
刷题记录｜牛客网-SQL篇-SQL进阶挑战（46题）
长行
10-03 182
题目表述不清：“当月均完成试卷数” 是指 “完成试卷的总数” / “完成过试卷的月份数”补充题目要求：以有 submit_time 字段作为活跃判断标准。在实现中，输出这两个中的任意一个列名均可通过。在判题时，包含题目要求中不存在的条件：按。在判题时，包含题目要求中不存在的条件：按。题目样例中，未完成率。
64道企业真实Flink题目让你无惧Flink面试（带答案）
热门推荐
百看不如一RUN
02-18 1万+
1、Flink如何保证精确一次性消费 Flink 保证精确一次性消费主要依赖于两种Flink机制 1、Checkpoint机制 2、二阶段提交机制 Checkpoint机制 主要是当Flink开启Checkpoint的时候，会往Source端插入一条barrir，然后这个barrir随着数据流向一直流动，当流入到一个算子的时候，这个算子就开始制作checkpoint，制作的是从barrir来到之前的时候当前算子的状态，将状态写入状态后端当中。然后将barrir往下流动，当流动到keyby 或者shuffle
最全面的flink入门编程案例
09-18
【标题】：“最全面的Flink入门编程案例” 在大数据处理领域，Apache Flink是一个流行的开源流处理框架，它提供了一种低延迟、高吞吐量的数据处理能力，支持批处理和流处理两种模式。本篇文章将深入浅出地引导初学...
flink学习资料案例记录
07-25
flink学习资料案例记录
flink实践案例
12-20
本文档总结了国内各个互联网巨头使用flink的案例，有美团，唯品会，滴滴，360等，如何实现对flink的各种应用，同时里面也包含对flink使用的总结。
Flink流处理之迭代案例
01-27
当前Flink将迭代的重心集中在批处理上，之前我们谈及了批量迭代和增量迭代主要是针对批处理（DataSet）API而言的，并且Flink为批处理中的迭代提供了针对性的优化。但是对于流处理（DataStream），Flink同样提供了对...
Flink入门案例程序（中华石杉的课堂代码）
04-12
**Flink入门案例程序概述** 本教程主要针对的是Apache Flink初学者，通过中华石杉提供的课堂代码，我们将深入理解Flink的核心概念和技术。Apache Flink是一个开源的流处理和批处理框架，它以强大的实时数据处理能力...
flink中的时间语义和水位线及迟到处理
03-30
Flink 中的窗口（窗口的作用，窗口的分类，Windows API，窗口函数）和时间语义（时间语义，水位线，使用步骤）以迟到数据处理（推迟水位线推进，设置窗口延迟关闭，使用测流接受迟到的数据）基于时间的合流-双流联结...
Flink行业案例.pdf
02-17
Flink行业案例.pdf
Flink案例实战.pdf
11-13
Flink案例实战.pdf Flink是一种流处理引擎，能够实时处理大规模的数据流。下面是Flink案例实战中的知识点： 1. 流处理的需求：在传统业务中，经常需要对数据进行分类汇总统计，这类业务的开发通常基于关系型数据库...
flink学习教程，flink学习案例
05-15
标题"flink学习教程，flink学习案例"表明这是一个关于Apache Flink的学习资源集合，可能包含教程文档和实践案例，旨在帮助用户深入理解并掌握Flink这一大数据处理框架。 描述同样强调了是"flink学习教程"和"flink...
Flink State体系剖析以及案例实践
01-13
Flink State体系剖析以及案例实践，State按照是否有Key划分KeyedState和OperatorState两种。按照数据结构不同，flink定义了多种state，分别应用于不同的场景，具体实现如下：ValueState、ListState、MapState、...
Apache Flink 行业案例集.pdf
09-26
以下是一些具体的行业案例，展示了 Flink 如何在各个领域发挥其优势。 在移动媒体领域，Bigo 直播利用 Flink 构建了流批一体的生产应用，优化了实时计算平台的建设，提高了效率。网易游戏基于 Flink 的流式 ETL...
Flink案例源码和数据集.rar
10-27
本资源“Flink案例源码和数据集.rar”提供了丰富的学习材料，包括实际操作的源代码以及配套的数据集，帮助我们深入理解Flink的工作原理和实践应用。 一、Flink核心概念与特性 Flink的核心概念主要包括流（Stream）...
flink CDC监控PG数据库的demo案例
最新发布
04-19
标题 "flink CDC监控PG数据库的demo案例" 涉及到的是使用Apache Flink的Change Data Capture (CDC)功能来实时监控PostgreSQL (PG)数据库的变化。Flink CDC允许我们近乎实时地捕获数据库中的插入、更新和删除操作，...
Apache Flink 案例集（2022版）.pdf
01-25
Apache Flink 案例集（2022 版） Apache Flink 作为流处理领域的领军角色和事实标准，已经逐步演进为流计算核心能力的领军角色。在数据集成方面，Apache Flink 提供了 Flink CDC 组件，使用 CDC 技术从各种数据库中...
flink 水位线 的作用
06-07
Flink 水位线（Watermark）是一种机制，用于协调有界和无界数据流处理的时间特性。它是在分布式流处理环境中实现事件时间（Event Time）语义的关键组件。水位线是一种时间戳（Timestamp）的度量，用于表示数据流中的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值