FLINKエントリ（E） - DataSetのAPIはプログラミングガイド

ファイル

ApacheのFLINK

ApacheのFLINKは、両方の高スループット、低レイテンシ、高性能分散処理フレームワークです。リアルタイムコンピューティング、今日の上昇は、FLINKが活況を呈しています。両方の長所とバッチ処理の流れ特性のパフォーマンス以来、FLINKは全体ビッグデータの生態を破壊することがあります。

ファイル

DataSetのAPI

します。https：//flink.apache.org/downloads.html FLINKファーストを実行するには、我々は、ダウンロードしてFLINKバイナリパッケージ解凍し、次のアドレスをダウンロードする必要があります

私たちは、FLINKは、我々は最新の1.9バージョンを選択Scalaのバージョン、と組み合わせて選択することができますScalaの2.12のためのApache FLINK 1.9.0をダウンロードします。

ダウンロードが成功したら、WindowsシステムでFLINKを実行するには、WindowsまたはCygwinのbatファイルをすることができます。

このようなHadoopのクラスタおよびLinuxシステムのように、スタンドアローンの状況、各種のに分割されています。

参照してください：FLINKエントリ（3） -環境と展開

FLINKプログラミングモデルは、FLINKはストリーミングまたはバッチ・アプリケーションの開発に異なる抽象化レベルを提供し、本論文では、我々は、DataSetのAPI、FLINK最も一般的に使用されるバッチ・プログラミング・モデルをご紹介します。

ファイル

FLINKデータセットプログラムは、従来のデータセットの変換プログラム（例えば、フィルタ、マッピング、接続、パケット）に実装されています。最初に特定の供給源から（例えば、ファイルまたはローカルを読み取ることによって作成されたセットから）作成されたデータセット。受信側によって返された結果は、受信機は、例えば、データ（分散）または標準出力ファイル（例えば、コマンドライン端末）を書き込むことができます。FLINKプログラムは、スタンドアロンまたは他のプログラムに組み込まれた、様々な環境で実行することができます。実行は、ローカルJVMで実行することができ、多くのコンピュータのクラスタ上で実行することができます。

サンプルプログラム

次のプログラムは、WORDCOUNTの完全な作業例です。あなたはローカルで実行するためのコードをコピーして貼り付けることができます。

ジャワ

public class WordCountExample {
    public static void main(String[] args) throws Exception {
        final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

        DataSet<String> text = env.fromElements(
            "Who's there?",
            "I think I hear them. Stand, ho! Who's there?");

        DataSet<Tuple2<String, Integer>> wordCounts = text
            .flatMap(new LineSplitter())
            .groupBy(0)
            .sum(1);

        wordCounts.print();
    }

    public static class LineSplitter implements FlatMapFunction<String, Tuple2<String, Integer>> {
        @Override
        public void flatMap(String line, Collector<Tuple2<String, Integer>> out) {
            for (String word : line.split(" ")) {
                out.collect(new Tuple2<String, Integer>(word, 1));
            }
        }
    }
}

スカラ

import org.apache.flink.api.scala._

object WordCount {
  def main(args: Array[String]) {

    val env = ExecutionEnvironment.getExecutionEnvironment
    val text = env.fromElements(
      "Who's there?",
      "I think I hear them. Stand, ho! Who's there?")

    val counts = text.flatMap { _.toLowerCase.split("\\W+") filter { _.nonEmpty } }
      .map { (_, 1) }
      .groupBy(0)
      .sum(1)

    counts.print()
  }
}

データセットの変換

データ変換は、1つまたは複数の新しいデータセットDataSetに変換されます。手順複数の複雑な組み合わせアセンブリに変換することができます。

DataSet API 中最重要的就是这些算子，我们将数据接入后，通过这些算子对数据进行处理，得到我们想要的结果。

Java版算子如下：

