Flink学习笔记（五）DataStream API

前言

由于从Flink1.12开始全部操作可由DataStream完成，相当于摒弃了DataSet，因此本文只对DataStream API进行介绍。

5. DataStream API

​ 一个 Flink 程序，其实就是对 DataStream 的各种转换。具体来说，代码基本上都由以下几部分构成：

• 获取执行环境（execution environment）

• 读取数据源（source）

• 定义基于数据的转换操作（transformations）

• 定义计算结果的输出位置（sink）

• 触发程序执行（execute）

  获取环境和触发执行，都可以认为是针对执行环境的操作。因此包含以下四部分：

  

5.1 执行环境

​ 在提交作业执行计算时，首先必须获取当前 Flink 的运行环境，从而建立起与 Flink 框架之间的联系。只有获取了环境上下文信息，才能将具体的任务调度到不同的 TaskManager 执行。

5.1.1 创建执行环境

​ 要 获 取 的 执 行 环 境 ， 是StreamExecutionEnvironment 类的对象，这是所有 Flink 程序的基础。

​ 1.getExecutionEnvironment

​ 根据当前运行的上下文直接得到正确的结果：如果程序是独立运行的，就返回一个本地执行环境；如果是创建了 jar包，然后从命令行调用它并提交到集群执行，那么就返回集群的执行环境。根据当前运行的方式，自行决定该返回什么样的运行环境。

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

​ 2.createLocalEnvironment

​ 返回一个本地执行环境。可以在调用时传入一个参数，指定默认的并行度；如果不传入，则默认并行度就是本地的 CPU 核心数。

StreamExecutionEnvironment localEnv = StreamExecutionEnvironment.createLocalEnvironment();

​ 3.createRemoteEnvironment

​ 返回集群执行环境。需要在调用时指定 JobManager 的主机名和端口号，并指定要在集群中运行的 Jar 包。

StreamExecutionEnvironment remoteEnv = StreamExecutionEnvironment
 	.createRemoteEnvironment(
 	"host", // JobManager 主机名
	 1234, // JobManager 进程端口号
	 "path/to/jarFile.jar" // 提交给 JobManager 的 JAR 包
	);

5.1.2 执行模式

​ 从 1.12.0 版本起，Flink 实现了 API 上的流批统一。DataStream API 新增了一个重要特性：可以支持不同的“执行模式”（execution mode），通过简单的设置就可以让一段 Flink 程序在流处理和批处理之间切换。这样一来，DataSet API 也就没有存在的必要了。

• 流执行模式（STREAMING）

  DataStream API 最经典的模式，一般用于需要持续实时处理的无界数据流。默认情况下，程序使用的就是 STREAMING 执行模式。

• 批执行模式（BATCH）

  专门用于批处理的执行模式, 这种模式下，Flink 处理作业的方式类似于 MapReduce 框架。对于不会持续计算的有界数据，我们用这种模式处理会更方便。

• 自动模式（AUTOMATIC）

  在这种模式下，将由程序根据输入数据源是否有界，来自动选择执行模式。

用 BATCH 模式处理批量数据，用 STREAMING 模式处理流式数据。因为数据有界的时候，直接输出结果会更加高效；而当数据无界的时候, 我 们没得选择——只有 STREAMING 模式才能处理持续的数据流。

BATCH模式的配置方法

（1）通过命令行配置: 在提交作业时，增加 execution.runtime-mode 参数，指定值为 BATCH。

bin/flink run -Dexecution.runtime-mode=BATCH ...

（2）通过代码配置： 在代码中，直接基于执行环境调用 setRuntimeMode 方法，传入 BATCH 模式。

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

为了使其具有更高的灵活性，一般采用命令行设置的方式

5.1.3 触发程序执行

​ 写完输出（sink）操作并不代表程序已经结束。因为当 main()方法被调用时，其实只是定义了作业的每个执行操作，然后添加到数据流图中；这时并没有真正处理数据——因为数据可能还没来。Flink 是由事件驱动的，只有等到数据到来，才会触发真正的计算，这也被称为“延迟执行”或“懒执行”（lazy execution）。

​ 需要显式地调用执行环境的 execute()方法，来触发程序执行。

env.execute();

5.2 源算子（Source）

5.2.1 准备工作

创建Event对象：

import java.sql.Timestamp;

public class Event {
    public String user;
    public String url;
    public Long timestamp;

    public Event() {
    }

    public Event(String user, String url, Long timestamp) {
        this.user = user;
        this.url = url;
        this.timestamp = timestamp;
    }

