Flink的流批统一

Flink依赖,1.13版本

在项目的 pom 文件中，增加标签设置属性，然后增加标签引 入需要的依赖。我们需要添加的依赖最重要的就是 Flink 的相关组件，包括 flink-java、 flink-streaming-java，以及 flink-clients（客户端，也可以省略）。另外，为了方便查看运行日志， 我们引入 slf4j 和 log4j 进行日志管理。

这里做一点解释： 在属性中，我们定义了，这指代的是所依赖的 Scala 版本。这有一点 奇怪：Flink 底层是 Java，而且我们也只用 Java API，为什么还会依赖 Scala 呢？这是因为 Flink 的架构中使用了 Akka 来实现底层的分布式通信，而 Akka 是用 Scala 开发的。

    <properties>
        <flink.version>1.13.0</flink.version>
        <java.version>1.8</java.version>
        <scala.binary.version>2.12</scala.binary.version>
        <slf4j.version>1.7.30</slf4j.version>
    </properties>

    <dependencies>
        <!-- 引入 Flink 相关依赖================开始============================================-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <!-- 引入 Flink 相关依赖================结束============================================-->
        <!-- 引入 Flink 本地模式查看Web界面================开始===================================-->
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-runtime-web_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
        </dependency>
        <!-- 引入 Flink 本地模式查看Web界面================结束===================================-->
        <!-- 引入日志管理相关依赖================开始============================================-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-to-slf4j</artifactId>
            <version>2.14.0</version>
        </dependency>
        <!-- 引入日志管理相关依赖================结束============================================-->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

一.前言:Flink流批统一

早期Flink提供了两套API.一个批处理的DataSet API,基于流处理DataStream API.
自从Flink1.12之后,开始支持流批统一.用DataStream API实现流处理和批处理.这样我们就可以使用一套DataStream API实现流批统一.
DataStream API怎么把数据集当成流来进行处理呢?
答:把数据当成有界流来进行流处理.并指定执行模式为BATCH

尽管 Flink 自身的定位是流式处理引擎，但它同样拥有批处理的能力。所以接下来，我们会针对不同的处理模式、不同的输入数据形式，分别讲述 WordCount 代码的实现。

二.DataSet

接下里的代码实现方式，是基于 DataSet API 的，也就是我们对数据的处理转换，是看作数据集来进行操作的。

读取文件

hello world
hello flink
hello java

代码

import org.apache.flink.api.common.typeinfo.Types;
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.operators.FlatMapOperator;
import org.apache.flink.api.java.operators.UnsortedGrouping;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;

public class BatchWordCount {
    public static void main(String[] args) throws Exception {
        // 1. 创建批处理执行环境,注意执行环境是:ExecutionEnvironment
        ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
        // 2. 从文件读取数据  按行读取(存储的元素就是每行的文本)
        DataSource<String> lineDS = env.readTextFile("input/words.txt");
        // 3. 转换数据格式
        FlatMapOperator<String, Tuple2<String, Long>> wordAndOne = lineDS
                .flatMap((String line, Collector<Tuple2<String, Long>> out) -> {
                    String[] words = line.split(" ");
                    for (String word : words) {
                        out.collect(Tuple2.of(word, 1L));
                    }
                })
                .returns(Types.TUPLE(Types.STRING, Types.LONG));  //当Lambda表达式使用 Java 泛型的时候, 由于泛型擦除的存在, 需要显示的声明类型信息

        // 4. 按照 word 进行分组
        UnsortedGrouping<Tuple2<String, Long>> wordAndOneUG = wordAndOne.groupBy(0);
        // 5. 分组内聚合统计
        AggregateOperator<Tuple2<String, Long>> sum = wordAndOneUG.sum(1);

        // 6. 打印结果
        sum.print();
    }
}

显示效果

(flink,1)
(world,1)
(hello,3)
(java,1)
发现这是很传统的批处理.读取文本数据,只做一次输出,得到最终结果
注意执行环境是:ExecutionEnvironment
为什么是DataSet APi呢? 
可以看DataSource的继承关系,继承了DataSet
public class DataSource<OUT> extends Operator<OUT, DataSource<OUT>>
public abstract class Operator<OUT, O extends Operator<OUT, O>> extends DataSet<OUT> 

三.DataStream

Flink 本身是流批统一的处理架构，批量的数据集本质上也是流，没有必要用两套不同的 API 来实现。所以从 Flink 1.12 开始，官方推荐的做法是直接使用 DataStream API，在提交任务时通过将执行模式设为 BATCH 来进行批处理：
$ bin/flink run -Dexecution.runtime-mode=BATCH BatchWordCount.jar
这样，DataSet API 就已经处于“软弃用”（soft deprecated）的状态，在实际应用中我们只
要维护一套 DataStream API 就可以了。这里只是为了方便大家理解，我们依然用 DataSet API
做了批处理的实现。

