• 博客园logo
  • 会员
  • 众包
  • 新闻
  • 博问
  • 闪存
  • 赞助商
  • HarmonyOS
  • Chat2DB
    • 搜索
      所有博客
    • 搜索
      当前博客
  • 写随笔 我的博客 短消息 简洁模式
    用户头像
    我的博客 我的园子 账号设置 会员中心 简洁模式 ... 退出登录
    注册 登录
思想人生从关注生活开始
博客园    首页    新随笔    联系   管理    订阅  订阅

Apache Flink with Java 简介-Java快速进阶教程

1. 概述

Apache Flink是一个大数据处理框架,允许程序员以非常高效和可扩展的方式处理大量数据。

在本文中,我们将介绍Apache FlinkJava API 中提供的一些核心 API 概念和标准数据转换。这个 API 的流畅风格使得使用 Flink 的中心结构——分布式集合变得容易。

首先,我们将看一下 Flink 的DataSetAPI 转换,并使用它们来实现字数统计程序。然后我们将简要介绍一下 Flink 的DataStreamAPI,它允许您以实时方式处理事件流。

2. Maven 依赖

首先,我们需要将 Maven 依赖项添加到 flink-java 和flink-test-utils库中:

<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-java</artifactId>
    <version>1.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.flink</groupId>
    <artifactId>flink-test-utils_2.10</artifactId>
    <version>1.2.0</version>
    <scope>test<scope>
</dependency>

3. 核心 API 概念

在使用 Flink 时,我们需要了解与其 API 相关的几件事:

  • 每个 Flink 程序都对分布式数据集合执行转换。提供了多种数据转换功能,包括过滤、映射、联接、分组和聚合
  • Flink 中的sink操作会触发流的执行以产生程序的预期结果,例如将结果保存到文件系统或将其打印到标准输出
  • Flink 转换是惰性的,这意味着在调用接收器操作之前不会执行它们
  • Apache Flink API 支持两种操作模式——批处理和实时。如果要处理可在批处理模式下处理的有限数据源,则将使用数据集API。如果要实时处理无限数据流,则需要使用DataStreamAPI

4. 数据集 API 转换

Flink 程序的入口点是ExecutionEnvironment类的一个实例——它定义了程序执行的上下文。

让我们创建一个执行环境来开始我们的处理:

ExecutionEnvironment env
  = ExecutionEnvironment.getExecutionEnvironment();

请注意,当您在本地机器上启动应用程序时,它将在本地 JVM 上执行处理。如果要在计算机集群上开始处理,则需要在这些计算机上安装Apache Flink并相应地配置执行环境。

4.1. 创建DataSet

要开始执行数据转换,我们需要为程序提供数据。

让我们使用我们的执行环境创建DataSet类的实例:

DataSet<Integer> amounts = env.fromElements(1, 29, 40, 50);

您可以从多个源创建数据集,例如 Apache Kafka、CSV、文件或几乎任何其他数据源。

4.2. Filter和Reduce

创建DataSet类的实例后,可以对其应用转换。

假设您要过滤超过某个阈值的数字,然后将它们全部相加。您可以使用filter() 和reduce() 转换来实现此目的:

int threshold = 30;
List<Integer> collect = amounts
  .filter(a -> a > threshold)
  .reduce((integer, t1) -> integer + t1)
  .collect();

assertThat(collect.get(0)).isEqualTo(90);

请注意,collect() 方法是触发实际数据转换的接收器操作。

4.3. map

假设您有一个Person对象的数据集:

private static class Person {
    private int age;
    private String name;

    // standard constructors/getters/setters
}

接下来,让我们创建这些对象的数据集:

DataSet<Person> personDataSource = env.fromCollection(
  Arrays.asList(
    new Person(23, "Tom"),
    new Person(75, "Michael")));

假设您只想从集合的每个对象中提取年龄字段。您可以使用map() 转换来仅获取Person类的特定字段:

List<Integer> ages = personDataSource
  .map(p -> p.age)
  .collect();

assertThat(ages).hasSize(2);
assertThat(ages).contains(23, 75);

4.4. Join

 