转换	描述
Map	采用一个数据元并生成一个数据元。`data.map(new MapFunction<String, Integer>() { public Integer map(String value) { return Integer.parseInt(value); } });`
FlatMap	采用一个数据元并生成零个，一个或多个数据元。`data.flatMap(new FlatMapFunction<String, String>() { public void flatMap(String value, Collector<String> out) { for (String s : value.split(" ")) { out.collect(s); } } });`
MapPartition	在单个函数调用中转换并行分区。该函数将分区作为`Iterable`流来获取，并且可以生成任意数量的结果值。每个分区中的数据元数量取决于并行度和先前的算子操作。`data.mapPartition(new MapPartitionFunction<String, Long>() { public void mapPartition(Iterable<String> values, Collector<Long> out) { long c = 0; for (String s : values) { c++; } out.collect(c); } });`
Filter	计算每个数据元的布尔函数，并保存函数返回true的数据元。重要信息：系统假定该函数不会修改应用谓词的数据元。违反此假设可能会导致错误的结果。`data.filter(new FilterFunction<Integer>() { public boolean filter(Integer value) { return value > 1000; } });`
Reduce	通过将两个数据元重复组合成一个数据元，将一组数据元组合成一个数据元。Reduce可以应用于完整数据集或分组数据集。`data.reduce(new ReduceFunction<Integer> { public Integer reduce(Integer a, Integer b) { return a + b; } });`如果将reduce应用于分组数据集，则可以通过提供`CombineHint`to 来指定运行时执行reduce的组合阶段的方式 `setCombineHint`。在大多数情况下，基于散列的策略应该更快，特别是如果不同键的数量与输入数据元的数量相比较小（例如1/10）。
ReduceGroup	将一组数据元组合成一个或多个数据元。ReduceGroup可以应用于完整数据集或分组数据集。`data.reduceGroup(new GroupReduceFunction<Integer, Integer> { public void reduce(Iterable<Integer> values, Collector<Integer> out) { int prefixSum = 0; for (Integer i : values) { prefixSum += i; out.collect(prefixSum); } } });`
Aggregate	将一组值聚合为单个值。聚合函数可以被认为是内置的reduce函数。聚合可以应用于完整数据集或分组数据集。`Dataset<Tuple3<Integer, String, Double>> input = // [...] DataSet<Tuple3<Integer, String, Double>> output = input.aggregate(SUM, 0).and(MIN, 2);`您还可以使用简写语法进行最小，最大和总和聚合。`Dataset<Tuple3<Integer, String, Double>> input = // [...] DataSet<Tuple3<Integer, String, Double>> output = input.sum(0).andMin(2);`
Distinct	返回数据集的不同数据元。它相对于数据元的所有字段或字段子集从输入DataSet中删除重复条目。`data.distinct();`使用reduce函数实现Distinct。您可以通过提供`CombineHint`to 来指定运行时执行reduce的组合阶段的方式 `setCombineHint`。在大多数情况下，基于散列的策略应该更快，特别是如果不同键的数量与输入数据元的数量相比较小（例如1/10）。
Join	通过创建在其键上相等的所有数据元对来连接两个数据集。可选地使用JoinFunction将数据元对转换为单个数据元，或使用FlatJoinFunction将数据元对转换为任意多个（包括无）数据元。请参阅键部分以了解如何定义连接键。`result = input1.join(input2) .where(0) // key of the first input (tuple field 0) .equalTo(1); // key of the second input (tuple field 1)`您可以通过Join Hints指定运行时执行连接的方式。提示描述了通过分区或广播进行连接，以及它是使用基于排序还是基于散列的算法。有关可能的提示和示例的列表，请参阅“ 转换指南”。如果未指定提示，系统将尝试估算输入大小，并根据这些估计选择最佳策略。`// This executes a join by broadcasting the first data set // using a hash table for the broadcast data result = input1.join(input2, JoinHint.BROADCAST_HASH_FIRST) .where(0).equalTo(1);`请注意，连接转换仅适用于等连接。其他连接类型需要使用OuterJoin或CoGroup表示。
OuterJoin	在两个数据集上执行左，右或全外连接。外连接类似于常规（内部）连接，并创建在其键上相等的所有数据元对。此外，如果在另一侧没有找到匹配的Keys，则保存“外部”侧（左侧，右侧或两者都满）的记录。匹配数据元对（或一个数据元和`null`另一个输入的值）被赋予JoinFunction以将数据元对转换为单个数据元，或者转换为FlatJoinFunction以将数据元对转换为任意多个（包括无）数据元。请参阅键部分以了解如何定义连接键。`input1.leftOuterJoin(input2) // rightOuterJoin or fullOuterJoin for right or full outer joins .where(0) // key of the first input (tuple field 0) .equalTo(1) // key of the second input (tuple field 1) .with(new JoinFunction<String, String, String>() { public String join(String v1, String v2) { // NOTE: // - v2 might be null for leftOuterJoin // - v1 might be null for rightOuterJoin // - v1 OR v2 might be null for fullOuterJoin } });`
CoGroup	reduce 算子操作的二维变体。将一个或多个字段上的每个输入分组，然后关联组。每对组调用转换函数。请参阅keys部分以了解如何定义coGroup键。`data1.coGroup(data2) .where(0) .equalTo(1) .with(new CoGroupFunction<String, String, String>() { public void coGroup(Iterable<String> in1, Iterable<String> in2, Collector<String> out) { out.collect(...); } });`
Cross	构建两个输入的笛卡尔积（交叉乘积），创建所有数据元对。可选择使用CrossFunction将数据元对转换为单个数据元`DataSet<Integer> data1 = // [...] DataSet<String> data2 = // [...] DataSet<Tuple2<Integer, String>> result = data1.cross(data2);`注：交叉是一个潜在的非常计算密集型算子操作它甚至可以挑战大的计算集群！建议使用crossWithTiny（）和crossWithHuge（）来提示系统的DataSet大小。
Union	生成两个数据集的并集。`DataSet<String> data1 = // [...] DataSet<String> data2 = // [...] DataSet<String> result = data1.union(data2);`
Rebalance	均匀地Rebalance 数据集的并行分区以消除数据偏差。只有类似Map的转换可能会遵循Rebalance 转换。`DataSet<String> in = // [...] DataSet<String> result = in.rebalance() .map(new Mapper());`
Hash-Partition	散列分区给定键上的数据集。键可以指定为位置键，表达键和键选择器函数。`DataSet<Tuple2<String,Integer>> in = // [...] DataSet<Integer> result = in.partitionByHash(0) .mapPartition(new PartitionMapper());`
Range-Partition	Range-Partition给定键上的数据集。键可以指定为位置键，表达键和键选择器函数。`DataSet<Tuple2<String,Integer>> in = // [...] DataSet<Integer> result = in.partitionByRange(0) .mapPartition(new PartitionMapper());`
Custom Partitioning	手动指定数据分区。注意：此方法仅适用于单个字段键。`DataSet<Tuple2<String,Integer>> in = // [...] DataSet<Integer> result = in.partitionCustom(Partitioner<K> partitioner, key)`
Sort Partition	本地按指定顺序对指定字段上的数据集的所有分区进行排序。可以将字段指定为元组位置或字段表达式。通过链接sortPartition（）调用来完成对多个字段的排序。`DataSet<Tuple2<String,Integer>> in = // [...] DataSet<Integer> result = in.sortPartition(1, Order.ASCENDING) .mapPartition(new PartitionMapper());`
First-n	返回数据集的前n个（任意）数据元。First-n可以应用于常规数据集，分组数据集或分组排序数据集。分组键可以指定为键选择器函数或字段位置键。`DataSet<Tuple2<String,Integer>> in = // [...] // regular data set DataSet<Tuple2<String,Integer>> result1 = in.first(3); // grouped data set DataSet<Tuple2<String,Integer>> result2 = in.groupBy(0) .first(3); // grouped-sorted data set DataSet<Tuple2<String,Integer>> result3 = in.groupBy(0) .sortGroup(1, Order.ASCENDING) .first(3);`

