Flink使用二次聚合实现TopN计算
一、背景说明：
有需求需要对数据进行统计，要求每隔5分钟输出最近1小时内点击量最多的前N个商品，数据格式预览如下：
543462,1715,1464116,pv,1511658000
662867,2244074,1575622,pv,1511658000
561558,3611281,965809,pv,1511658000
894923,3076029,1879194,pv,1511658000
834377,4541270,3738615,pv,1511658000
315321,942195,4339722,pv,1511658000
625915,1162383,570735,pv,1511658000
578814,176722,982926,pv,1511658000
....
最后统计输出结果如下：
==============2017-11-26 09:05:00.0==============
Top1 ItemId:5051027 Counts:3
Top2 ItemId:3493253 Counts:3
Top3 ItemId:4261030 Counts:3
Top4 ItemId:4894670 Counts:2
Top5 ItemId:3781391 Counts:2
==============2017-11-26 09:05:00.0==============
==============2017-11-26 09:10:00.0==============
Top1 ItemId:812879 Counts:5
Top2 ItemId:2600165 Counts:4
Top3 ItemId:2828948 Counts:4
Top4 ItemId:2338453 Counts:4
Top5 ItemId:4261030 Counts:4
==============2017-11-26 09:10:00.0==============
二、实现过程
-
实现思路：
①建立环境，设置并行度及CK。
②定义watermark策略及事件时间，获取数据并对应到JavaBean，筛选pv数据。
③第一次聚合，按商品id分组开窗聚合,使用aggregate算子进行增量计算。
④第二次聚合，按窗口聚合，使用ListState存放数据，并定义定时器，在watermark达到后1秒触发，对窗口数据排序输出。
⑤打印结果及执行。 -
代码细节说明：
2.1 、第一次聚合代码：
//第一次聚合
SingleOutputStreamOperator<ItemCount> aggregateDS = userBehaviorDS
.map(new MapFunction<UserBehavior, Tuple2<Long, Integer>>() {
@Override
public Tuple2<Long, Integer> map(UserBehavior value) throws Exception {
return new Tuple2<>(value.getItemId(), 1);
}})
.keyBy(data -> data.f0)
.window(SlidingEventTimeWindows.of(Time.hours(1), Time.minutes(5)))
.aggregate(new ItemCountAggFunc(), new ItemCountWindowFunc());
①第一次聚合这里将商品id进行提取并转换为Tuple2<id,1>的格式，再对id进行keyby后聚合，避免直接使用对应的JavaBean进行分组聚合提高效率：
②这里使用aggregate算子进行增量计算，Flink的window function来负责一旦窗口关闭, 去计算处理窗口中的每个元素。window function 是如下三种：
- ReduceFunction （增量聚合函数） 输入及输出类型得一致
- AggregateFunction（增量聚合函数）输入及输出类型可以不一致
- ProcessWindowFunction（全窗口函数）
ReduceFunction,AggregateFunction更加高效, 原因就是Flink可以对到来的元素进行增量聚合 .
ProcessWindowFunction 可以得到一个包含这个窗口中所有元素的迭代器, 以及这些元素所属窗口的一些元数据信息.
ProcessWindowFunction不能被高效执行的原因是Flink在执行这个函数之前, 需要在内部缓存这个窗口上所有的元素
2.2、重写AggregateFunction函数代码
public static class ItemCountAggFunc implements AggregateFunction<Tuple2<Long,Integer>,Integer,Integer>{
@Override
public Integer createAccumulator() { return 0; }
@Override
public Integer add(Tuple2<Long, Integer> value, Integer accumulator) { return accumulator+1; }
@Override
public Integer getResult(Integer accumulator) { return accumulator; }
@Override
public Integer merge(Integer a, Integer b) { return a+b; }
}
这里对AggregateFunction函数里面四个方法进行重写自定义计数规则，入参<IN,ACC,OUT>对应为Tuple2，累加器用Integer过度，输出结果为Integer。
- createAccumulator
这个方法首先要创建一个累加器，要进行一些初始化的工作，这里初始值为0. - add
add方法就是做聚合的时候的核心逻辑，这里这是对tuple的第二位整数进行累加。 - merge
Flink是一个分布式计算框架，可能计算是分布在很多节点上同时进行的，如果计算在多个节点进行，需要对结果进行合并，这个merge方法就是做这个工作的，所以入参和出参的类型都是中间结果类型ACC。 - getResult
这个方法就是将每个用户最后聚合的结果经过处理之后，按照OUT的类型返回，返回的结果也就是聚合函数的输出结果了。
这里也是AggregateFunction和ReduceFunction区别的地方，reduce的input为Tuple2，则output也必须是Tuple2。
三、完整代码
这里处理的是顺序数据，如果是乱序数据，在窗口触发计算后迟到数据统计会有问题，优化思路为在窗口关闭后再触发键控状态的清除，及使用MapState来避免同个产品Id多个结果的问题。
package com.test.topN;
import bean.ItemCount;
import bean.UserBehavior;
import org.apache.commons.compress.utils.Lists;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows;
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.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author: Rango
* @create: 2021-05-24 10:37
* @description: 每隔5分钟输出最近1小时内点击量最多的前N个商品
**/
public class ProductTopN {
public static void main(String[] args) throws Exception {
//1.建立环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment().setParallelism(1);
//2.设置watermark及定义事件时间，从socket获取数据并对应到JavaBean,筛选只取pv数据
WatermarkStrategy<UserBehavior> wms = WatermarkStrategy
.<UserBehavior>forBoundedOutOfOrderness(Duration.ofSeconds(1))
.withTimestampAssigner(new SerializableTimestampAssigner<UserBehavior>() {
@Override
public long extractTimestamp(UserBehavior element, long recordTimestamp) {
return element.getTimestamp() * 1000L;
}
});
SingleOutputStreamOperator<UserBehavior> userBehaviorDS = env
//.socketTextStream("hadoop102", 9999)
.readTextFile("input/UserBehavior.csv")
.map(new MapFunction<String, UserBehavior>() {
@Override
public UserBehavior map(String value) throws Exception {
String[] split = value.split(",");
return new UserBehavior(Long.parseLong(split[0]),
Long.parseLong(split[1]),
Integer.parseInt(split[2]),
split[3],
Long.parseLong(split[4]));
}
})
.filter(data -> "pv".equals(data.getBehavior()))
.assignTimestampsAndWatermarks(wms);
//3.第一次聚合，按商品id分组开窗聚合,使用aggregate进行增量计算,将商品id用tuple2抽离出来提高效率
SingleOutputStreamOperator<ItemCount> aggregateDS = userBehaviorDS
.map(new MapFunction<UserBehavior, Tuple2<Long, Integer>>() {
@Override
public Tuple2<Long, Integer> map(UserBehavior value) throws Exception {
return new Tuple2<>(value.getItemId(), 1);
}})
.keyBy(data -> data.f0)
.window(SlidingEventTimeWindows.of(Time.hours(1), Time.minutes(5)))
.aggregate(new ItemCountAggFunc(), new ItemCountWindowFunc());
//4.第二次聚合，按窗口聚合，基于状态编程实现窗口内有序
SingleOutputStreamOperator<String> processDS = aggregateDS.keyBy(ItemCount::getTime)
.process(new ItemCountProcessFunc(5));
//5.打印结果并执行
processDS.print();
env.execute();
}
public static class ItemCountAggFunc implements AggregateFunction<Tuple2<Long,Integer>,Integer,Integer>{
@Override
public Integer createAccumulator() { return 0; }
@Override
public Integer add(Tuple2<Long, Integer> value, Integer accumulator) { return accumulator+1; }
@Override
public Integer getResult(Integer accumulator) { return accumulator; }
@Override
public Integer merge(Integer a, Integer b) { return a+b; }
}
public static class ItemCountWindowFunc implements WindowFunction<Integer, ItemCount,Long, TimeWindow>{
@Override
public void apply(Long key, TimeWindow window, Iterable<Integer> input, Collector<ItemCount> out) throws Exception {
Integer next = input.iterator().next();
out.collect(new ItemCount(key,new Timestamp(window.getEnd()).toString(),next));
}
}
public static class ItemCountProcessFunc extends KeyedProcessFunction<String,ItemCount,String>{
//定义构造器可以按入参取排名
private Integer topN;
public ItemCountProcessFunc(Integer topN) {
this.topN = topN;
}
//使用liststatus并初始化
private ListState <ItemCount>listState;
@Override
public void open(Configuration parameters) throws Exception {
listState= getRuntimeContext()
.getListState(new ListStateDescriptor<ItemCount>("list-state",ItemCount.class));
}
//定时器
@Override
public void processElement(ItemCount value, Context ctx, Collector<String> out) throws Exception {
listState.add(value);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
ctx.timerService().registerEventTimeTimer(sdf.parse(value.getTime()).getTime()+1000L);
}
@Override
public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
//1.获取状态的数据并转为List
Iterator<ItemCount> iterator = listState.get().iterator();
ArrayList<ItemCount> itemCounts = Lists.newArrayList(iterator);
//2.排序
itemCounts.sort(((o1, o2) -> o2.getCount() - o1.getCount()));
//3.获取前n
StringBuilder sb = new StringBuilder();
sb.append("==============")
.append(new Timestamp(timestamp - 1000L))
.append("==============")
.append("\n");
for (int i = 0; i < Math.min(topN,itemCounts.size()); i++) {
ItemCount itemCount = itemCounts.get(i);
sb.append("Top").append(i+1);
sb.append(" ItemId:").append(itemCount.getItem());
sb.append(" Counts:").append(itemCount.getCount());
sb.append("\n");
}
sb.append("==============")
.append(new Timestamp(timestamp - 1000L))
.append("==============")
.append("\n")
.append("\n");
listState.clear();
out.collect(sb.toString());
Thread.sleep(200);//方便查看结果时间休眠
}}}
学习交流，有任何问题还请随时评论指出交流。