    @Override
    public String toString() {
        return "Event{" +
                "user='" + user + '\'' +
                ", url='" + url + '\'' +
                ", timestamp=" + new Timestamp(timestamp) +
                '}';
    }
}

5.2.2 从集合中读取数据

ArrayList<Event> events = new ArrayList<>();
events.add(new Event("Mary", "./home", 1000L));
events.add(new Event("Bob", "./cart", 2000L));
DataStreamSource<Event> stream2 = env.fromCollection(events);

不构建集合，直接将元素列举出来，调用 fromElements 方法进行读取数据：

DataStreamSource<Event> stream2 = env.fromElements(
 new Event("Mary", "./home", 1000L),
 new Event("Bob", "./cart", 2000L)
);

5.2.3 从文件读取数据

DataStream<String> stream = env.readTextFile("clicks.csv");

也可以从 hdfs 目录下读取, 使用路径 hdfs://…, 由于 Flink 没有提供 hadoop 相关依赖, 需要 pom 中添加相关依赖:

<dependency>
 	<groupId>org.apache.hadoop</groupId>
 	<artifactId>hadoop-client</artifactId>
 	<version>2.7.5</version>
	 <scope>provided</scope>
</dependency>

5.2.4 从Socket读取数据

吞吐量小、稳定性较差，一般用于测试。

DataStream<String> stream = env.socketTextStream("localhost", 7777);

5.2.5 从Kafka读取数据

​ Kafka 作为分布式消息传输队列，是一个高吞吐、易于扩展的消息系统。而消息队列的传输方式，恰恰和流处理是完全一致的。

​ 与 Kafka 的连接比较复杂，Flink 内部并没有提供预实现的方法。所以只能采用通用的 addSource 方式、实现一个 SourceFunction 。好在Kafka与Flink确实是非常契合，所以Flink官方提供了连接工具flink-connector-kafka，直接帮我们实现了一个消费者 FlinkKafkaConsumer，它就是用来读取 Kafka 数据的SourceFunction。想要以 Kafka 作为数据源获取数据，我们只需要引入 Kafka 连接器的依赖。Flink 官方提供的是一个通用的 Kafka 连接器，它会自动跟踪最新版本的 Kafka 客户端。

添加依赖：

<dependency>
  <groupId>org.apache.flink</groupId>
  <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
  <version>${flink.version}</version>
</dependency>

调用 env.addSource()，传入 FlinkKafkaConsumer 的对象实例
    
Properties properties = new Properties();
properties.setProperty("bootstrap.servers", "hadoop102:9092");
properties.setProperty("group.id", "consumer-group");
properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
properties.setProperty("auto.offset.reset", "latest");

DataStreamSource<String> stream = env.addSource(new FlinkKafkaConsumer<String>(
         "clicks",
         new SimpleStringSchema(),
         properties
));

5.2.6 自定义Source

创建一个自定义的数据源，实现 SourceFunction 接口。主要重写两个关键方法：run()和 cancel()。

• run()方法：使用运行时上下文对象（SourceContext）向下游发送数据；
• cancel()方法：通过标识位控制退出循环，来达到中断数据源的效果。

自定义数据源示例:

mport org.apache.flink.streaming.api.functions.source.SourceFunction;

import java.util.Calendar;
import java.util.Random;

public class ClickSource implements SourceFunction<Event> {
    // 声明一个布尔变量，作为控制数据生成的标识位
    private Boolean running = true;
    @Override
    public void run(SourceContext<Event> ctx) throws Exception {
        Random random = new Random();
        // 在指定的数据集中随机选取数据
        String[] users = {"Mary", "Alice", "Bob", "Cary"};
        String[] urls = {"./home", "./cart", "./fav", "./prod?id=1", "./prod?id=2"};

        while (running) {
            ctx.collect(new Event(
                    users[random.nextInt(users.length)],
                    urls[random.nextInt(urls.length)],
                    Calendar.getInstance().getTimeInMillis()
            ));
            // 隔1秒生成一个点击事件，方便观测
            Thread.sleep(1000);
        }
    }
    @Override
    public void cancel() {
        running = false;
    }

}

**注意：**SourceFunction 接口定义的数据源，并行度只能设置为 1，如果数据源设置为大于 1 的并行度，则会抛出异常。

想要自定义并行的数据源的话，需要使用 ParallelSourceFunction，实现接口中的 run() 方法和 cancle() 方法。

5.2.7 Flink支持的数据类型

​ 1. Flink的类型系统

