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==============

二、实现过程

1. 实现思路：
   
   ①建立环境，设置并行度及CK。
   
   ②定义watermark策略及事件时间，获取数据并对应到JavaBean，筛选pv数据。
   
   ③第一次聚合，按商品id分组开窗聚合,使用aggregate算子进行增量计算。
   
   ④第二次聚合，按窗口聚合，使用ListState存放数据，并定义定时器，在watermark达到后1秒触发，对窗口数据排序输出。
   
   ⑤打印结果及执行。

2. 代码细节说明：
   
   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);//方便查看结果时间休眠
        }}}

---

学习交流，有任何问题还请随时评论指出交流。