数据源

数据源创建初始数据集，例如来自文件或Java集合。创建数据集的一般机制是在InputFormat后面抽象的。Flink附带了几种内置格式，可以从通用文件格式创建数据集。他们中的许多人在ExecutionEnvironment上都有快捷方法。

基于文件的：

readTextFile(path)/ TextInputFormat- 按行读取文件并将其作为字符串返回。
readTextFileWithValue(path)/ TextValueInputFormat- 按行读取文件并将它们作为StringValues返回。StringValues是可变字符串。
readCsvFile(path)/ CsvInputFormat- 解析逗号（或其他字符）分隔字段的文件。返回元组或POJO的DataSet。支持基本java类型及其Value对应作为字段类型。
readFileOfPrimitives(path, Class)/ PrimitiveInputFormat- 解析新行（或其他字符序列）分隔的原始数据类型（如String或）的文件Integer。
readFileOfPrimitives(path, delimiter, Class)/ PrimitiveInputFormat- 解析新行（或其他字符序列）分隔的原始数据类型的文件，例如String或Integer使用给定的分隔符。
readSequenceFile(Key, Value, path)/ SequenceFileInputFormat- 创建一个JobConf并从类型为SequenceFileInputFormat，Key class和Value类的指定路径中读取文件，并将它们作为Tuple2 <Key，Value>返回。