​ Flink 有自己一整套类型系统。Flink 使用“类型信息”（TypeInformation）来统一表示数据类型。TypeInformation 类是 Flink 中所有类型描述符的基类。它涵盖了类型的一些基本属性，并为每个数据类型生成特定的序列化器、反序列化器和比较器。

​ 2. Flink支持的数据类型

​ 对于常见的 Java 和 Scala 数据类型，Flink 都是支持的。Flink 在内部，Flink对支持不同的类型进行了划分，这些类型可以在 Types 工具类中找到。

​ （1）基本类型：所有 Java 基本类型及其包装类，再加上 Void、String、Date、BigDecimal 和 BigInteger；

​ （2）数组类型：包括基本类型数组（PRIMITIVE_ARRAY）和对象数组(OBJECT_ARRAY)；

​ （3）复合数据类型：Java 元组类型；Scala 样例类及 Scala 元组；行类型；POJO

​ （4）辅助类型：Option、Either、List、Map 等

​ （5）泛型类型

​ 在这些类型中，元组类型和 POJO 类型最为灵活，因为它们支持创建复杂类型。而相比之下，POJO 还支持在键（key）的定义中直接使用字段名，这会让我们的代码可读性大大增加。所以，在项目实践中，往往会将流处理程序中的元素类型定为 Flink 的 POJO 类型。

​ Flink 对 POJO 类型的要求如下：

• 类是公共的（public）和独立的（standalone，也就是说没有非静态的内部类）；

• 类有一个公共的无参构造方法；

• 类中的所有字段是 public 且非 final 的；或者有一个公共的 getter 和 setter 方法，这些方法需要符合 Java bean 的命名规范。

  3. 类型提示（Type Hints）

  Flink 还具有一个类型提取系统，可以分析函数的输入和返回类型，自动获取类型信息，从而获得对应的序列化器和反序列化器。

​ Flink 专门提供了 TypeHint 类，它可以捕获泛型的类型信息，并且一直记录下来，为运行时提供足够的信息。我们同样可以通过.returns()方法，明确地指定转换之后的 DataStream 里元素的类型。

returns(new TypeHint<Tuple2<Integer, SomeType>>(){})

5.3 转换算子(Transformation)

​ 一个 Flink 程序的核心，其实就是所有的转换操作，它们决定了处理的业务逻辑。

5.3.1 基本转换算子

​ 1. 映射（map）

​ map 就是一个“一一映射”，消费一个元素就产出一个元素。只需要基于 DataStrema 调用 map()方法就可以进行转换处理。方法需要传入的参数是接口 MapFunction 的实现；返回值类型还是 DataStream，不过泛型（流中的元素类型）可能改变。

​ 需要基于 DataStrema 调用 map()方法就可以进行转换处理。方法需要传入的参数是 接口 MapFunction 的实现；返回值类型还是 DataStream，不过泛型（流中的元素类型）可能改变。

  // 1.传入匿名类，实现MapFunction
        stream.map(new MapFunction<Event, String>() {
            @Override
            public String map(Event e) throws Exception {
                return e.user;
            }
        });

// 2.传入MapFunction的实现类
        stream.map(new UserExtractor()).print();

//使用自定义类，实现MapFunction接口
    public static class UserExtractor implements MapFunction<Event, String> {
        @Override
        public String map(Event e) throws Exception {
            return e.user;
        }
    }

​ 2. 过滤（filter）

​ filter 转换操作，顾名思义是对数据流执行一个过滤，通过一个布尔条件表达式设置过滤条件，对于每一个流内元素进行判断，若为 true 则元素正常输出，若为 false 则元素被过滤掉。

​ 进行 filter 转换之后的新数据流的数据类型与原数据流是相同的。filter 转换需要传入的参数需要实现 FilterFunction 接口，而 FilterFunction 内要实现 filter()方法，就相当于一个返回布尔类型的条件表达式。

 // 1.传入匿名类实现FilterFunction
        stream.filter(new FilterFunction<Event>() {
            @Override
            public boolean filter(Event e) throws Exception {
                return e.user.equals("Mary");
            }
        });

// 2.传入FilterFunction实现类
        stream.filter(new UserFilter()).print();

 public static class UserFilter implements FilterFunction<Event> {
        @Override
        public boolean filter(Event e) throws Exception {
            return e.user.equals("Mary");
        }
    }

​ 3. 扁平映射（flatMap）

​ flatMap 操作又称为扁平映射，主要是将数据流中的整体（一般是集合类型）拆分成一个一个的个体使用。消费一个元素，可以产生 0 到多个元素。flatMap 可以认为是“扁平化”（flatten）和“映射”（map）两步操作的结合，也就是先按照某种规则对数据进行打散拆分，再对拆分后的元素做转换处理。

