流式计算（四）-Flink Stream API 篇二

话说看图看核心，代码也得看核心。Flink体系十分庞大复杂，没个几十篇文章没法聊完，核心就是最擅长，做的最好，就像说起百度就是搜索，微信就是聊天一样，至于百度核心还是不是搜索已经不那么重要了，但至少聊起Flink，我们得知道，Flink核心是流计算！

环境：Idea2019.03/Gradle6.0.1/JDK11.0.4/Lambda/Flink1.9.1

难度：新手--战士--老兵--大师

目标：

1. Flink流计算核心API应用实战

说明：

为了遇见各种问题，同时保持时效性，我尽量使用最新的软件版本。代码中大量使用注释，理解更轻松。代码地址：其中的day25，https://github.com/xiexiaobiao/dubbo-project.git

步骤：

Flink中将每个转换操作称为算子(Operator)，详细可参考官网API.Doc：以下分别详述：

01 映射

map映射计算比较简单，不做很多解释，map的参数MapFunction属于“Functional Interface”，可直接使用Lambda代替，本例对整数流中每个元素加100：

public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        // list1将不可更新操作
        // List list1 = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        List list = new ArrayList<>(Collections.emptyList());
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        System.out.println("environment.getParallelism >>>> " + environment.getParallelism());
        DataStream dataStream = environment
                .setParallelism(6) // 设置执行环境并行度
                .fromCollection(list);
        System.out.println("dataStream Parallelism is >>>> " + dataStream.getParallelism());
        // lambda表达式实现参数 MapFunction
        dataStream.map(t -> t + 100)
                .setParallelism(6)
                .writeAsText("D:/API/MapTest", FileSystem.WriteMode.OVERWRITE);
         //     .print();  //打印到控制台
        environment.execute();
    }

可通过environment.setParallelism(6) 执行环境全局或 单独的map(t -> t + 100).setParallelism(6) 算子属性设置，获取并行度：

System.out.println("environment.getParallelism >>>> " + environment.getParallelism());
System.out.println("dataStream.getParallelism >>>> " + dataStream.getParallelism());

结果如下，有8个文件，说明并行度为8：

02 扁平映射

这个算子也简单，可类比java Stream的flatmap，注意flatMap函数返回void，其实他将返回值放到Collector中，所以可以容纳元素拆分的不限数量的结果。本例将流中元素(文本行)分割成单词，最终形成一个单词流：

publicclass T2_FlatMapTest {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        List list = Arrays.asList("this is FlatMapTest","by xiaobiao","what a nice day");
        DataStream dataStream = environment.fromCollection(list);
        dataStream.flatMap(flatMapFunction)
                  .writeAsText("D:/API/FlatMap", FileSystem.WriteMode.OVERWRITE);
        environment.execute();
    }

    privatestatic FlatMapFunction flatMapFunction = new FlatMapFunction() {
        @Override
        public void flatMap(String value, Collector out) {
            for(String word: value.split(" ")){
                out.collect(word);
            }
        }
    };
}

结果如下，有8个文件，这个实例中不能自定义setParallelism，为1：

03 过滤

这个operator也简单，不解释，lambda表达式实现filte函数的参数 FilterFunction(T)，本例实现过滤出偶数元素：

public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        // list将不可更新操作
        List list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        DataStream dataStream = environment.fromCollection(list);
        System.out.println("Parallelism is >>>> " + dataStream.getParallelism());
        // lambda表达式实现函数参数 FilterFunction
        dataStream.filter(t -> t % 2 == 0)
                .writeAsText("D:/API/FlatMap", FileSystem.WriteMode.OVERWRITE);
                // print 和 writeAsText都是sink终端类算子，只能有一个，
                //.print();
        environment.execute();
    }

04 键分区

这里比较注意对象比较：DataStreamSource(T) extends SingleOutputStreamOperator(T)，而SingleOutputStreamOperator(T) extends DataStream(T)，SingleOutputStreamOperator 代表在流上定义的一个指定了输出类型的转换(transformation)操作，DataStreamSource表示DataStream的一个开始元素位置。本实例实现按Vehicle的color属性进行流的逻辑分区：