基于集合：

fromCollection(Collection) - 从Java Java.util.Collection创建数据集。集合中的所有数据元必须属于同一类型。
fromCollection(Iterator, Class) - 从迭代器创建数据集。该类指定迭代器返回的数据元的数据类型。
fromElements(T ...) - 根据给定的对象序列创建数据集。所有对象必须属于同一类型。
fromParallelCollection(SplittableIterator, Class) - 并行地从迭代器创建数据集。该类指定迭代器返回的数据元的数据类型。
generateSequence(from, to) - 并行生成给定间隔中的数字序列。

通用：

readFile(inputFormat, path)/ FileInputFormat-入力ファイル形式を受け付けます。
createInput(inputFormat)/ InputFormat-一般的な入力形式を受け付けます。

例

ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

// read text file from local files system
DataSet<String> localLines = env.readTextFile("file:///path/to/my/textfile");

// read text file from a HDFS running at nnHost:nnPort
DataSet<String> hdfsLines = env.readTextFile("hdfs://nnHost:nnPort/path/to/my/textfile");

// read a CSV file with three fields
DataSet<Tuple3<Integer, String, Double>> csvInput = env.readCsvFile("hdfs:///the/CSV/file")
                           .types(Integer.class, String.class, Double.class);

// read a CSV file with five fields, taking only two of them
DataSet<Tuple2<String, Double>> csvInput = env.readCsvFile("hdfs:///the/CSV/file")
                               .includeFields("10010")  // take the first and the fourth field
                           .types(String.class, Double.class);

// read a CSV file with three fields into a POJO (Person.class) with corresponding fields
DataSet<Person>> csvInput = env.readCsvFile("hdfs:///the/CSV/file")
                         .pojoType(Person.class, "name", "age", "zipcode");

// read a file from the specified path of type SequenceFileInputFormat
DataSet<Tuple2<IntWritable, Text>> tuples =
 env.readSequenceFile(IntWritable.class, Text.class, "hdfs://nnHost:nnPort/path/to/file");

// creates a set from some given elements
DataSet<String> value = env.fromElements("Foo", "bar", "foobar", "fubar");

// generate a number sequence
DataSet<Long> numbers = env.generateSequence(1, 10000000);