​ flatMap 操作会应用在每一个输入事件上面，FlatMapFunction 接口中定义了 flatMap 方法，用户可以重写这个方法，在这个方法中对输入数据进行处理，并决定是返回 0 个、1 个或多个结果数据。因此 flatMap 并没有直接定义返回值类型，而是通过一个“收集器”（Collector）来指定输出。希望输出结果时，只要调用收集器的.collect()方法就可以了；这个方法可以多次调用，也可以不调用。所以 flatMap 方法也可以实现 map 方法和 filter 方法的功能，当返回结果是 0 个的时候，就相当于对数据进行了过滤，当返回结果是 1 个的时候，相当于对数据进行了简单的转换操作。

// 2.传入FlatMapFunction实现类 
stream.flatMap(new MyFlatMap()).print();

public static class MyFlatMap implements FlatMapFunction<Event, String> {
    @Override
    public void flatMap(Event value, Collector<String> out) throws Exception {
        if (value.user.equals("Mary")) {
            out.collect(value.user);
        } else if (value.user.equals("Bob")) {
            out.collect(value.user);
            out.collect(value.url);
        }
    }
}

5.3.2 聚合算子（Aggregation）

​ 1. 按键分区（KeyBy）

​ 对于 Flink 而言，DataStream 是没有直接进行聚合的 API 的。因为我们对海量数据做聚合肯定要进行分区并行处理，这样才能提高效率。所以在 Flink 中，要做聚合，需要先进行分区；这个操作就是通过 keyBy 来完成的。

​ keyBy 是聚合前必须要用到的一个算子。keyBy 通过指定键（key），可以将一条流从逻辑上划分成不同的分区（partitions）。这里所说的分区，其实就是并行处理的子任务，也就对应着任务槽（task slot）。

​ 基于不同的 key，流中的数据将被分配到不同的分区中去，所有具有相同的 key 的数据，都将被发往同一个分区，下一步算子操作就将会在同一个 slot中进行处理了。

​ keyBy()方法需要传入一个参数，这个参数指定了一个或一组 key。

以 id 作为 key 做一个分区操作:

// 使用 Lambda 表达式
 KeyedStream<Event, String> keyedStream = stream.keyBy(e -> e.user);

// 使用匿名类实现 KeySelector
 KeyedStream<Event, String> keyedStream1 = stream.keyBy(new KeySelector<Event, String>() {
     @Override
     public String getKey(Event e) throws Exception {
     return e.user;
     }
 });

​ keyBy 得到的结果将不再是 DataStream，而是会将 DataStream 转换为KeyedStream。KeyedStream 可以认为是“分区流”或者“键控流”，它是对 DataStream 按照key 的一个逻辑分区，所以泛型有两个类型：除去当前流中的元素类型外，还需要指定 key 的类型。KeyedStream 是一个非常重要的数据结构，只有基于它才可以做后续的聚合操作（比如 sum，reduce）；而且它可以将当前算子任务的状态（state）也按照 key 进行划分、限定为仅对当前 key 有效。

​ 2. 简单聚合

• sum()：在输入流上，对指定的字段做叠加求和的操作。

• min()：在输入流上，对指定的字段求最小值。

• max()：在输入流上，对指定的字段求最大值。

• minBy()：与 min()类似，在输入流上针对指定字段求最小值。不同的是，min()只计算指定字段的最小值，其他字段会保留最初第一个数据的值；而 minBy()则会返回包含字段最小值的整条数据。
• maxBy()：与 max()类似，在输入流上针对指定字段求最大值。两者区别与min()/minBy()完全一致。

这些聚合方法调用时，也需要传入参数； 但并不像基本转换算子那样需要实现自定义函数，只要说明聚合指定的字段就可以了。指定字 段的方式有两种：指定位置，和指定名称。

而如果数据流的类型是 POJO 类，那么就只能通过字段名称来指定，不能通过位置来指定 了。

3. 规约聚合（reduce）

调用 KeyedStream 的 reduce 方法时，需要传入一个参数，实现 ReduceFunction 接口。接口在源码中的定义如下：

public interface ReduceFunction<T> extends Function, Serializable {
	T reduce(T value1, T value2) throws Exception;
}

​ ReduceFunction 接口里需要实现 reduce()方法，这个方法接收两个输入事件，经过转换处理之后输出一个相同类型的事件。在流处理的底层实现过程中，实际上是将中间“合并的结果”作为任务的一个状态保存起来的；之后每来一个新的数据，就和之前的聚合状态进一步做归约。

