Flink 基础学习(四)转换 Transformation

这是 Java 极客技术的第  257  篇原创文章

1 前言

前面写了如何使用 Flink 读取常用的数据源，也简单介绍了如何进行自定义扩展数据源，本篇介绍它的下一步：数据转换 Transformation，其中数据处理用到的函数，叫做算子 Operator，下面是算子的官方介绍。

算子将一个或多个 DataStream 转换为新的 DataStream。程序可以将多种转换组合成复杂的数据流拓扑。

在学习过程中，官网是个不错的入门介绍，格式如下：

一共有两列，左边介绍了函数名称，转换前的流类型，以及转换后的流类型，右边进行了方法描述，介绍该算子的概念和作用，然后有个代码段，告诉了如何使用它。

但官网的中文介绍不多，有些例子 demo 也有点不完善，所以接下来我会将自己理解笔记贴下来，跟大家一起来学习。

友情提示，贴出来的代码段可能不完整，可以下载 github 上的代码进行参考。

2 转换 Transformation

2.1 Map，DataStream ---> DataStream

映射转换。输入是一个 DataStream，输出也是一个 DataStream，属于一对一操作，例如输入是 [1, 3, 5]，然后每个数乘以 2，可以通过下面形式实现：

dataStream.map((MapFuction) ) value -> value * 2;);

将会输出 [2, 6, 10]，也有可能不是如上顺序，默认按照程序处理数据的时间进行输出。

后面如果大家发现执行顺序与我展示的不一致，请不用担心，属于正常现象，由于顺序性问题涉及到时间和窗口属性的作用，所以请各位先按照默认情况运行，理解算子的概念和使用，之后再去了解上述概念。

2.2 FlatMap，DataStream ---> DataStream

"平坦"映射（不知道该如何翻译囧）。 不同于上面的单个操作，这是一对多操作，取一个元素并产生零个，一个或多个元素。例如拆分一行字符串，然后输出多个单词：

SingleOutputStreamOperator operator = source.flatMap(new FlatMapFunction() {
    @Override
    public void flatMap(String value, Collector out) throws Exception {
        String[] tokens = parseString2Tokens(value);
        if (tokens == null) {
            return;
        }
        for (String token : tokens) {
            out.collect(token);
        }
    }
});

输出多个元素的关键是 Collector 这个参数，通过它可以收集到更多元素。

2.3 Filter，DataStream ---> DataStream

过滤操作。通过一个 boolean function 对元素进行过滤，保留为 true 的元素，从而达到过滤的目的。例如下面过滤操作，保留 id 是偶数的元素：

SingleOutputStreamOperator operator = source.filter((FilterFunction) value -> {
    Student stu = parseTokens2Object(parseString2Tokens(value));
    return stu != null && stu.getId() % 2 == 0;
});

2.4 KeyBy，DataStream ---> KeyedStream

按键 key 进行分类。KeyBy 通过 Hash partitioning 方法将一个 stream 变成一组不相交的分区 partitions，每个 partitions 包含的元素具有相同的 key。例如输入的是一组字符串，根据第一个字段的整数值进行分类：

KeyedStream keyedStream = source.keyBy((KeySelector) value -> {
    String[] tokens = parseString2Tokens(value);
    return tokens == null ? 0 : Integer.valueOf(tokens[0]);
});

注意，KeyBy 操作后，流类型从 DataStream 变成了 keyedStream，是一组 partitions。

上面介绍的是通用类型的 keySelector 分类方法，也可以通过下述两种方法进行分区：

keyedStream.keyBy(0); // key 是 tuple 中的第一个元素
keyedStream.keyBy("id"); //  key 是 pojo 中的 id 字段，实现了 getter、setter

2.5 Reduce，KeyedStream ---> DataStream

对按 key 分类的数据流进行"滚动"压缩。可以将当前元素与前一个元素进行整合处理，并返回一个新值。

例如下面例子，通过 id 字段进行分类，然后使用 reduce 进行压缩处理，每次将学生的名字字段进行拼接，年龄进行相加，返回一个新的对象：

SingleOutputStreamOperator operator = source
    .map((MapFunction) value -> parseTokens2Object(parseString2Tokens(value)))
    .keyBy((KeySelector) value ->  value == null ? 0 : value.getId())
    .reduce((ReduceFunction) (value1, value2) -> {
        Student student = new Student();
        student.setId(value1.getId() + value2.getId());
        student.setName(value1.getName() + " || " + value2.getName());
        student.setAge(value1.getAge() + value2.getAge());
        return student;
    });

