Flink 的算子介绍(上)

原创

已于 2024-06-25 10:35:11 修改 · 1.3k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#flink #java #大数据

于 2023-02-24 11:28:53 首次发布

本文详细介绍了Flink中的数据加工操作，包括map、flatMap、filter和process函数，以及分组操作的关键字keyBy。接着讨论了Flink中的聚合操作，如reduce、aggregate和window的应用，展示了如何进行数据的汇总和分组计算。此外，还提到了窗口函数的不同类型及其在处理数据流时的重要性。

数据加工三类重要的操作

所有的数据处理工具，都离不开数据加工，我总结了最最常用的数据加工操作只有下面四种：

转换: (1->N 列转行 , A -> B )，一条一条的处理
分组：group by 相同数据的聚集
聚合: max min sum avg count topN bitMap 中位数统计学上的指标
连接：（合(union all)、交(inner join on condition)、并(union)、补(left join on codition where is null)）集合的运算

转换

Flink 中有那些转化操作呢？就是下面的这些，在 Flink 中这叫做算子。

map ，输入一条数据后，必须输出一条数据，输出入和输出不一定是相同的数据类型。
flatMap：输入一条数据后，可以不输出数据，也可以输出多条数据，是 map 的加强版。
filter：根据判断条件，返回 true or false ,true 的留下，false 不在往下发送。
process：全年选手，可以模拟实现 map、flatMap、filter 三个的逻辑。

下面是代码：


import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.RichFilterFunction;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.util.Collector;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
 * @className: TranslateDataShow
 * @Description:
 * @Author: wangyifei
 * @Date: 2023/2/20 15:37
 */
public class TranslateDataShow {
   
   
    public static void main(String[] args) throws Exception {
   
   
//        showMapUsage();
//        showFlatMapUsage();
        showProcessUsage();
    }

    private static void showProcessUsage() throws Exception {
   
   
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        env.setParallelism(1);
        Collection<String> list = new ArrayList<>();
        list.add("ok,1,2,3,4,5");
        SingleOutputStreamOperator<String> src = env.fromCollection(list);
        src.filter(new RichFilterFunction<String>() {
   
   
            @Override
            public boolean filter(String value) throws Exception {
   
   
                return value.split(",")[0].equals("ok");
            }
        }).process(new ProcessFunction<String, String>() {
   
   
            @Override
            public void processElement(String s, ProcessFunction<String, String>.Context context, Collector<String> collector) throws Exception {
   
   
                // 模拟 flatMap 的功能
                Arrays.stream(s.split("//s*,//s*")).forEach(x->{
   
   
                    collector.collect(x);
                });
                // 模拟 filter 的功能
//                if(s.split("//s*,//s*")[0].equals("ok")){
   
   
//                    collector.collect(s);
//                }
            }
        }).print();
        env.execute();
    }

    private static void showFlatMapUsage() throws Exception {
   
   
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        env.setParallelism(1);
        Collection<String> list = new ArrayList<>();
        list.add("ok,1,2,3,4,5");
        SingleOutputStreamOperator<String> src = env.fromCollection(list);
        src.filter(new RichFilterFunction<String>() {
   
   
            @Override
            public boolean filter(String value) throws Exception {
   
   
                return value.split(",")[0].equals("ok");
            }
        }).flatMap(new FlatMapFunction<String,String>(){
   
   

            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
   
   
                for(String e:value.split(",")){
   
   
                    out.collect(e);
                }
            }
        }).print("------");
        env.execute("test-flatMap");
    }

    private static void showMapUsage() throws Exception {
   
   
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        env.setParallelism(1);
        Collection<String> list = new ArrayList<>();
        list.add("ok,1");
        list.add("ok,2");
        list.add("ok,3");
        list.add("no,4");
        list.add("ok,5");
        SingleOutputStreamOperator<String> src = env.fromCollection(list);
        src.filter(new FilterFunction<String>() {
   
   
            @Override
            public boolean filter(String value) throws Exception {
   
   
                return value.split(",")[0].equals("ok");
            }
        }).map(new MapFunction<String, String>() {
   
   
            @Override
            public String map(String value) throws Exception {
   
   
                return value.split(",")[1];
            }
        }).print("------");
        env.execute("test-dateStream");
    }
}

分组

Flink 分组的函数只有一个 keyBy(KeySelector) 。这里给出一个计算 word count 的例子。


        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(10);
        env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
        env.socketTextStream("127.0.0.1", 6666)
                .flatMap(new RichFlatMapFunctio