public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        Set vehicleHashSet = new HashSet<>(5);
        // java Stream
        Stream stream = new Producer().getVehicles().limit(5L);
        stream.forEach(vehicleHashSet::add);
        /**
         * 关系比较：
         * DataStreamSource extends SingleOutputStreamOperator
         * SingleOutputStreamOperator extends DataStream
         *
         * The SingleOutputStreamOperator represents a user defined transformation
         * applied on a DataStream with one predefined output type.
         *
         * The DataStreamSource represents the starting point of a DataStream.
         */
        DataStreamSource dataStream = environment.fromCollection(vehicleHashSet);
        // KeyedStream即DataStream上的操作状态按key分区了,即对数据流做分类，注意这是逻辑分区
        KeyedStream keyedStream = dataStream
                .keyBy("color");
        keyedStream.writeAsText("D:/API/KeyBy", FileSystem.WriteMode.OVERWRITE);;
        environment.execute();
    }

注意这个实例中DataStreamSource和keyBy都不能自定义setParallelism，为1，结果如下：

05 归约

本例实现对按color键分区后的流进行weight属性累加，即在每个分区内进行归约计算，注意只有key相同的值才能进行同一个归约：

public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        Set vehicleHashSet = new HashSet<>(5);
        // java Stream
        Stream stream = new Producer().getVehicles().limit(5L);
        stream.forEach(vehicleHashSet::add);
        vehicleHashSet.stream().forEach(System.out::println);
        DataStreamSource dataStream = environment.fromCollection(vehicleHashSet);
        // KeyedStream即DataStream上的操作状态按key分区了,即对数据流做分类，注意这是逻辑分区
        KeyedStream keyedStream = dataStream.keyBy("color");
        DataStream dataStream1 = keyedStream
                .reduce((value1, value2) -> {value1.setWeight(value1.getWeight()+value2.getWeight()); return value1;} );
        dataStream1.print();
        dataStream1.writeAsText("D:/API/Reduce", FileSystem.WriteMode.OVERWRITE);
        environment.execute();
    }

结果如下，多个同区元素，会reduce计算多次：

06 fold operator已经@Deprecated，故删除此部分内容。

07 集合

本例实现按type分区后，找出weight最小的元素，注意keyBy返回类型必须为 KeyedStream：

public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        Set vehicleHashSet = new HashSet<>(5);
        // java Stream
        Stream stream = new Producer().getVehicles().limit(5L);
        stream.forEach(vehicleHashSet::add);
        vehicleHashSet.stream().forEach(System.out::println);
        DataStreamSource dataStream = environment.setParallelism(3).fromCollection(vehicleHashSet);
        System.out.println("environment.getParallelism >>>> " + environment.getParallelism());
        // KeyedStream即DataStream上的操作状态按key分区了,即对数据流做分类，注意这是逻辑分区
        // keyBy返回类型必须为 KeyedStream
        KeyedStream keyedStream = dataStream.keyBy("type");
        System.out.println("dataStream.getParallelism >>>> " + dataStream.getParallelism());
        // 先按type分区记录，再找到plate最小的元素
        DataStream dataStream1 = keyedStream
                // 找到最小的plate值
                // .min("weight");
                .minBy("weight");
        dataStream1.print();
        dataStream1.writeAsText("D:/API/Aggregations", FileSystem.WriteMode.OVERWRITE);
        environment.execute();
    }

结果如下：

 

 

08 Window窗口

 

 

Window是Flink中的核心概念，这里详细描述下。

首先，window窗口每次要框住一组元素，得需有一定的标准吧。比如按元素的时间特征，框住的数量等。元素的时间特征有EventTime/ IngestionTime / ProcessingTime；

