flink水位线案例

已于 2024-03-31 12:42:16 修改
阅读量510 收藏 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～茹
关注
专栏目录
通俗易懂理解Flink水位线
SunnyRivers
08-22 336
水位线对于初学者来说可能不是很好理解，网上很多资料讲解的也不是很清楚，这篇博客尽量用最通俗易懂、最简单的案例把它讲解清楚。理解水位线之前，我们先得理解Flink中的时间语义。现在我们可以知道，水位线就代表了当前的事件时间时钟，而且可以在数据的时间戳基础上加一些延迟来保证不丢数据，这一点对于乱序流的正确处理非常重要。水位线是插入到数据流中的一个标记，可以认为是一个特殊的数据水位线主要的内容是一个时间戳，用来表示当前事件时间的进展水位线是基于数据的时间戳生成的。
Flink-SQL 设置水位线（Watermark）和开窗（window）示例
m0_48379126的博客
01-19 5155
代码 import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; import org.apache.flink.table.api.Table; import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
刷题记录｜牛客网-SQL篇-SQL进阶挑战（46题）
长行
10-03 361
题目表述不清：“当月均完成试卷数” 是指 “完成试卷的总数” / “完成过试卷的月份数”补充题目要求：以有 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水位线
2301_78959404的博客
03-29 1111
周期性水位线生成器（Periodic Generator）周期性生成器一般是通过onEvent()观察判断输入的事件，而在onPeriodicEmit()里发出水位线。// 自定义水位线的产生env.print();@Override@Override// 告诉程序数据源里的时间戳是哪一个字段@Override// 延迟时间// 观察到的最大时间戳@Override// 每来一条数据就调用一次// 更新最大时间戳@Override。
聊聊flink水位线
Deepexi_Date的博客
06-21 1244
flink中比较重要的是时间和状态，学习flink的过程中对水位线的理解一直模糊，经过一段时间的消化，在此总结总结。本文主要把水位线是什么，怎么来的，有什么用描述清楚。
【入门Flink】- 09Flink水位线Watermark
打怪升级
11-11 1133
Flink 水位线 和 水位线生成策略
Flink水位线不触发问题
longlovefilm的博客
11-18 4249
窗口计算时遇到好几次水位线不触发的情况，简单总结下。 首先，介绍下Flink的事件时间(EventTime)和水位线(Watermarks)的概念。 一、处理时间 如果要构造一个实时的流式应用，或早或晚都会接触到EventTime这个概念。现实场景中也会遇到消息乱序到达，这里会介绍到为什么需要事件时间和如何去处理乱序到达的数据。 ProcessingTime是Flink系统处理这条消息的时间，EventTime可以理解成是这条消息真实发生的时间。 举个例子，创建一个SlidingWindow，窗口大小
【5】flink窗口与水位线watermark例子
PacosonSWJTU的博客
05-09 1561
【README】 本文总结了flink时间语义和水位线的知识； 【1】时间语义 1）时间分类 Event Time： 事件创建的时间（事件发生时间）； Ingestion Time：数据进入flink的实际； Processing Time：执行算子的本地机器时间 ； 我们主要讨论的是 事件时间； 【2】水位线 ...
flink水位线案例 中的数据源
03-30
数据源
Flink水位线案例：数据源解析与处理
总结来说，这个案例展示了Flink如何处理带有时间戳的数据源，特别是在存在延迟和乱序的情况下，通过水位线机制保证了处理的正确性。对于大数据分析，理解并有效应用水位线是实现高效、准确流处理的关键。
flink 内存配置（一）：设置Flink进程内存
chanyue123的博客
11-04 893
Apache Flink通过严格控制各个组件的内存使用，在JVM之上提供了高效的工作负载。虽然Flink社区努力为所有配置提供合理的默认值，但由于用户部署在Flink上的应用范围很广，这并不总是可行的。为了给用户提供最大的生产价值，Flink支持对集群内的内存分配进行高层和细粒度的调优。下面进一步描述的内存配置适用于1.10版本之后的TaskManager进程和1.11版本之后的JobManager进程。
Caused by: org.apache.flink.api.common.io.ParseException: Row too short:
最新发布
ycsdn10的博客
11-07 120
path为文件地址， fieldDelimiter为分隔符，文件内容是字段|字段的格式，所以fieldDelimiter为|通过flink中的flinkSql直接使用对应的connector去获取csv文件内容，报获取的数据太短了。在获取csv的时候，没有设置分割符，导致整个csv内容识别异常，匹配不上。1.创建的表字段多于csv文件当中的表头。
数据治理项目怎么做，3种推进思路可参考
esensoft123的博客
11-06 549
因此，即使有些人认为先建大数据平台而暂时无法实现业务支撑或应用分析是无效的，但实际上，在建设平台的过程中，企业的能力已经在逐步提升。因此，在做项目时，我们必须与最终用户达成一致，明确项目的定义和规划。先做数据治理顶层设计的规划，确定战略目标，进而拆解KPI，然后设立对应的支撑项目，并且根据优先级别进行排序，最后形成一个执行的路径，即每个阶段要建设的项目及其目标。这种方式的优点显而易见：它确保了项目有明确的规划和方向，从面到线，再到点，逐步落实，从而最大程度地保证了项目的成功，减少了无用功和重复建设。
【零基础小白】 window环境下安装RabbitMQ
许苑向上
11-06 243
RabbitMQ是用编写的，因此在安装RabbitMQ之前，需要先安装Erlang环境。确定Erlang版本：根据具体需求以及安装符合的Erlang版本。本文下载的故而下载Erlang版本之间的，打开系统属性：右键点击“此电脑”或“计算机”图标，选择“属性”，然后点击“高级系统设置”。编辑环境变量：在“系统属性”窗口中，点击“环境变量”按钮。编辑Path变量：同样在“系统变量”区域，找到名为Path的变量并选择它，然后点击“编辑”按钮。
牛客网项目总结
qq_43539664的博客
11-04 284
下面这幅图是牛客网项目的架构图，最下层是Spring Boot，表示我们所有的技术都是基于Spring Boot，上面一层是Spring，Spring上面是Spring MVC、Spring MyBatis 和 Spring Security。数据库访问的问题，通过Spring Security来管理我们项目中的安全层面的这个内容来管理我们项目中的权限，这三个技术都是基于Spring之上的。由Spring进行整合。通过Spring MVC 解决前后端请求交互的问题，通过Spring MyBatis解决。
Kafka-linux环境部署
xiaoyuanbama的博客
11-05 195
Kafka在Linux环境下的安装，以及一点点的kafka实战运维优化经验。
RDD转换算子：【filter】
一个大数据的爱好者
11-04 234
RDD转换算子：filter的用法
高校大数据实训平台介绍
tipdm0301的博客
11-04 426
为满足高校专业教学要求和专业发展需求，泰迪智能科技结合自身技术优势，为院校提供实验室建设服务，充分发挥校企双方资源和技术优势，助力高校培养更多具有创新精神、科研精神及实践能力强的复合型人才。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值