大数据-115 - Flink DataStream Transformation 多个函数方法 FlatMap Window Aggregations Reduce 原创
点一下关注吧!!!非常感谢!!持续更新!!!
目前已经更新到了:
- Hadoop(已更完)
- HDFS(已更完)
- MapReduce(已更完)
- Hive(已更完)
- Flume(已更完)
- Sqoop(已更完)
- Zookeeper(已更完)
- HBase(已更完)
- Redis (已更完)
- Kafka(已更完)
- Spark(已更完)
- Flink(正在更新!)
章节内容
上节我们完成了如下的内容:
- Flink DataStream API
- Rich并行源 并行源
Flink针对DataStream提供了大量的已经实现的算子
Map
DataStream -> DataStream,获取一个元素并产生一个元素。
以下是将输入流中的值*2的映射函数:
DataStream<Integer> dataStream = //...
dataStream.map(new MapFunction<Integer, Integer>() {
@Override
public Integer map(Integer value) throws Exception {
return 2 * value;
}
});
FlatMap
DataStream -> DataStream
获取一个元素,产生0个、1个、多个元素。
以下是一个FlapMap函数切分句子:
dataStream.flatMap(new FlatMapFunction<String, String>() {
@Override
public void flatMap(String value, Collector<String> out) throws Exception {
for(String word: value.split(" ")){
out.collect(word);
}
}
});
Filter
DataSteam -> DataStream
返回一个布尔值,如果满足条件就筛选出来。
以下是去掉0的值:
dataStream.filter(new FilterFunction<Integer>() {
@Override
public boolean filter(Integer value) throws Exception {
return value != 0;
}
});
KeyBy
DataStream -> KeyedStream
将流逻辑上划分为不相交的分区。所有具有相同键的记录被分配到相同的分区。在函数的内部,keyBy() 使用哈希分区实现。
有不同的方法来指定键。 此转换返回一个 KeyedStream。
dataStream.keyBy(value -> value.getSomeKey())
dataStream.keyBy(value -> value.f0)
Reduce
KeyedStream -> DataStream
"滚动"归约是一种在数据流处理中常用的操作。简单来说,它是一个累积的过程,逐个处理流中的元素并将结果逐步更新。
- 键控数据流:这是指数据流中的元素根据某个键(如ID或类别)进行分组。
- 当前元素:这是指数据流中正在处理的当前记录。
- 上一个归约值:这是指之前已经处理过并累积的结果。
keyedStream.reduce(new ReduceFunction<Integer>() {
@Override
public Integer reduce(Integer value1, Integer value2) throws Exception {
return value1 + value2;
}
});
举一个例子:
部分和是一种典型的归约操作,它逐步计算出流中各元素的累积和。例如,对于一个输入数据流 [1, 2, 3, 4, 5],部分和的输出将是 [1, 3, 6, 10, 15]。也就是说:
- 第一个元素1的部分和是1。
- 第二个元素2的部分和是1+2=3。
- 第三个元素3的部分和是1+2+3=6。
- 以此类推。
通过这样的处理方式,你可以在数据流中实时地看到每一步累积的结果。
Fold
KeyedStream -> DataStream
对于带有初始值的键控数据流进行滚动折叠,将当前元素与上一个折叠值相互结合,并发出新值。
一个折叠函数,应用序列是:(1,2,3,4,5),会发出:start-1、start-1-2、start-1-2-3…
DataStream<String> result =
keyedStream.fold("start", new FoldFunction<Integer, String>() {
@Override
public String fold(String current, Integer value) {
return current + "-" + value;
}
});
Aggregations
KeyedStream -> DataStream
对KeyedStream进行滚动聚合,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上定义窗口,窗口根据某些特性(例如:最近5秒内到达的数据),对每个键中的数据进行分组。
// Last 5 seconds of data
dataStream.keyBy(value -> value.f0).window(TumblingEventTimeWindows.of(Time.seconds(5)));
WindowAll
DataStream -> AllWindowStream
可以在常规的 DataStream 上定义窗口,窗口根据某些特性(例如:最近5秒内到达的数据)对所有流事件进行分组。
// Last 5 seconds of data
dataStream.windowAll(TumblingEventTimeWindows.of(Time.seconds(5)));
Window Apply
WindowedStream -> DataStream
AllWindowedStream -> DataStream
对整个窗口应用一个通用函数:
windowedStream.apply (new WindowFunction<Tuple2<String,Integer>, Integer, Tuple,
Window>() {
public void apply (Tuple tuple,
Window window,
Iterable<Tuple2<String, Integer>> values,
Collector<Integer> 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<Tuple2<String,Integer>, Integer,
Window>() {
public void apply (Window window,
Iterable<Tuple2<String, Integer>> values,
Collector<Integer> out) throws Exception {
int sum = 0;
for (value t: values) {
sum += t.f1;
}
out.collect (new Integer(sum));
}
});
Window Reduce
WindowedStream -> DataStream
对于一个功能性Reduce函数应用于窗口,并返回简化的值。
windowedStream.reduce (new ReduceFunction<Tuple2<String,Integer>>() {
public Tuple2<String, Integer> reduce(Tuple2<String, Integer> value1,
Tuple2<String, Integer> value2) throws Exception {
return new Tuple2<String,Integer>(value1.f0, value1.f1 + value2.f1);
}
});
Window Fold
WindowedStream -> DataStream
应用一个函数式的折叠函数到窗口,并返回折叠后的值。
示例函数在序列(1,2,3,4,5)上应用时,将折叠成字符:start-1-2-3-4-5
windowedStream.fold("start", new FoldFunction<Integer, String>() {
public String fold(String current, Integer value) {
return current + "-" + value;
}
});
Aggregations on 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
将两个数据流按给定的键和一个公共窗口进行连接。
dataStream
.join(otherStream)
.where(<key selector>).equalTo(<key selector>)
.window(TumblingEventTimeWindows.of(Time.seconds(3)))
.apply (new JoinFunction () {...});
Interval Join
KeyedStream, KeyedStream -> DataStream
将两个具有相同键的键控流中的元素e1和e2在给定时间间隔内连接起来,使得e2的时间戳满足 e1.timestamp + lowerBound <= e2.timestamp <= e1.timestamp + upperBound
// this will join the two streams so that
// key1 == key2 && leftTs - 2 < rightTs < leftTs + 2
keyedStream.intervalJoin(otherKeyedStream)
.between(Time.milliseconds(-2), Time.milliseconds(2)) // lower and upper
bound
.upperBoundExclusive(true) // optional
.lowerBoundExclusive(true) // optional
.process(new IntervalJoinFunction() {...});
Window CoGroup
DataStream, DataStream -> DataStream
将两个数据流在给定键和公共窗口上进行合并。
dataStream.coGroup(otherStream)
.where(0).equalTo(1)
.window(TumblingEventTimeWindows.of(Time.seconds(3)))
.apply (new CoGroupFunction () {...});
Connect
DataStrean, DataStream -> ConnectedStreams
将两个数据流连接起来,保留他们的类型,连接允许在两个数据流之间共享。
DataStream<Integer> someStream = //...
DataStream<String> otherStream = //...
ConnectedStreams<Integer, String> connectedStreams =
someStream.connect(otherStream);
CoMap, CoFlatMap
ConnetedStreams -> DataStream
类似Map和FlatMap,只不过是连接流。
connectedStreams.map(new CoMapFunction<Integer, String, Boolean>() {
@Override
public Boolean map1(Integer value) {
return true;
}
@Override
public Boolean map2(String value) {
return false;
}
});
connectedStreams.flatMap(new CoFlatMapFunction<Integer, String, String>() {
@Override
public void flatMap1(Integer value, Collector<String> out) {
out.collect(value.toString());
}
@Override
public void flatMap2(String value, Collector<String> out) {
for (String word: value.split(" ")) {
out.collect(word);
}
}
});
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码,我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了,比商业数据库还牛
· 白话解读 Dapr 1.15:你的「微服务管家」又秀新绝活了
· 上周热点回顾(2.24-3.2)