• ProcessingTime处理时间戳：这个是最简单的，直接取执行服务器的系统时间，无服务器间和流之间的协调，故延迟最低。但是在分布式异步环境下，因记录到达各服务器的速度差异，会存在不确定性。
• EventTime事件时间：是记录产生时的事件时间戳，在进入Flink前记录就已自带。Flink中可以通过API获取记录的EventTime，在使用EventTime的程序中，必须指定Event Time Watermarks，此时间水印是一种进度标签，表示一个时间点之后不会有再晚的EventTime记录了。EventTime的好处就是能保证记录处理有序，无论接收的顺序，按EventTime处理的窗口，会等待所有满足EventTime条件的记录，直到超时。但缺点就是，这种等待历史或无序记录到达的过程，就有延迟了，所以高实时要求的时候，可选择ProcessingTime。
• IngestionTime进入时间。是记录进入Flink的时间戳，在source节点的operator处理时取source的当前时间。IngestionTime概念上介于EventTime和ProcessingTime之间。IngestionTime的优势是能保证时间戳的稳定性，记录在source处分配IngestionTime后，后续各window都将使用相同的时间戳。相比EventTime，就不能保证无序记录的处理顺序了，但同时也不需要watermark了。在内部使用上，IngestionTime被近似当作EventTime来处理，只是加了时间戳和水印的自动生成。

 

 

其次，有了时间戳后，每个执行环境可先设置运行环境的时间特征处理模式，三选一，缺省为ProcessingTime:

environment.setStreamTimeCharacteristic(TimeCharacteristic.IngestionTime);
environment.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
environment.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

window有多种：一是按时间，有TumblingWindow和SlidingWindows，前者是翻转式，window连续翻动，不跳跃记录，在框内的就是一组，后者是滑动式，按照窗口时间和滑动时间定义，可以跳跃前进。以下为两者示意：

 

 

 

 

二是按数量，类似的，也有翻转和滑动，只是以记录数量为标准。三是自定义，自定义WindowAssigner窗口分配器。因时间和数量窗口最常用，Flink提供了keyedStream.countWindow()和keyedStream.timeWindow()。还有其他session window，global window，此处不述。

最后，是使用window或windowAll对将DataStream转为WindowedStream，再对每个window进行如apply/reduce/fold转换。

完整代码如下：本例使用时间窗口，并使用AssignerWithPunctuatedWatermarks来进行event time timestamps赋值，并生成标识流event time处理进度的低位水印(low watermarks)：

publicclass T8_WindowTest1 {
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment environment = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置运行环境的时间特征，可以三选一，缺省为ProcessingTime:
        // environment.setStreamTimeCharacteristic(TimeCharacteristic.IngestionTime);
        // environment.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
        environment.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
        // cause all operators (such as map,batchReduce) to run with x parallel instances
        environment.setParallelism(2);
        Set vehicleHashSet = new HashSet<>(7);
        // java Stream
        Stream stream = new Producer().getVehicles().limit(7L);
        stream.forEach(vehicleHashSet::add);
        vehicleHashSet.stream().forEach(System.out::println);
        // flink stream
        SingleOutputStreamOperator dataStream = environment.fromCollection(vehicleHashSet)
                // 这里特别注意：对记录加eventTime时间戳，因为这里是从collection自建的流，没自带时间戳，如果从kafka取，一般会自带
                // 否则报错：java.lang.RuntimeException: Record has Long.MIN_VALUE timestamp (= no timestamp marker)
                .assignTimestampsAndWatermarks(new MyTimeAssigner());

        // Sets the parallelism for this operator.但此实例流无法使用并行，请看官君思考下why
        // dataStream.setParallelism(3);

        // KeyedStream即DataStream上的操作状态按key分区了(即对数据流做分类)，注意这是逻辑分区
        // 先按type分区流的所有记录
        KeyedStream keyedStream = dataStream.keyBy("type");
        // 建立按记录数的WindowedStream,以下为窗口内元素数量为5，窗口每次滑过10个元素，
        /*  windowStream = keyedStream.countWindow(5,10); */
        // 建立按时间特征划分的WindowedStream，
        WindowedStream windowStream = keyedStream
                //  以下建立 翻转模式窗口，窗口时间跨度1秒
                // .window(TumblingEventTimeWindows.of(Time.seconds(1));
                // 以下建立 滑动模式窗口，窗口时长500，每次滑动时长1000
                .window(SlidingEventTimeWindows.of(Time.milliseconds(500),Time.milliseconds(1000)));
        // 可以在window内reduce/fold/aggregations，这里是将一个window内的全部元素放入到一个list中
        SingleOutputStreamOperator