​ reduce 同简单聚合算子一样，也要针对每一个 key 保存状态。因为状态不会清空，所以需要将 reduce 算子作用在一个有限 key 的流上。

import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.functions.ReduceFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

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

        // 这里的使用了之前自定义数据源小节中的ClickSource()，随机产生Event对象
        env.addSource(new ClickSource())
                // 将Event数据类型转换成元组类型
                .map(new MapFunction<Event, Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> map(Event e) throws Exception {
                        return Tuple2.of(e.user, 1L);
                    }
                })
                .keyBy(r -> r.f0) // 使用用户名来进行分流
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                        // 每到一条数据，用户pv的统计值加1
                        return Tuple2.of(value1.f0, value1.f1 + value2.f1);
                    }
                })
                .keyBy(r -> true) // 为每一条数据分配同一个key，将聚合结果发送到一条流中去
                .reduce(new ReduceFunction<Tuple2<String, Long>>() {
                    @Override
                    public Tuple2<String, Long> reduce(Tuple2<String, Long> value1, Tuple2<String, Long> value2) throws Exception {
                        // 将累加器更新为当前最大的pv统计值，然后向下游发送累加器的值
                        return value1.f1 > value2.f1 ? value1 : value2;
                    }
                })
                .print();

        env.execute();

    }
}

5.3.3 用户自定义函数（UDF）

​ Flink 的 DataStream API 编程风格其实是一致的：基本上都是基于 DataStream 调用一个方法，表示要做一个转换操作；方法需要传入一个参数，这个参数都是需要实现一个接口。接口有一个共同特点：全部都以算子操作名称 + Function 命名。查看源码会发现，它们都继承自 Function 接口。

1. 函数类（Function Classes）

自定义一个函数类，实现对应的接口。包括定义一个类实现接口和使用匿名类两种方式。

//实现 FilterFunction 接口
DataStream<Event> stream = clicks.filter(new FlinkFilter());

public static class FlinkFilter implements FilterFunction<Event> {
     @Override
     public boolean filter(Event value) throws Exception {
     return value.url.contains("home");
     }
 }

//匿名类实现 FilterFunction 接口
DataStream<String> stream = clicks.filter(new FilterFunction<Event>() {
     @Override
     public boolean filter(Event value) throws Exception {
     return value.url.contains("home");
     }
});

2. 匿名函数（Lambda）

Lambda 表达式允许以简洁的方式实现函数，以及将函数作为参数来进行传递，而不必声明额外的（匿名）类。

//map 函数使用 Lambda 表达式，返回简单类型，不需要进行类型声明
 DataStream<String> stream1 = clicks.map(event -> event.url);

由于 OUT 是 String 类型而不是泛型，所以 Flink 可以从函数签名 OUT map(IN value) 的实现中自动提取出结果的类型信息。但是对于像 flatMap() 这样的函数，它的函数签名 void flatMap(IN value, Collector out) 被 Java 编译器编译成了 void flatMap(IN value, Collector out)，也就是说将 Collector 的泛 型信息擦除掉了。这样 Flink 就无法自动推断输出的类型信息了。

示例：

// flatMap 使用 Lambda 表达式，抛出异常
DataStream<String> stream2 = clicks.flatMap((event, out) -> {
    out.collect(event.url);
    });
stream2.print();

执行上述代码Flink会抛出异常。

在这种情况下，我们需要显式地指定类型信息，否则输出将被视为 Object 类型，这会导 致低效的序列化。

// flatMap 使用 Lambda 表达式，必须通过 returns 明确声明返回类型
DataStream<String> stream2 = clicks.flatMap((Event event, Collector<String> out) -> {
    out.collect(event.url);
    }).returns(Types.STRING);
stream2.print();	

3. 富函数类（ich Function Classes）

“富函数类”也是 DataStream API 提供的一个函数类的接口，所有的 Flink 函数类都有其Rich 版本。富函数类一般是以抽象类的形式出现的。例如：RichMapFunction、RichFilterFunction、RichReduceFunction 等。

Rich Function 有生命周期的概念。典型的生命周期方法有：

• open()方法，是 Rich Function 的初始化方法，也就是会开启一个算子的生命周期。当 一个算子的实际工作方法例如 map()或者 filter()方法被调用之前，open()会首先被调 用。所以像文件 IO 的创建，数据库连接的创建，配置文件的读取等等这样一次性的 工作，都适合在 open()方法中完成。

• close()方法，是生命周期中的最后一个调用的方法，类似于解构方法。一般用来做一 些清理工作。