输出结果如下：

16> Student(id=2, name=name2, age=22)
11> Student(id=1, name=name1, age=21)
15> Student(id=3, name=name13, age=28)
16> Student(id=5, name=name10, age=25)
16> Student(id=10, name=name10 || name15, age=55)
16> Student(id=4, name=name2 || name7, age=44)
16> Student(id=6, name=name2 || name7 || name12, age=71)
...
16> Student(id=15, name=name10 || name15 || name5, age=80)
1> Student(id=12, name=name4 || name9 || name14, age=77)
11> Student(id=3, name=name1 || name6 || name11, age=68)

从结果可以看到，id 相同的都分到同一个分区（测试中可以简单通过前面的线程 id 确认，属于同一分区处理），然后传入新对象，按照 reduce 的操作进行了处理，返回了拼装之后的对象。

2.6 Fold，KeyedStream ---> DataStream

滚动折叠。合并当前元素和上一个被折叠的值，输入值可以与返回值类型不一样。

例如数据流是一组数字 [1, 5, 7]，想要输出一个拼接后的字符串，可以通过下面进行处理：

// 标准格式
keyedStream.fold(${initialValue}, (s1, s2) -> s1 + " || " + s2);

SingleOutputStreamOperator operator = source
    .map((MapFunction) value -> parseTokens2Object(parseString2Tokens(value)))
    .keyBy("id")
    .fold("strat", new FoldFunction() {
        @Override
        public String fold(String accumulator, Student value) throws Exception {
            return accumulator + " || " + value;
        }
    });

上述例子的 ${initialValue} 初始值是 start，然后在方法中通过 || 分隔符进行拼接，最后输出结果是：

16> strat || Student(id=2, name=name2, age=22)
11> strat || Student(id=1, name=name1, age=21)
15> strat || Student(id=3, name=name13, age=28)
16> strat || Student(id=2, name=name2, age=22) || Student(id=2, name=name12, age=27)
1> strat || Student(id=4, name=name9, age=24)
11> strat || Student(id=1, name=name1, age=21) || Student(id=1, name=name6, age=21)
1> strat || Student(id=4, name=name9, age=24) || Student(id=4, name=name14, age=29)
16> strat || Student(id=2, name=name2, age=22) || Student(id=2, name=name12, age=27) || Student(id=2, name=name7, age=22)
...

从输出结果可以看到，初始值和每次处理的对象进行了拼接，最后返回的是折叠后的对象，不过该方法被标注为 @Deprecated，不建议继续使用。

2.7 Aggregations，KeyedStream ---> DataStream

在按 key 分类的数据流上滚动聚合。要注意的是  min 和 minBy 之间的区别是 min 返回指定字段的最小值，而 minBy 返回在此字段中具有最小值的元素，也可以理解成整个对象（max 和 maxBy 的机制相同）

常用的 sum 合计函数就不多说了，下面具体展示的 min 和 minBy 函数，取当前流中的最小值：

测试代码的逻辑是：从一个文本流中读取数据，转换成对象，接着根据 id 进行 keyBy 分类，接着从每组分区 partitions 中取出年龄 age 字段最小的，我们来分别测试 min 和 minBy 的不同之处：

2.7.1. 测试文件

# id, name, age, address (代替 index 下标)
...
1 name10 21 j
1 name9 20 k
1 name8 21 l
1 name7 21 m
...
1 name2 21 r
1 name1 10 s

为了便于从小样本中观察的具体的区别，id 字段都设成 1，它们将会分组到同一个 partitions，然后 age 字段有三种值（21、20 和 10），每次处理一个元素时，都会输出一个最小值

2.7.2. 测试代码

SingleOutputStreamOperator operator = source
    .map((MapFunction) value -> {
         parseTokens2Object(parseString2Tokens(value)); }
    )
    .keyBy("id")
    // 这里表示选择使用 minBy 或者 min 函数
    .minBy("age")/min("age");

2.7.3. 查看结果

左图是 minBy，右图是 min 输出结果，从结果可以看出，minBy 返回多个值的意思是：返回元素的完整对象，而 min 返回的是字段的最小值，其它字段将不会修改。于是左边能看到不同的 age 对应的下标 address 是不同的，而右边不同的 age，对应的还是第一次输出的 address 结果。