// Read data from a relational database using the JDBC input format
DataSet<Tuple2<String, Integer> dbData =
    env.createInput(
      JDBCInputFormat.buildJDBCInputFormat()
                     .setDrivername("org.apache.derby.jdbc.EmbeddedDriver")
                     .setDBUrl("jdbc:derby:memory:persons")
                     .setQuery("select name, age from persons")
                     .setRowTypeInfo(new RowTypeInfo(BasicTypeInfo.STRING_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO))
                     .finish()
    );

// Note: Flink's program compiler needs to infer the data types of the data items which are returned
// by an InputFormat. If this information cannot be automatically inferred, it is necessary to
// manually provide the type information as shown in the examples above.

データソース及び受信機を収集

入力ファイルを作成することで、解析プログラムを完了するために、入力し、出力ファイルを読み込み、その出力を確認することは非常に面倒です。FLINK簡素化試験のJavaサポートによって設定された特別なデータソース及び受信機を有します。プログラムがテストされた後、ソース及び受信機は簡単/書き込み外部データ記憶装置（例えば、HDFS）ソースを読み取り、受信機によって置き換えることができます。

開発では、私たちはしばしば直接データソースを受信する受信機を使用しています。

final ExecutionEnvironment env = ExecutionEnvironment.createLocalEnvironment();

// Create a DataSet from a list of elements
DataSet<Integer> myInts = env.fromElements(1, 2, 3, 4, 5);

// Create a DataSet from any Java collection
List<Tuple2<String, Integer>> data = ...
DataSet<Tuple2<String, Integer>> myTuples = env.fromCollection(data);

// Create a DataSet from an Iterator
Iterator<Long> longIt = ...
DataSet<Long> myLongs = env.fromCollection(longIt, Long.class);

放送変数

オペレータ入力変数の従来の動作に加えて、次のデータセットを提供するために、すべてのインスタンスを並列算術演算子をブロードキャストすることを可能にします。これは、補助データ・セットまたは関連データのパラメータのために有用です。その後、オペレータは、コレクションとしてデータセットにアクセスすることができます。

// 1. The DataSet to be broadcast
DataSet<Integer> toBroadcast = env.fromElements(1, 2, 3);

DataSet<String> data = env.fromElements("a", "b");

data.map(new RichMapFunction<String, String>() {
    @Override
    public void open(Configuration parameters) throws Exception {
      // 3. Access the broadcast DataSet as a Collection
      Collection<Integer> broadcastSet = getRuntimeContext().getBroadcastVariable("broadcastSetName");
    }


    @Override
    public String map(String value) throws Exception {
        ...
    }
}).withBroadcastSet(toBroadcast, "broadcastSetName"); // 2. Broadcast the DataSet

分散キャッシュ

FLINKは、Apache Hadoopの、ユーザ機能のローカルインスタンスへの並列アクセスと同様分散キャッシュを提供します。この関数は、回帰モデルの辞書や機械学習などの静的外部データを含むファイルを共有するために使用することができます。

ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

// register a file from HDFS
env.registerCachedFile("hdfs:///path/to/your/file", "hdfsFile")

// register a local executable file (script, executable, ...)
env.registerCachedFile("file:///path/to/exec/file", "localExecFile", true)

// define your program and execute
...
DataSet<String> input = ...
DataSet<Integer> result = input.map(new MyMapper());
...
env.execute();

これらは、DataSetのAPIは、実際には、使用されたされ、そして火花は非常に似ている、我々はデータにアクセスするには、データ処理のための演算子の様々なを使用することができます。

FLINKデモコード

FLINKシリーズ：

FLINKエントリ（） - ApacheのFLINKが紹介
 エントリFLINK（2） -導入FLINKアーキテクチャ

FLINKエントリ（3） - 環境と展開

FLINKエントリ（4） - プログラミング・モデル

よりリアルタイム計算、FLINK、カフカやその他の関連技術ボーエン、リアルタイムのストリーミングを計算するために歓迎の注意

ファイル