例如希望连接到一个外部数据库进行读写操作，那么将连 接操作放在 map()中显然不是个好选择——因为每来一条数据就会重新连接一次数据库；所以 我们可以在 open()中建立连接，在 map()中读写数据，而在 close()中关闭连接。

public class MyFlatMap extends RichFlatMapFunction<IN, OUT>> {
     @Override
     public void open(Configuration configuration) {
     // 做一些初始化工作
     // 建立一个和 MySQL 的连接
     }
     @Override
     public void flatMap(IN in, Collector<OUT out) {
     // 对数据库进行读写
     }
     @Override
     public void close() {
     // 清理工作，关闭和 MySQL 数据库的连接。
 }
}

5.3.4 物理分区（Physical Partitioning）

​ keyBy是一种按照键的哈希值来进行重新分区的操作。keyBy 是一种逻辑分区（logical partitioning）操作。常见的物理分区策略有随机分配（Random）、轮询分配（Round-Robin）、重缩放（Rescale）和广播（Broadcast）。

​ 1. 随机分区（shuffle）

​ 最简单的重分区方式就是直接“洗牌”。通过调用 DataStream 的.shuffle()方法，将数据随机地分配到下游算子的并行任务中去。随机分区服从均匀分布（uniform distribution），所以可以把流中的数据随机打乱，均匀地传递到下游任务分区。

​ 2. 轮询分区（Round-Robin）

​ 简单来说就是“发牌”，按照先后顺序将数据做依次分发。通过调用 DataStream 的.rebalance()方法，就可以实现轮询重分区。rebalance使用的是 Round-Robin 负载均衡算法，可以将输入流数据平均分配到下游的并行任务中去。

​ 3. 重缩放分区（rescale）

​ 重缩放分区和轮询分区非常相似。当调用 rescale()方法时，其实底层也是使用 Round-Robin算法进行轮询，但是只会将数据轮询发送到下游并行任务的一部分中。也就是说，“发牌人”如果有多个，那么 rebalance 的方式是每个发牌人都面向所有人发牌；而 rescale的做法是分成小团体，发牌人只给自己团体内的所有人轮流发牌。从底层实现上看，rebalance 和 rescale 的根本区别在于任务之间的连接机制不同。rebalance将会针对所有上游任务（发送数据方）和所有下游任务（接收数据方）之间建立通信通道，这是一个笛卡尔积的关系；而 rescale 仅仅针对每一个任务和下游对应的部分任务之间建立通信通道，节省了很多资源。

​ 4. 广播（broadcast）

​ 这种方式其实不应该叫做“重分区”，因为经过广播之后，数据会在不同的分区都保留一份，可能进行重复处理。可以通过调用 DataStream 的 broadcast()方法，将输入数据复制并发送到下游算子的所有并行任务中去。

​ 5. 全局分区（global）

​ 通过调用.global()方法，会将所有的输入流数据都发送到下游算子的第一个并行子任务中去。这就相当于强行让下游任务并行 度变成了 1，所以使用这个操作需要非常谨慎，可能对程序造成很大的压力。

​ 6. 自定义分区（Custom）

​ 当 Flink 提 供 的 所 有 分 区 策 略 都 不 能 满 足 用 户 的 需 求 时 ， 我 们 可 以 通 过 使 用 partitionCustom()方法来自定义分区策略。 在调用时，方法需要传入两个参数，第一个是自定义分区器（Partitioner）对象，第二个 是应用分区器的字段，它的指定方式与 keyBy 指定 key 基本一样：可以通过字段名称指定， 也可以通过字段位置索引来指定，还可以实现一个 KeySelector。

// 将自然数按照奇偶分区
 env.fromElements(1, 2, 3, 4, 5, 6, 7, 8)
     .partitionCustom(new Partitioner<Integer>() {
     @Override
     public int partition(Integer key, int numPartitions) {
     return key % 2;
     }
     }, new KeySelector<Integer, Integer>() {
     @Override
     public Integer getKey(Integer value) throws Exception {
     return value;
     }
 })

对于Flink的资源调度问题这部分内容，有学者对其进行了大量研究，可以查看相关论文。

5.4 输出算子（Sink）

5.4.1 连接到外部系统

​ Flink 的 DataStream API 专门提供了向外部写入数据的方法： addSink。与 addSource 类似，addSink 方法对应着一个“Sink”算子，主要就是用来实现与外 部系统连接、并将数据提交写入的；Flink 程序中所有对外的输出操作，一般都是利用 Sink 算 子完成的。

​ SinkFuntion 多数情况下同样并不需要我们自己实现。Flink 官方提供了一部分的框 架的 Sink 连接器。