DataSet API 可以很容易地实现批处理；与之对应.
流处理当然可以用DataStream API 来实现。对于 Flink 而言，流才是整个处理逻辑的底层核心，所以流批统一之
后的 DataStream API 更加强大，可以直接处理批处理和流处理的所有场景。

代码

import org.apache.flink.api.common.RuntimeExecutionMode;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.util.Collector;

import java.util.Arrays;

public class BoundedStreamWordCount {
    public static void main(String[] args) throws Exception {
        // 1. 创建流式执行环境 注意执行环境:StreamExecutionEnvironment
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
//        env.setRuntimeMode(RuntimeExecutionMode.BATCH);
        // 2. 读取文件
        DataStreamSource<String> lineDSS = env.readTextFile("input/words.txt");
        // 3. 转换数据格式
        SingleOutputStreamOperator<Tuple2<String, Long>> wordAndOne = lineDSS
                .flatMap((String line, Collector<String> words) -> {
                    Arrays.stream(line.split(" ")).forEach(words::collect);
                })
                .returns(Types.STRING)
                .map(word -> Tuple2.of(word, 1L))
                .returns(Types.TUPLE(Types.STRING, Types.LONG));
        // 4. 分组
        KeyedStream<Tuple2<String, Long>, String> wordAndOneKS = wordAndOne
                .keyBy(t -> t.f0);
        // 5. 求和
        SingleOutputStreamOperator<Tuple2<String, Long>> result = wordAndOneKS
                .sum(1);
        // 6. 打印
        result.print();
        // 7. 执行
        env.execute();
    }
}

显示效果

9> (world,1)
13> (flink,1)
5> (hello,1)
5> (hello,2)
5> (hello,3)
3> (java,1)
发现这是流处理来一条计算一条.并不是将整体做计算只输出一次.这就是流处理
注意执行环境:StreamExecutionEnvironment

与批处理的结果是完全不同的。批处理针对每个单词，只会输出一个最终的统计个数；而在流处理的打印结果中，“hello”这个单词每出现一次，都会有一个频次统计
数据输出。这就是流处理的特点，数据逐个处理，每来一条数据就会处理输出一次。我们通过
打印结果，可以清晰地看到单词“hello”数量增长的过程。

那么问题来了,DataStream API 不是支持批处理吗? 我这里读的是文件啊,你把批数据,当成了有界流,我能理解.但是怎么体现DataStream的批处理呢?

注意看我注释的那行代码:env.setRuntimeMode(RuntimeExecutionMode.BATCH);

DataStream API要想支持批处理,需要指定DataStream 的运行模式为Batch.

这是我把注点的代码放开之后的结果:

3> (java,1)
13> (flink,1)
5> (hello,3)
9> (world,1)
很明显的发现这是标准的批处理.将整体数据集统一做计算,只输出最终一次结果

四.DataStream API指定执行模式的两种方式

1.通过命令行配置

bin/flink run -Dexecution.runtime-mode=BATCH ...
在提交作业时，增加 execution.runtime-mode 参数，指定值为 BATCH。

2.通过代码配置

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setRuntimeMode(RuntimeExecutionMode.BATCH);

建议

不要在代码中配置，而是使用命令行。这同设置并行度是类似的：在提交作业时指定参数可以更加灵活，同一段应用程序写好之后，既可以用于批处理也可以用于流处理。而在代码中硬编码（hard code）的方式可扩展性比较差，一般都不推荐。

什么时候选择BATCH模式

我们知道，Flink 本身持有的就是流处理的世界观，即使是批量数据，也可以看作“有界流”来进行处理。所以 STREAMING 执行模式对于有界数据和无界数据都是有效的；而 BATCH模式仅能用于有界数据。
看起来 BATCH 模式似乎被 STREAMING 模式全覆盖了，那还有必要存在吗？我们能不
能所有情况下都用流处理模式呢？
当然是可以的，但是这样有时不够高效。
我们可以仔细回忆一下 word count 程序中，批处理和流处理输出的不同：在 STREAMING模式下，每来一条数据，就会输出一次结果（即使输入数据是有界的）；而 BATCH 模式下，只有数据全部处理完之后，才会一次性输出结果。最终的结果两者是一致的，但是流处理模式会将更多的中间结果输出。在本来输入有界、只希望通过批处理得到最终的结果的场景下，STREAMING 模式的逐个输出结果就没有必要了。
所以总结起来，一个简单的原则就是：用 BATCH 模式处理批量数据，用 STREAMING模式处理流式数据。因为数据有界的时候，直接输出结果会更加高效；而当数据无界的时候, 我们没得选择——只有 STREAMING 模式才能处理持续的数据流。

五.总结

总结:Flink通过指定DataStream API的执行模式来实现DataStream API的流批统一.
执行模式的指定有两种:
1.通过命令行配置
2.通过代码配置