Process Function用来构建事件驱动的应用以及实现自定义的业务逻辑,Flink提供了8个Process Function:
- ProcessFunction :最原始,自定义程度高,什么都能做
- KeyedProcessFunction:keyby后使用得process中传入得Process Function
- CoProcessFunction:connect后使用得process中传入得Process Function
- ProcessJoinFunction:两条流Join连接后使用得process中传入得Process Function
- BroadcastProcessFunction:广播流使用得process中传入得Process Function
- KeyedBroadcastProcessFunction:keyby广播流使用得process中传入得Process Function
- ProcessWindowFunction:开窗后使用得process中传入得Process Function
- ProcessAllWindowFunction:AllWindow后使用得process中传入得Process Function
ProcessFunction
ProcessFunction用来构建事件驱动的应用以及实现自定义的业务逻辑,用于DataStream。
ProcessFunction是一个低级的流处理操作,允许访问所有非循环流应用程序的基本构件:
- 事件events:数据流中的元素
- 状态state:用于容错和状态一致性,仅用于Keyed stream
- 定时器timers:支持事件时间和处理时间,仅用于Keyed stream
时间戳例子:
测试获取时间戳,过滤奇数数据。
package com.ts.processfunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.util.Collector;
public class Simple {
public static void main(String[] args) throws Exception {
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
// 并行度为1
env.setParallelism(1);
// 设置数据源,一共5个元素
DataStream<Tuple2<String,Integer>> dataStream = env.addSource(new SourceFunction<Tuple2<String, Integer>>() {
@Override
public void run(SourceContext<Tuple2<String, Integer>> ctx) throws Exception {
for(int i=1; i<6; i++) {
String name = "name" + i;
Integer value = i;
long timeStamp = System.currentTimeMillis();
// 将将数据和时间戳打印出来,用来验证数据
System.out.println(String.format("source,%s, %d, %d\n",
name,
value,
timeStamp));
// 发射一个元素,并且戴上了时间戳
ctx.collectWithTimestamp(new Tuple2<String, Integer>(name, value), timeStamp);
// 为了让每个元素的时间戳不一样,每发射一次就延时10毫秒
Thread.sleep(10);
}
}
@Override
public void cancel() {
}
});
// 过滤值为奇数的元素
SingleOutputStreamOperator<String> mainDataStream = dataStream
.process(new ProcessFunction<Tuple2<String, Integer>, String>() {
@Override
public void processElement(Tuple2<String, Integer> value, Context ctx, Collector<String> out) throws Exception {
// f1字段为奇数的元素不会进入下一个算子
if(0 == value.f1 % 2) {
out.collect(String.format("processElement,%s, %d, %d\n",
value.f0,
value.f1,
ctx.timestamp()));
}
}
});
// 打印结果,证明每个元素的timestamp确实可以在ProcessFunction中取得
mainDataStream.print();
env.execute("processfunction demo : simple");
}
}
---------
source,name1, 1, 1615280030807
source,name2, 2, 1615280030819
processElement,name2, 2, 1615280030819
source,name3, 3, 1615280030829
source,name4, 4, 1615280030840
processElement,name4, 4, 1615280030840
source,name5, 5, 1615280030851
旁路例子:
侧输出流输出。
package com.ts.processfunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;
import java.util.ArrayList;
import java.util.List;
public class SideOutput {
public static void main(String[] args) throws Exception {
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 并行度为1
env.setParallelism(1);
// 定义OutputTag
final OutputTag<String> outputTag = new OutputTag<String>("side-output"){};
// 创建一个List,里面有两个Tuple2元素
List<Tuple2<String, Integer>> list = new ArrayList<>();
list.add(new Tuple2("aaa", 1));
list.add(new Tuple2("bbb", 2));
list.add(new Tuple2("ccc", 3));
//通过List创建DataStream
DataStream<Tuple2<String, Integer>> fromCollectionDataStream = env.fromCollection(list);
//所有元素都进入mainDataStream,f1字段为奇数的元素进入SideOutput
SingleOutputStreamOperator<String> mainDataStream = fromCollectionDataStream
.process(new ProcessFunction<Tuple2<String, Integer>, String>() {
@Override
public void processElement(Tuple2<String, Integer> value, Context ctx, Collector<String> out) throws Exception {
//进入主流程的下一个算子
out.collect("main, name : " + value.f0 + ", value : " + value.f1);
//f1字段为奇数的元素进入SideOutput
if(1 == value.f1 % 2) {
ctx.output(outputTag, "side, name : " + value.f0 + ", value : " + value.f1);
}
}
});
// 禁止chanin,这样可以在页面上看清楚原始的DAG
mainDataStream.disableChaining();
// 取得旁路数据
DataStream<String> sideDataStream = mainDataStream.getSideOutput(outputTag);
mainDataStream.print();
sideDataStream.print();
env.execute("processfunction demo : sideoutput");
}
}
----------
side, name : aaa, value : 1
main, name : aaa, value : 1
side, name : ccc, value : 3
main, name : bbb, value : 2
main, name : ccc, value : 3
KeyedProcessFunction
KeyedProcessFunction 用来操作 KeyedStream。KeyedProcessFunction 会处理流的每一个元素,输出为 0 个、1 个或者多个元素。所有的 Process Function 都继承自RichFunction 接口,所以都有 open()、close()和 getRuntimeContext()等方法。而KeyedProcessFunction<K, I, O>还额外提供了两个方法:
-
processElement(I value, Context ctx, Collector out), 流中的每一个元素都会调用这个方法,调用结果将会放在 Collector 数据类型中输出。Context 可 以访问元素的时间戳,元素的 key,以及 TimerService 时间服务。Context 还可以将结果输出到别的流(side outputs)。
-
onTimer(long timestamp, OnTimerContext ctx, Collector out) 是一个回调函数。当之前注册的定时器触发时调用。参数 timestamp 为定时器所设定的触发的时间戳。Collector 为输出结果的集合。OnTimerContext 和processElement 的 Context 参数一样,提供了上下文的一些信息,例如定时器触发的时间信息(事件时间或者处理时间)。
分组聚合例子:
记录每个单词最新一次出现的时间,然后建一个十秒的定时器,十秒后如果发现这个单词没有再次出现,就把这个单词和它出现的总次数发送到下游算子
package com.ts.processfunction;
public class CountWithTimestamp {
public String key;
public long count;
public long lastModified;
}
package com.ts.processfunction;
import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;
import org.apache.flink.util.StringUtils;
public class Splitter implements FlatMapFunction<String, Tuple2<String, Integer>> {
@Override
public void flatMap(String s, Collector<Tuple2<String, Integer>> collector) throws Exception {
if(StringUtils.isNullOrWhitespaceOnly(s)) {
System.out.println("invalid line");
return;
}
for(String word : s.split(" ")) {
collector.collect(new Tuple2<String, Integer>(word, 1));
}
}
}
package com.ts.processfunction;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.AssignerWithPeriodicWatermarks;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.streaming.api.watermark.Watermark;
import org.apache.flink.util.Collector;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ProcessTime {
/**
* KeyedProcessFunction的子类,作用是将每个单词最新出现时间记录到backend,并创建定时器,
* 定时器触发的时候,检查这个单词距离上次出现是否已经达到10秒,如果是,就发射给下游算子
*/
static class CountWithTimeoutFunction extends KeyedProcessFunction<Tuple, Tuple2<String, Integer>, Tuple2<String, Long>> {
// 自定义状态
private ValueState<CountWithTimestamp> state;
@Override
public void open(Configuration parameters) throws Exception {
// 初始化状态,name是myState
state = getRuntimeContext().getState(new ValueStateDescriptor<>("myState", CountWithTimestamp.class));
}
@Override
public void processElement(
Tuple2<String, Integer> value,
Context ctx,
Collector<Tuple2<String, Long>> out) throws Exception {
// 取得当前是哪个单词
Tuple currentKey = ctx.getCurrentKey();
// 从backend取得当前单词的myState状态
CountWithTimestamp current = state.value();
// 如果myState还从未没有赋值过,就在此初始化
if (current == null) {
current = new CountWithTimestamp();
current.key = value.f0;
}
// 单词数量加一
current.count++;
// 取当前元素的时间戳,作为该单词最后一次出现的时间
current.lastModified = ctx.timestamp();
// 重新保存到backend,包括该单词出现的次数,以及最后一次出现的时间
state.update(current);
// 为当前单词创建定时器,十秒后后触发
long timer = current.lastModified + 10000;
ctx.timerService().registerProcessingTimeTimer(timer);
// 打印所有信息,用于核对数据正确性
System.out.println(String.format("process, %s, %d, lastModified : %d (%s), timer : %d (%s)\n\n",
currentKey.getField(0),
current.count,
current.lastModified,
time(current.lastModified),
timer,
time(timer)));
}
/**
* 定时器触发后执行的方法
* @param timestamp 这个时间戳代表的是该定时器的触发时间
* @param ctx
* @param out
* @throws Exception
*/
@Override
public void onTimer(
long timestamp,
OnTimerContext ctx,
Collector<Tuple2<String, Long>> out) throws Exception {
// 取得当前单词
Tuple currentKey = ctx.getCurrentKey();
// 取得该单词的myState状态
CountWithTimestamp result = state.value();
// 当前元素是否已经连续10秒未出现的标志
boolean isTimeout = false;
// timestamp是定时器触发时间,如果等于最后一次更新时间+10秒,就表示这十秒内已经收到过该单词了,
// 这种连续十秒没有出现的元素,被发送到下游算子
if (timestamp == result.lastModified + 10000) {
// 发送
out.collect(new Tuple2<String, Long>(result.key, result.count));
isTimeout = true;
}
// 打印数据,用于核对是否符合预期
System.out.println(String.format("ontimer, %s, %d, lastModified : %d (%s), stamp : %d (%s), isTimeout : %s\n\n",
currentKey.getField(0),
result.count,
result.lastModified,
time(result.lastModified),
timestamp,
time(timestamp),
String.valueOf(isTimeout)));
}
}
public static void main(String[] args) throws Exception {
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 并行度1
env.setParallelism(1);
// 处理时间
env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
// 监听本地9999端口,读取字符串
DataStream<String> socketDataStream = env.socketTextStream("localhost", 9999);
// 所有输入的单词,如果超过10秒没有再次出现,都可以通过CountWithTimeoutFunction得到
DataStream<Tuple2<String, Long>> timeOutWord = socketDataStream
// 对收到的字符串用空格做分割,得到多个单词
.flatMap(new Splitter())
// 设置时间戳分配器,用当前时间作为时间戳
.assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<Tuple2<String, Integer>>() {
@Override
public long extractTimestamp(Tuple2<String, Integer> element, long previousElementTimestamp) {
// 使用当前系统时间作为时间戳
return System.currentTimeMillis();
}
@Override
public Watermark getCurrentWatermark() {
// 本例不需要watermark,返回null
return null;
}
})
// 将单词作为key分区
.keyBy(0)
// 按单词分区后的数据,交给自定义KeyedProcessFunction处理
.process(new CountWithTimeoutFunction());
// 所有输入的单词,如果超过10秒没有再次出现,就在此打印出来
timeOutWord.print();
env.execute("ProcessFunction demo : KeyedProcessFunction");
}
public static String time(long timeStamp) {
return new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date(timeStamp));
}
}
----------
process, aaa, 1, lastModified : 1615364825631 (2021-03-10 04:27:05), timer : 1615364835631 (2021-03-10 04:27:15)
// 输入aaa后,十秒内不输入aaa,aaa会进入下游打印。
(aaa,1)
ontimer, aaa, 1, lastModified : 1615364825631 (2021-03-10 04:27:05), stamp : 1615364835631 (2021-03-10 04:27:15), isTimeout : true
process, aaa, 2, lastModified : 1615364837036 (2021-03-10 04:27:17), timer : 1615364847036 (2021-03-10 04:27:27)
process, aaa, 3, lastModified : 1615364838212 (2021-03-10 04:27:18), timer : 1615364848212 (2021-03-10 04:27:28)
// 输入aaa后,马上再输入一个aaa (aaa,2)不会打印,打印(aaa,3) 但是触发器的时间是aaa,2输入时触发的时间。
ontimer, aaa, 3, lastModified : 1615364838212 (2021-03-10 04:27:18), stamp : 1615364847036 (2021-03-10 04:27:27), isTimeout : false
(aaa,3)
ontimer, aaa, 3, lastModified : 1615364838212 (2021-03-10 04:27:18), stamp : 1615364848212 (2021-03-10 04:27:28), isTimeout : true
CoProcessFunction
CoProcessFunction用于连接2个输入流。对于2条输入流,DataStream API 提供了 CoProcessFunction 这样的 low-level
操作。CoProcessFunction 提供了操作每一个输入流的方法: processElement1()和processElement2()。
类似于 ProcessFunction,这两种方法都通过 Context 对象来调用。这个 Context对象可以访问事件数据,定时器时间戳,TimerService,以及 side outputs。CoProcessFunction 也提供了 onTimer()回调函数。
双流聚合例子:
package com.ts.processfunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.StringUtils;
public class WordCountMap implements MapFunction<String, Tuple2<String, Integer>> {
@Override
public Tuple2<String, Integer> map(String s) throws Exception {
if(StringUtils.isNullOrWhitespaceOnly(s)) {
System.out.println("invalid line");
return null;
}
String[] array = s.split(",");
if(null==array || array.length<2) {
System.out.println("invalid line for array");
return null;
}
return new Tuple2<>(array[0], Integer.valueOf(array[1]));
}
}
package com.ts.processfunction;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoProcessFunction;
/**
* @author will
* @email zq2599@gmail.com
* @date 2020-11-09 17:33
* @description 串起整个逻辑的执行类,用于体验CoProcessFunction
*/
public abstract class AbstractCoProcessFunctionExecutor {
/**
* 返回CoProcessFunction的实例,这个方法留给子类实现
* @return
*/
protected abstract CoProcessFunction<
Tuple2<String, Integer>,
Tuple2<String, Integer>,
Tuple2<String, Integer>> getCoProcessFunctionInstance();
/**
* 监听根据指定的端口,
* 得到的数据先通过map转为Tuple2实例,
* 给元素加入时间戳,
* 再按f0字段分区,
* 将分区后的KeyedStream返回
* @param port
* @return
*/
protected KeyedStream<Tuple2<String, Integer>, Tuple> buildStreamFromSocket(StreamExecutionEnvironment env, int port) {
return env
// 监听端口
.socketTextStream("localhost", port)
// 得到的字符串"aaa,3"转成Tuple2实例,f0="aaa",f1=3
.map(new WordCountMap())
// 将单词作为key分区
.keyBy(0);
}
/**
* 如果子类有侧输出需要处理,请重写此方法,会在主流程执行完毕后被调用
*/
protected void doSideOutput(SingleOutputStreamOperator<Tuple2<String, Integer>> mainDataStream) {
}
/**
* 执行业务的方法
* @throws Exception
*/
public void execute() throws Exception {
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 并行度1
env.setParallelism(1);
// 监听9998端口的输入
KeyedStream<Tuple2<String, Integer>, Tuple> stream1 = buildStreamFromSocket(env, 9998);
// 监听9999端口的输入
KeyedStream<Tuple2<String, Integer>, Tuple> stream2 = buildStreamFromSocket(env, 9999);
SingleOutputStreamOperator<Tuple2<String, Integer>> mainDataStream = stream1
// 两个流连接
.connect(stream2)
// 执行低阶处理函数,具体处理逻辑在子类中实现
.process(getCoProcessFunctionInstance());
// 将低阶处理函数输出的元素全部打印出来
mainDataStream.print();
// 侧输出相关逻辑,子类有侧输出需求时重写此方法
doSideOutput(mainDataStream);
// 执行
env.execute("ProcessFunction demo : CoProcessFunction");
}
}
package com.ts.processfunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.functions.co.CoProcessFunction;
import org.apache.flink.util.Collector;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CollectEveryOne extends AbstractCoProcessFunctionExecutor {
private static final Logger logger = LoggerFactory.getLogger(CollectEveryOne.class);
@Override
protected CoProcessFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple2<String, Integer>> getCoProcessFunctionInstance() {
return new CoProcessFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple2<String, Integer>>() {
@Override
public void processElement1(Tuple2<String, Integer> value, Context ctx, Collector<Tuple2<String, Integer>> out) {
System.out.println("处理1号流的元素:"+value);
out.collect(value);
}
@Override
public void processElement2(Tuple2<String, Integer> value, Context ctx, Collector<Tuple2<String, Integer>> out) {
System.out.println("处理2号流的元素:"+ value);
out.collect(value);
}
};
}
public static void main(String[] args) throws Exception {
new CollectEveryOne().execute();
}
}
----------
处理2号流的元素:(aaa,111)
(aaa,111)
处理1号流的元素:(bbb,111)
(bbb,111)
ProcessJoinFunction
用于Join流操作。
BroadcastProcessFunction
用于广播。
KeyedBroadcastProcessFunction
用于KeyBy之后的广播。
ProcessWindowFunction
用于窗口增量聚合。
增量聚合例子:
统计key在窗口中出现的次数,并打印总出现次数。
package com.ts.processfunction;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.streaming.api.functions.windowing.ProcessWindowFunction;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ProcessWindowFunctionDemo {
public static void main(String[] args) throws Exception {
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 使用事件时间
env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
// 并行度为1
env.setParallelism(1);
// 设置数据源,一共三个元素
DataStream<Tuple2<String,Integer>> dataStream = env.addSource(new SourceFunction<Tuple2<String, Integer>>() {
@Override
public void run(SourceContext<Tuple2<String, Integer>> ctx) throws Exception {
int aaaNum = 0;
int bbbNum = 0;
for(int i=1; i<Integer.MAX_VALUE; i++) {
// 只有aaa和bbb两种name
String name = 0==i%2 ? "aaa" : "bbb";
//更新aaa和bbb元素的总数
if(0==i%2) {
aaaNum++;
} else {
bbbNum++;
}
// 使用当前时间作为时间戳
long timeStamp = System.currentTimeMillis();
// 将数据和时间戳打印出来,用来验证数据
System.out.println(String.format("source,%s, %s, aaa total : %d, bbb total : %d\n",
name,
time(timeStamp),
aaaNum,
bbbNum));
// 发射一个元素,并且戴上了时间戳
ctx.collectWithTimestamp(new Tuple2<String, Integer>(name, 1), timeStamp);
// 每发射一次就延时1秒
Thread.sleep(1000);
}
}
@Override
public void cancel() {
}
});
// 将数据用5秒的滚动窗口做划分,再用ProcessWindowFunction
SingleOutputStreamOperator<String> mainDataStream = dataStream
// 以Tuple2的f0字段作为key,本例中实际上key只有aaa和bbb两种
.keyBy(value -> value.f0)
// 5秒一次的滚动窗口
.timeWindow(Time.seconds(5))
// 统计每个key当前窗口内的元素数量,然后把key、数量、窗口起止时间整理成字符串发送给下游算子
.process(new ProcessWindowFunction<Tuple2<String, Integer>, String, String, TimeWindow>() {
// 自定义状态
private ValueState<KeyCount> state;
@Override
public void open(Configuration parameters) throws Exception {
// 初始化状态,name是myState
state = getRuntimeContext().getState(new ValueStateDescriptor<>("myState", KeyCount.class));
}
@Override
public void process(String s, Context context, Iterable<Tuple2<String, Integer>> iterable, Collector<String> collector) throws Exception {
// 从backend取得当前单词的myState状态
KeyCount current = state.value();
// 如果myState还从未没有赋值过,就在此初始化
if (current == null) {
current = new KeyCount();
current.key = s;
current.count = 0;
}
int count = 0;
// iterable可以访问该key当前窗口内的所有数据,
// 这里简单处理,只统计了元素数量
for (Tuple2<String, Integer> tuple2 : iterable) {
count++;
}
// 更新当前key的元素总数
current.count += count;
// 更新状态到backend
state.update(current);
// 将当前key及其窗口的元素数量,还有窗口的起止时间整理成字符串
String value = String.format("window, %s, %s - %s, %d, total : %d\n",
// 当前key
s,
// 当前窗口的起始时间
time(context.window().getStart()),
// 当前窗口的结束时间
time(context.window().getEnd()),
// 当前key在当前窗口内元素总数
count,
// 当前key出现的总数
current.count);
// 发射到下游算子
collector.collect(value);
}
});
// 打印结果,通过分析打印信息,检查ProcessWindowFunction中可以处理所有key的整个窗口的数据
mainDataStream.print();
env.execute("processfunction demo : processwindowfunction");
}
public static String time(long timeStamp) {
return new SimpleDateFormat("hh:mm:ss").format(new Date(timeStamp));
}
static class KeyCount {
/**
* 分区key
*/
public String key;
/**
* 元素总数
*/
public long count;
}
}
----------
source,bbb, 04:45:01, aaa total : 0, bbb total : 1
source,aaa, 04:45:02, aaa total : 1, bbb total : 1
source,bbb, 04:45:03, aaa total : 1, bbb total : 2
source,aaa, 04:45:04, aaa total : 2, bbb total : 2
window, bbb, 04:45:00 - 04:45:05, 2, total : 2
window, aaa, 04:45:00 - 04:45:05, 2, total : 2
ProcessAllWindowFunction
用于全窗口聚合。
聚合例子:
统计全窗口5秒内数据数量。
package com.ts.processfunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.TimeCharacteristic;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.SourceFunction;
import org.apache.flink.streaming.api.functions.windowing.ProcessAllWindowFunction;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.util.Collector;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ProcessAllWindowFunctionDemo {
public static void main(String[] args) throws Exception {
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
// 使用事件时间
env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime);
// 并行度为1
env.setParallelism(1);
// 设置数据源,一共三个元素
DataStream<Tuple2<String,Integer>> dataStream = env.addSource(new SourceFunction<Tuple2<String, Integer>>() {
@Override
public void run(SourceContext<Tuple2<String, Integer>> ctx) throws Exception {
for(int i=1; i<Integer.MAX_VALUE; i++) {
// 只有aaa和bbb两种name
String name = 0==i%2 ? "aaa" : "bbb";
// 使用当前时间作为时间戳
long timeStamp = System.currentTimeMillis();
// 将数据和时间戳打印出来,用来验证数据
System.out.println(String.format("source,%s, %s\n",
name,
time(timeStamp)));
// 发射一个元素,并且带上了时间戳
ctx.collectWithTimestamp(new Tuple2<String, Integer>(name, 1), timeStamp);
// 每发射一次就延时1秒
Thread.sleep(1000);
}
}
@Override
public void cancel() {
}
});
// 将数据用5秒的滚动窗口做划分,再用ProcessAllWindowFunction
SingleOutputStreamOperator<String> mainDataStream = dataStream
// 5秒一次的滚动窗口
.timeWindowAll(Time.seconds(5))
// 统计当前窗口内的元素数量,然后把数量、窗口起止时间整理成字符串发送给下游算子
.process(new ProcessAllWindowFunction<Tuple2<String, Integer>, String, TimeWindow>() {
@Override
public void process(Context context, Iterable<Tuple2<String, Integer>> iterable, Collector<String> collector) throws Exception {
int count = 0;
// iterable可以访问当前窗口内的所有数据,
// 这里简单处理,只统计了元素数量
for (Tuple2<String, Integer> tuple2 : iterable) {
count++;
}
// 将当前窗口的起止时间和元素数量整理成字符串
String value = String.format("window, %s - %s, %d\n",
// 当前窗口的起始时间
time(context.window().getStart()),
// 当前窗口的结束时间
time(context.window().getEnd()),
// 当前key在当前窗口内元素总数
count);
// 发射到下游算子
collector.collect(value);
}
});
// 打印结果,通过分析打印信息,检查ProcessWindowFunction中可以处理所有key的整个窗口的数据
mainDataStream.print();
env.execute("processfunction demo : processallwindowfunction");
}
public static String time(long timeStamp) {
return new SimpleDateFormat("hh:mm:ss").format(new Date(timeStamp));
}
}
----------
source,bbb, 04:07:27
source,aaa, 04:07:28
source,bbb, 04:07:29
window, 04:07:25 - 04:07:30, 3