​ 除 Flink 官方之外，Apache Bahir 作为给 Spark 和 Flink 提供扩展支持的项目，也实现了一 些其他第三方系统与 Flink 的连接器。

5.4.2 输出到文件

​ StreamingFileSink 为批处理和流处理提供了一个统一的 Sink，它可以将分区文件写入 Flink 支持的文件系统。它的主要操作是将数据写入桶（buckets），每个桶中的数据都可以分割成一个个大小有限的分 区文件，这样一来就实现真正意义上的分布式文件存储。

​ StreamingFileSink 支持行编码（Row-encoded）和批量编码（Bulk-encoded，比如 Parquet） 格式。这两种不同的方式都有各自的构建器（builder），调用方法也非常简单，可以直接调用 StreamingFileSink 的静态方法：

• 行编码：StreamingFileSink.forRowFormat（basePath，rowEncoder）。
• 批量编码：StreamingFileSink.forBulkFormat（basePath，bulkWriterFactory）。

StreamingFileSink<String> fileSink = StreamingFileSink
    .<String>forRowFormat(new Path("./output"),
                          new SimpleStringEncoder<>("UTF-8"))
    .withRollingPolicy( //指定滚动策略
    DefaultRollingPolicy.builder()
    //滚动周期，单位为毫秒
    .withRolloverInterval(TimeUnit.MINUTES.toMillis(15))
    //当前不活跃的时间
    .withInactivityInterval(TimeUnit.MINUTES.toMillis(5))
    .withMaxPartSize(1024 * 1024 * 1024)
    .build())
    .build();

// 将Event转换成String写入文件
stream.map(Event::toString).addSink(fileSink);

5.4.3 输出到Kafka

​ Flink 官方为 Kafka 提供了 Source 和 Sink 的连接器，我们可以用它方便地从 Kafka 读写数据。要将数据输出到 Kafka，整个数据处理的闭环已经形成，所以可以完整测试如下：

​ （1）添加 Kafka 连接器依赖 由于我们已经测试过从 Kafka 数据源读取数据；

​ （2）启动 Kafka 集群 ；

​ （3）编写输出到 Kafka 的示例代码。

import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer;

import java.util.Properties;

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

        Properties properties = new Properties();
        properties.put("bootstrap.servers", "hadoop102:9092");

        DataStreamSource<String> stream = env.readTextFile("input/clicks.csv");

        stream
                .addSink(new FlinkKafkaProducer<String>(
                        "clicks",
                        new SimpleStringSchema(),
                        properties
                ));

        env.execute();
    }
}

5.3.4 输出到Redis

（1）导入依赖：

<dependency>
     <groupId>org.apache.bahir</groupId>
     <artifactId>flink-connector-redis_2.11</artifactId>
     <version>1.0</version>
</dependency>

（2）启动 Redis 集群

（3）输出到 Redis 的示例代码:

连接器为我们提供了一个 RedisSink，它继承了抽象类 RichSinkFunction，这就是已经实现 好的向 Redis 写入数据的 SinkFunction。可以直接将 Event 数据输出到 Redis。

import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.redis.RedisSink;
import org.apache.flink.streaming.connectors.redis.common.config.FlinkJedisPoolConfig;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommand;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisCommandDescription;
import org.apache.flink.streaming.connectors.redis.common.mapper.RedisMapper;

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

        DataStreamSource<Event> stream = env.addSource(new ClickSource());

        // 创建一个到redis连接的配置
        FlinkJedisPoolConfig conf = new FlinkJedisPoolConfig.Builder()
                .setHost("hadoop102")
                .build();

        stream.addSink(new RedisSink<Event>(conf, new MyRedisMapper()));

        env.execute();
    }
    public static class MyRedisMapper implements RedisMapper<Event> {
        @Override
        public RedisCommandDescription getCommandDescription() {
            return new RedisCommandDescription(RedisCommand.HSET, "clicks");
        }

        @Override
        public String getKeyFromData(Event data) {
            return data.user;
        }

        @Override
        public String getValueFromData(Event data) {
            return data.url;
        }
    }

}

RedisSink 的构造方法需要传入两个参数：

• JFlinkJedisConfigBase：Jedis 的连接配置
• RedisMapper：Redis 映射类接口，说明怎样将数据转换成可以写入 Redis 的类型

5.3.5 输出到ElasticSearch

ElasticSearch 是一个分布式的开源搜索和分析引擎，适用于所有类型的数据。

（1）添加 Elasticsearch 连接器依赖