当您有两个数据集时,您可能希望将它们连接到某个id字段上。为此,您可以使用join() 转换。

让我们创建用户的交易和地址的集合:

Tuple3<Integer, String, String> address
  = new Tuple3<>(1, "5th Avenue", "London");
DataSet<Tuple3<Integer, String, String>> addresses
  = env.fromElements(address);

Tuple2<Integer, String> firstTransaction 
  = new Tuple2<>(1, "Transaction_1");
DataSet<Tuple2<Integer, String>> transactions 
  = env.fromElements(firstTransaction, new Tuple2<>(12, "Transaction_2"));

两个元组中的第一个字段都是Integer类型,这是一个id字段,我们希望在其上连接两个数据集。

为了执行实际的连接逻辑,我们需要为地址和事务实现一个KeySelector接口:

private static class IdKeySelectorTransaction 
  implements KeySelector<Tuple2<Integer, String>, Integer> {
    @Override
    public Integer getKey(Tuple2<Integer, String> value) {
        return value.f0;
    }
}
private static class IdKeySelectorAddress 
  implements KeySelector<Tuple3<Integer, String, String>, Integer> {
    @Override
    public Integer getKey(Tuple3<Integer, String, String> value) {
        return value.f0;
    }
}

每个选择器仅返回应对其执行连接的字段。

不幸的是,这里不能使用 lambda 表达式,因为 Flink 需要泛型类型信息。

接下来,让我们使用这些选择器实现合并逻辑:

List<Tuple2<Tuple2<Integer, String>, Tuple3<Integer, String, String>>>
  joined = transactions.join(addresses)
  .where(new IdKeySelectorTransaction())
  .equalTo(new IdKeySelectorAddress())
  .collect();

assertThat(joined).hasSize(1);
assertThat(joined).contains(new Tuple2<>(firstTransaction, address));

4.5. Sort

假设您有以下Tuple2 集合:

Tuple2<Integer, String> secondPerson = new Tuple2<>(4, "Tom");
Tuple2<Integer, String> thirdPerson = new Tuple2<>(5, "Scott");
Tuple2<Integer, String> fourthPerson = new Tuple2<>(200, "Michael");
Tuple2<Integer, String> firstPerson = new Tuple2<>(1, "Jack");
DataSet<Tuple2<Integer, String>> transactions = env.fromElements(
  fourthPerson, secondPerson, thirdPerson, firstPerson);

如果要按元组的第一个字段对此集合进行排序,可以使用sortPartitions()转换:

List<Tuple2<Integer, String>> sorted = transactions
  .sortPartition(new IdKeySelectorTransaction(), Order.ASCENDING)
  .collect();

assertThat(sorted)
  .containsExactly(firstPerson, secondPerson, thirdPerson, fourthPerson);

5. 字数统计

字数统计问题通常用于展示大数据处理框架的功能。基本解决方案涉及计算文本输入中的单词出现次数。让我们使用 Flink 来实现这个问题的解决方案。

作为解决方案的第一步,我们创建一个LineSplitter类,该类将我们的输入拆分为标记(单词),为每个标记收集键值对的Tuple2。在每个元组中,键是在文本中找到的单词,值是整数 (1)。

此类实现FlatMapFunction接口,该接口将字符串作为输入并生成Tuple2<String, Integer>:

public class LineSplitter implements FlatMapFunction<String, Tuple2<String, Integer>> {

    @Override
    public void flatMap(String value, Collector<Tuple2<String, Integer>> out) {
        Stream.of(value.toLowerCase().split("\\W+"))
          .filter(t -> t.length() > 0)
          .forEach(token -> out.collect(new Tuple2<>(token, 1)));
    }
}

我们在Collector类上调用collect() 方法,以在处理管道中向前推送数据。

我们的下一步也是最后一步是按元组的第一个元素(单词)对元组进行分组,然后对第二个元素执行总和聚合以生成单词出现的计数:

 
public static DataSet<Tuple2<String, Integer>> startWordCount(
  ExecutionEnvironment env, List<String> lines) throws Exception {
    DataSet<String> text = env.fromCollection(lines);

    return text.flatMap(new LineSplitter())
      .groupBy(0)
      .aggregate(Aggregations.SUM, 1);
}

