转化算子(transform operator)将一个或多个DataStream转换为新的DataStream,如此下去可以将多个转换组合成复杂的数据流拓扑。
本节介绍了基本转换,应用这些转换的有效物理分区(partition),以及对Flink转换chain的深入介绍。
目录
- DataStream转换
- 物理分区
- 任务链和资源组
DataStream转换
- map
DataStream→DataStream |
读取一个元素并生成一个元素。例如,一个map函数,它将输入流的值加倍:
DataStream dataStream = //...
dataStream.map(new MapFunction() {
@Override
public Integer map(Integer value) throws Exception {
return 2 * value;
}
});
- FlatMap
DataStream→DataStream
读取一个元素,并生成零个、一个或多个元素。例如:将句子分割为单词的flatmap函数:
dataStream.flatMap(new FlatMapFunction() {
@Override
public void flatMap(String value, Collector out)
throws Exception {
for(String word: value.split(" ")){
out.collect(word);
}
}
});
- Filter
DataStream→DataStream
将每个元素输入的filter布尔函数:仅保留filter函数返回true的那部分元素,filter返回false的元素会被过滤掉。例如:过滤掉零值的过滤器:
dataStream.filter(new FilterFunction() {
@Override
public boolean filter(Integer value) throws Exception {
return value != 0;
}
});
- KeyBy
DataStream→KeyedStream |
在逻辑上将流分区为互不相交的分区。具有相同key的所有记录会分配给到同一分区。在内部,keyBy()是使用hash分区实现。在flink中有多种指定键的方法
此转换返回的是KeyedStream,其中包括key-state。
dataStream.keyBy("someKey") // Key by field "someKey"
dataStream.keyBy(0) // Key by the first element of a Tuple
注意 :
- 它是POJO类型,但不覆盖hashCode()方法,key内部是hash分区依赖于hashCode()方法的实现。
- 任何类型的数组也不能成为key。
- reduce
KeyedStream→DataStream
注意reduce函数是将KeyedStream转换为DataStream,也就是reduce调用前必须进行分区,即得先调用
keyBy()
函数
在分区的数据流上调用reduce函数:将当前元素与最后一个reduce的值合并生成新值。
例如:一个求和的reduce函数:
keyedStream.reduce(new ReduceFunction() {
@Override
public Integer reduce(Integer value1, Integer value2)
throws Exception {
return value1 + value2;
}
});
- Fold
KeyedStream→DataStream
注意Fold转换必须是基于KeyedStream(比如先执行keyBy操作)。
在一个初始值上进行Fold操作:将当前值和上一次Fold产生的值进行合并产生一个新的值:
比如:将Fold函数应用于(1,2,3,4,5)时,结果为:“start-1”,“start-1-2”,“start-1-2-3”,. ..
DataStream result =
keyedStream.fold("start", new FoldFunction() {
@Override
public String fold(String current, Integer value) {
return current + "-" + value;
}
});
- Aggregations(聚合)
KeyedStream→DataStream
min和minBy之间的差异是min返回最小值,而minBy返回该字段中具有最小值的元素(max和maxBy相同)。
keyedStream.sum(0);
keyedStream.sum("key");
keyedStream.min(0);
keyedStream.min("key");
keyedStream.max(0);
keyedStream.max("key");
keyedStream.minBy(0);
keyedStream.minBy("key");
keyedStream.maxBy(0);
keyedStream.maxBy("key");
- Window
KeyedStream→WindowedStream
可以在已经分区的KeyedStream上定义Windows。Windows根据某些特征(例如,在最后5秒内到达的数据)对每个key中的数据进行分组。有关窗口的完整说明,请参见windows。
dataStream.keyBy(0).window(TumblingEventTimeWindows.of(Time.seconds(5))); // Last 5 seconds of data
- WindowAll
DataStream→AllWindowedStream
Windows可以在常规DataStream上定义。Windows根据某些特征(例如,在最后5秒内到达的数据)对所有流事件进行分组。有关窗口的完整说明,请参见windows。
警告:在许多情况下,这是非并行转换。对于indowAll运算算子来说所有记录将收集在一个任务中。
dataStream.windowAll(TumblingEventTimeWindows.of(Time.seconds(5))); // Last 5 seconds of data
- Window Apply
WindowedStream→DataStream
AllWindowedStream→DataStream |
将一般性函数应用于整个窗口。下面是一个求和窗口函数。
注意:如果您正在使用windowAll转换,则需要使用AllWindowFunction。
windowedStream.apply (new WindowFunction, Integer, Tuple, Window>() {
public void apply (Tuple tuple,
Window window,
Iterable> values,
Collector out) throws Exception {
int sum = 0;
for (value t: values) {
sum += t.f1;
}
out.collect (new Integer(sum));
}
});
// applying an AllWindowFunction on non-keyed window stream
allWindowedStream.apply (new AllWindowFunction, Integer, Window>() {
public void apply (Window window,
Iterable> values,
Collector out) throws Exception {
int sum = 0;
for (value t: values) {
sum += t.f1;
}
out.collect (new Integer(sum));
}
});
- Window Reduce
WindowedStream→DataStream |
将reduce函数应用于窗口。返回reduce后的新结果。
windowedStream.reduce (new ReduceFunction>() {
public Tuple2 reduce(Tuple2 value1, Tuple2 value2) throws Exception {
return new Tuple2(value1.f0, value1.f1 + value2.f1);
}
});
- Window Fold
WindowedStream→DataStream
将fold函数应用于窗口并返回新的值。示例函数应用于序列(1,2,3,4,5)时,fold函数的输出为字符串“start-1-2-3-4-5”:
windowedStream.fold("start", new FoldFunction() {
public String fold(String current, Integer value) {
return current + "-" + value;
}
});
- Windows上的聚合
WindowedStream→DataStream
聚合窗口上的内容。min和minBy之间的差异是:min返回最小值,而minBy返回该字段中具有最小值的元素(max和maxBy相同)。
windowedStream.sum(0);
windowedStream.sum("key");
windowedStream.min(0);
windowedStream.min("key");
windowedStream.max(0);
windowedStream.max("key");
windowedStream.minBy(0);
windowedStream.minBy("key");
windowedStream.maxBy(0);
windowedStream.maxBy("key");
- Union
DataStream *→DataStream
两个或多个数据流的联合,创建包含来自所有流的所有元素的新流。注意:如果将数据流与其自身联合,则会在结果流中获取两次元素。
dataStream.union(otherStream1, otherStream2, ...);
- Window join
DataStream,DataStream→DataStream |
在给定key和公共窗口上连接两个数据流。
dataStream.join(otherStream)
.where().equalTo()
.window(TumblingEventTimeWindows.of(Time.seconds(3)))
.apply (new JoinFunction () {...});
- Window CoGroup
DataStream,DataStream→DataStream |
在给定key和公共窗口上对两个数据流进行Cogroup。
dataStream.coGroup(otherStream)
.where(0).equalTo(1)
.window(TumblingEventTimeWindows.of(Time.seconds(3)))
.apply (new CoGroupFunction () {...});
- Connect
DataStream,DataStream→ConnectedStreams |
“连接”两个保留其类型的数据流。连接操作允许两个流之间的共享状态。
DataStream someStream = //...
DataStream otherStream = //...
ConnectedStreams connectedStreams = someStream.connect(otherStream);
- CoMap,CoFlatMap
ConnectedStreams→DataStream
类似于ConnectedStreams上的map和flatMap
connectedStreams.map(new CoMapFunction() {
@Override
public Boolean map1(Integer value) {
return true;
}
@Override
public Boolean map2(String value) {
return false;
}
});
connectedStreams.flatMap(new CoFlatMapFunction() {
@Override
public void flatMap1(Integer value, Collector out) {
out.collect(value.toString());
}
@Override
public void flatMap2(String value, Collector out) {
for (String word: value.split(" ")) {
out.collect(word);
}
}
});
- Split
DataStream→SplitStream
根据某些标准将流拆分为两个或更多个流。
SplitStream split = someDataStream.split(new OutputSelector() {
@Override
public Iterable select(Integer value) {
List output = new ArrayList();
if (value % 2 == 0) {
output.add("even");
}
else {
output.add("odd");
}
return output;
}
});
- Select
SplitStream→DataStream
从split流中选择一个或多个流。
SplitStream split;
DataStream even = split.select("even");
DataStream odd = split.select("odd");
DataStream all = split.select("even","odd");
- 迭代
DataStream→IterativeStream→DataStream |
通过将一个运算符的输出重定向到某个先前的运算符,在流中创建“反馈”循环。这对于定义不断更新模型的算法特别有用。以下代码以流开头并连续应用迭代体。大于0的元素将被发送回反馈通道,其余元素将向下游转发。有关完整说明,请参阅迭代。
IterativeStream iteration = initialStream.iterate();
DataStream iterationBody = iteration.map (/*do something*/);
DataStream feedback = iterationBody.filter(new FilterFunction(){
@Override
public boolean filter(Long value) throws Exception {
return value > 0;
}
});
iteration.closeWith(feedback);
DataStream output = iterationBody.filter(new FilterFunction(){
@Override
public boolean filter(Long value) throws Exception {
return value <= 0;
}
});
物理分区
Flink还通过以下函数对转换后的stream进行精确分区、进行low-level控制(如果需要)。
- 自定义分区
DataStream→DataStream
使用用户定义的分区程序(Partitioner )为每个元素选择目标分区。
dataStream.partitionCustom(partitioner, "someKey");
dataStream.partitionCustom(partitioner, 0);
- 随机分区
DataStream→DataStream
均匀分布随机分配元素:(均匀分布)
dataStream.shuffle();
- 重新平衡(循环分区)
DataStream→DataStream
对元素循环分区,每个分区的负载相等。在存在数据偏斜时,用于性能优化。
dataStream.rebalance();