<dependency>
     <groupId>org.apache.flink</groupId>
     <artifactId>flink-connector-elasticsearch7_${scala.binary.version}</artifactId>
     <version>${flink.version}</version>
</dependency

（2）启动 Elasticsearch 集群

（3）输出到 Elasticsearch 的示例代码

import org.apache.flink.api.common.functions.RuntimeContext;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.elasticsearch.ElasticsearchSinkFunction;
import org.apache.flink.streaming.connectors.elasticsearch.RequestIndexer;
import org.apache.flink.streaming.connectors.elasticsearch6.ElasticsearchSink;
import org.apache.http.HttpHost;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.Requests;

import java.util.ArrayList;
import java.util.HashMap;

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

        DataStreamSource<Event> stream = env.fromElements(
                new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=200", 3500L),
                new Event("Bob", "./prod?id=2", 2500L),
                new Event("Alice", "./prod?id=300", 3600L),
                new Event("Bob", "./home", 3000L),
                new Event("Bob", "./prod?id=1", 2300L),
                new Event("Bob", "./prod?id=3", 3300L));

        ArrayList<HttpHost> httpHosts = new ArrayList<>();
        httpHosts.add(new HttpHost("hadoop102", 9200, "http"));

        // 创建一个ElasticsearchSinkFunction
        ElasticsearchSinkFunction<Event> elasticsearchSinkFunction = new ElasticsearchSinkFunction<Event>() {
            @Override
            public void process(Event element, RuntimeContext ctx, RequestIndexer indexer) {
                HashMap<String, String> data = new HashMap<>();
                data.put(element.user, element.url);

                IndexRequest request = Requests.indexRequest()
                        .index("clicks")
                        .type("type")    // Es 6 必须定义 type
                        .source(data);

                indexer.add(request);
            }
        };

        stream.addSink(new ElasticsearchSink.Builder<Event>(httpHosts, elasticsearchSinkFunction).build());

        env.execute();
    }
}

与 RedisSink 类 似 ， 连 接 器 也 为 我 们 实 现 了 写 入 到 Elasticsearch 的 SinkFunction——ElasticsearchSink。区别在于，这个类的构造方法是私有（private）的，需要使用 ElasticsearchSink 的 Builder 内部静态类，调用它的 build()方法才能创建出真正的 SinkFunction。

而 Builder 的构造方法中又有两个参数：

• httpHosts：连接到的 Elasticsearch 集群主机列表 。
• elasticsearchSinkFunction：这并不是我们所说的 SinkFunction，而是用来说明具体处 理逻辑、准备数据向 Elasticsearch 发送请求的函数。

5.3.6 输出到Mysql

（1）添加依赖

<dependency>
     <groupId>org.apache.flink</groupId>
     <artifactId>flink-connector-jdbc_${scala.binary.version}</artifactId>
     <version>${flink.version}</version>
</dependency>
<dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>5.1.47</version>
</dependency>

（2）启动 MySQL，在 database 库下建表 clicks

mysql> create table clicks(
 -> user varchar(20) not null,
 -> url varchar(100) not null);

（3）输出到 MySQL 的示例代码

import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.connector.jdbc.JdbcConnectionOptions;
import org.apache.flink.connector.jdbc.JdbcSink;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;

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


        DataStreamSource<Event> stream = env.fromElements(
                new Event("Mary", "./home", 1000L),
                new Event("Bob", "./cart", 2000L),
                new Event("Alice", "./prod?id=100", 3000L),
                new Event("Alice", "./prod?id=200", 3500L),
                new Event("Bob", "./prod?id=2", 2500L),
                new Event("Alice", "./prod?id=300", 3600L),
                new Event("Bob", "./home", 3000L),
                new Event("Bob", "./prod?id=1", 2300L),
                new Event("Bob", "./prod?id=3", 3300L));

        stream.addSink(
                JdbcSink.sink(
                        "INSERT INTO clicks (user, url) VALUES (?, ?)",
                        (statement, r) -> {
                            statement.setString(1, r.user);
                            statement.setString(2, r.url);
                        },
                        new JdbcConnectionOptions.JdbcConnectionOptionsBuilder()
                                .withUrl("jdbc:mysql://localhost:3306/temp")
                                .withDriverName("com.mysql.jdbc.Driver")
                                .withUsername("root")
                                .withPassword("123456")
                                .build()
                )
        );
        env.execute();
    }
}

总结

本文依次讲解了执行环境的创建、数据源的读取、数据流的转换操作，和最终结果数据的输出，对各种常见的转换操作 API 和外部系统的连接都做了详细介绍，至此介绍了 DataStream API 的基本用法以及 Flink 的编程习惯。