综上所述，如果使用聚合函数 minBy 和 min（以及 max），注意自己需要返回的类型，是否需要一个完整的对象，如果是的话，请选择使用 minBy。

2.8 Window，KeyedStream ---> WindowedStream

窗口。该函数允许在已分区的 KeyedStream 上定义窗口。例如最近 5 秒内到达的数据：

dataStream.keyBy(0).window(TumblingEventTimeWindows.of(Time.seconds(5)));

2.9 WindowAll，DataStream ---> AllWindowedStream

在 DataStream 上定义窗口。与上面不同的是，此次定义的范围是所有流，windows 会根据某些特征（例如，最近 5 秒内到达的数据）对所有流事件进行划分窗口。

SingleOutputStreamOperator operator = source
                .map((MapFunction) value -> parseTokens2Object(parseString2Tokens(value)))
                .assignTimestampsAndWatermarks(new MyTimestampExtractor())
                .windowAll(TumblingEventTimeWindows.of(Time.milliseconds(1)))
                .apply(new AllWindowFunction(){...};

注意：在许多情况下，这是非并行转换，所有记录都将被收集在 WindowAll 运算符的一项任务中。

2.10 Window Reduce、Apply、Aggregations，WindowedStream ---> DataStream

窗口函数跟前面提到的常用函数一样，也有属于窗口的数据流功能。

例如应用 apply 进行自定义逻辑加工，还有 reduce 进行“压缩”，返回合并后的值、sum 等统计函数。

唯一不同的是，前面常规函数对应的整个流中的数据，而 window 针对是根据特征（例如 5s 时间内）分开的窗口流的数据进行操作。

windowedStream.apply(new WindowFunction<...>{...});
windowedStream.sum(0;
windowedStream.min("key");
windowedStream.maxBy(0);

2.11 Union，DataStream * ---> DataStream

联合。Union 将两个或多个数据流合并，生成一个新的数据流，包含了本身以及参数中数据流的所有数据。

dataStream.union(otherStream1, otherStream2);

如果是一个数据流联合它自己，相当于得到两份同样的数据。

2.12 Window Join， DataStream,DataStream ---> DataStream

窗口连接。通过 key 将同一个 window 的两个数据流 join 起来。

dataStream.join(otherStram)
    .where()
    .equalsTo()
    .window(TumblingEventTimeWindows.of(Time.seconds(3)))
    .apply(new JoinFunction<...>{...});

上面代码的作用是，在 3s 时间内连接两个窗口，连接条件是 where （第一个流）和 equalsTo （第二个流）相同的返回值。

2.13 Window coGroup，DataStream,DataStream ---> DataStream

窗口连接。跟上面的作用一样，通过 key 将同一个 window 的两个数据流连接起来。

dataStream.coGroup(otherStram)
    .where()
    .equalsTo()
    .window(TumblingEventTimeWindows.of(Time.seconds(3)))
    .apply(new CoGroupFunction<...>{...});

可以看到，除了 join 和 coGroup 函数不同外，还有一个 apply 处理使用的参数类型也不一样。

interface JoinFunction<IN1, IN2, OUT> {
    OUT join(IN1 first, IN2 second);
}

interface CoGroupFunction<IN1, IN2, O> {
    void coGroup(Iterable first, Iterable second, Collector out);
}

上面展示的是两个接口，在 join 算子中使用的是 JoinFunction，对应的 join 方法是两个窗口流的单个入参；在 coGroup 算子中，使用的是 CoGroupFunction，对应的 coGroup 方法是两个窗口流的迭代器，可以进行更多数据处理。

在参考资料四种详细介绍了两个的区别，如有连接操作，为了更多扩展性，推荐使用的是 CoGroup 算子。

2.14 Connect，DataStream,DataStream ---> ConnectedStreams

数据流连接。“连接”两个保存其类型的数据流，该连接允许两个流之间的共享状态。

例如下面连接了两个数据流，将会转换成 ConnectedStram 类型，接着使用 CoFlatMapFunction 分别对合并流中两种类型数据流进行处理（也可以自定义一个 MyCoFlatMapFunction 类，继承自 RichCoFlatMapFunction），在里面实现自己的逻辑

ConnectedStreams connectedStreams = source.connect(studentDataStreamSource);
connectedStreams.flatMap(new CoFlatMapFunction() {
    @Override
    public void flatMap1(String value, Collector