决战 Flink 高频考点，万字超全攻略，让你面试无压力！

2023-11-17 13:31:35

大数据时代，Flink 以其强大的流处理能力和高度一致性的状态管理机制，成为炙手可热的技能。想要在 Flink 的面试中拔得头筹，对高频考点的掌握必不可少。本文汇集了万字超全的 Flink 高频考点，助你轻松应对面试挑战，自信展现专业能力。

选择题

1. 以下哪个不是 Dataset 的转换算子？

A. readTextFile
B. reduce distinct
D. rebalance
A

2. 关于状态，以下说法错误的是？

A. 状态可以存储在内存或外部存储中
B. 只有 keyed stream 才能使用状态
C. 状态可以用于实现累加、求平均值等操作
B

简答题

1. Flink 的流处理机制与批处理机制有何区别？

流处理：

处理数据流，以无限流的形式输入
持续计算并更新结果，无需等待所有数据到达
注重实时性和延迟性

批处理：

处理有限数据集，一次性输入所有数据
计算完成后才输出结果
注重准确性和完整性

2. 解释 Flink 中窗口操作的作用和分类。

窗口操作的作用：

将连续数据流分组为有限大小的窗口
在每个窗口内对数据进行聚合或转换

窗口分类：

滑动窗口： 数据流不断进入窗口，窗口向前滑动
滚动窗口： 窗口随着数据流定期创建和销毁
会话窗口： 基于事件的时间间隔或空闲时间，将相关事件分组

算法题

1. 使用 Flink 实现一个 WordCount 程序。

import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.operators.AggregateOperator;
import org.apache.flink.api.java.operators.DataSource;
import org.apache.flink.api.java.tuple.Tuple2;

public class WordCount {

    public static void main(String[] args) throws Exception {
        ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

        DataSource<String> data = env.readTextFile("input.txt");

        AggregateOperator<Tuple2<String, Integer>> wordCounts = data
                .flatMap((String line) -> Arrays.stream(line.split(" ")).map(word -> Tuple2.of(word, 1)))
                .groupBy(0)
                .sum(1);

        DataSet<Tuple2<String, Integer>> result = wordCounts.execute();

        for (Tuple2<String, Integer> wc : result.collect()) {
            System.out.println(wc.f0 + " : " + wc.f1);
        }
    }
}

2. 使用 Flink 实现一个滑动窗口，每 5 秒统计一次过去 10 秒的数据。

import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.functions.AggregateFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.streaming.api.windowing.assigners.SlidingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

public class SlidingWindow {

    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<Tuple2<String, Integer>> dataStream = env.addSource(new MySource());

        SingleOutputStreamOperator<Tuple2<String, Integer>> windowCounts = dataStream
                .keyBy(0)
                .window(SlidingTimeWindows.of(Time.seconds(10), Time.seconds(5)))
                .aggregate(new MyAggregateFunction());

        windowCounts.print();
        env.execute();
    }

    public static class MySource implements SourceFunction<Tuple2<String, Integer>> {

        private volatile boolean running = true;

        @Override
        public void run(SourceContext<Tuple2<String, Integer>> ctx) throws Exception {
            int i = 0;
            while (running) {
                ctx.collect(Tuple2.of("word" + i, i));
                i++;
                Thread.sleep(1000);
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    }

    public static class MyAggregateFunction implements AggregateFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple2<String, Integer>> {

        @Override
        public Tuple2<String, Integer> createAccumulator() {
            return Tuple2.of("", 0);
        }

        @Override
        public Tuple2<String, Integer> add(Tuple2<String, Integer> value, Tuple2<String, Integer> accumulator) {
            return Tuple2.of(value.f0, value.f1 + accumulator.f1);
        }

        @Override
        public Tuple2<String, Integer> getResult(Tuple2<String, Integer> accumulator) {
            return accumulator;
        }

        @Override
        public Tuple2<String, Integer> merge(Tuple2<String, Integer> a, Tuple2<String, Integer> b) {
            return Tuple2.of(a.f0, a.f1 + b.f1);
        }
    }
}