我们使用三种类型的 Flink 转换:flatMap()、groupBy() 和aggregate()。

让我们编写一个测试来断言字数统计实现按预期工作:

List<String> lines = Arrays.asList(
  "This is a first sentence",
  "This is a second sentence with a one word");

DataSet<Tuple2<String, Integer>> result = WordCount.startWordCount(env, lines);

List<Tuple2<String, Integer>> collect = result.collect();
 
assertThat(collect).containsExactlyInAnyOrder(
  new Tuple2<>("a", 3), new Tuple2<>("sentence", 2), new Tuple2<>("word", 1),
  new Tuple2<>("is", 2), new Tuple2<>("this", 2), new Tuple2<>("second", 1),
  new Tuple2<>("first", 1), new Tuple2<>("with", 1), new Tuple2<>("one", 1));

6. 数据流接口

6.1. 创建数据流

Apache Flink 还支持通过其 DataStream API 处理事件流。如果我们想开始使用事件,我们首先需要使用StreamExecutionEnvironment类:

StreamExecutionEnvironment executionEnvironment
 = StreamExecutionEnvironment.getExecutionEnvironment();

接下来,我们可以使用来自各种来源的executionEnvironment创建事件流。它可以是像Apache Kafka 这样的消息总线,但在这个例子中,我们将简单地从几个字符串元素创建一个源:

DataStream<String> dataStream = executionEnvironment.fromElements(
  "This is a first sentence", 
  "This is a second sentence with a one word");

我们可以像在普通的 DataSet类中一样将转换应用于DataStream的每个元素:

SingleOutputStreamOperator<String> upperCase = text.map(String::toUpperCase);

要触发执行,我们需要调用一个接收器操作,例如print(),该操作只会将转换的结果打印到标准输出中,然后是StreamExecutionEnvironment类上的execute()方法:

upperCase.print();
env.execute();

它将生成以下输出:

1> THIS IS A FIRST SENTENCE
2> THIS IS A SECOND SENTENCE WITH A ONE WORD

6.2. 事件的窗口化

实时处理事件流时,有时可能需要将事件分组在一起,并在这些事件的窗口上应用一些计算。

假设我们有一个事件流,其中每个事件都是一对,由事件编号和事件发送到我们系统时的时间戳组成,我们可以容忍无序事件,但前提是它们迟到不超过二十秒。

对于此示例,让我们首先创建一个模拟相隔几分钟的两个事件的流,并定义一个时间戳提取器来指定我们的延迟阈值:

SingleOutputStreamOperator<Tuple2<Integer, Long>> windowed
  = env.fromElements(
  new Tuple2<>(16, ZonedDateTime.now().plusMinutes(25).toInstant().getEpochSecond()),
  new Tuple2<>(15, ZonedDateTime.now().plusMinutes(2).toInstant().getEpochSecond()))
  .assignTimestampsAndWatermarks(
    new BoundedOutOfOrdernessTimestampExtractor
      <Tuple2<Integer, Long>>(Time.seconds(20)) {
 
        @Override
        public long extractTimestamp(Tuple2<Integer, Long> element) {
          return element.f1 * 1000;
        }
    });

接下来,让我们定义一个窗口操作,将事件分组为五秒窗口,并对这些事件应用转换:

SingleOutputStreamOperator<Tuple2<Integer, Long>> reduced = windowed
  .windowAll(TumblingEventTimeWindows.of(Time.seconds(5)))
  .maxBy(0, true);
reduced.print();

它将每五秒获得窗口的最后一个元素,因此它会打印出来:

1> (15,1491221519)

请注意,我们看不到第二个事件,因为它的到达时间晚于指定的延迟阈值。

7. 结论

在本文中,我们介绍了 Apache Flink 框架,并查看了其 API 提供的一些转换。

我们使用 Flink 流畅且实用的 DataSet API 实现了一个字数统计程序。然后,我们查看了 DataStream API,并对事件流实现了简单的实时转换。

posted @ 2023-02-24 12:04  JackYang  阅读(1060)  评论(1)    收藏  举报
刷新页面返回顶部
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3