topN功能是一个非常常见的功能，比如查看最近几分钟的阅读最高数，购买最高数。
flink实现topN的功能也非常方便，下面就开始构建一个flink topN的程序。
还是像上篇博客一样，从kafka读取数据，然后进行计算和数据转换，最后sink到mysql中。
假设有个需求，实现一个统计每5分钟最高购买数的商品。
使用maven创建一个工程，具体步骤可以参考上边博文。然后创建一个数据库表，用于存储最终的结果集。语句如下：
CREATE TABLE `itembuycount` ( `id` mediumint NOT NULL auto_increment, `itemId` bigint(255) NOT NULL, `buyCount` bigint(11) DEFAULT NULL, `createDate` timestamp NULL DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci
创建一个表对应的pojo类文件UserAction。里边主要是用户id，商品id，用户的行为，pv用户浏览，buy用户购买，cart加购物车，fav加入收藏。
package myflinktopn.pojo;
/**
* @author huangqingshi
* @Date 2019-12-13
*/
public class UserAction {
public long userId; //用户id
public long itemId; //商品id
public int categoryId; //商品分类id
public String behavior; //用户行为（pv, buy, cart, fav)
public long timestamp; //操作时间戳
public long getUserId() {
return userId;
}
public void setUserId(long userId) {
this.userId = userId;
}
public long getItemId() {
return itemId;
}
public void setItemId(long itemId) {
this.itemId = itemId;
}
public int getCategoryId() {
return categoryId;
}
public void setCategoryId(int categoryId) {
this.categoryId = categoryId;
}
public String getBehavior() {
return behavior;
}
public void setBehavior(String behavior) {
this.behavior = behavior;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
}
接下来创建一个kafka主题，存储发送和接受数据使用。
./bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic USER_ACTION
kafka的主题创建好了之后，写一个程序往kafka里边写数据，一秒写一条。
package myflinktopn.kafka;
import com.alibaba.fastjson.JSON;
import myflinktopn.pojo.UserAction;
import org.apache.commons.lang3.RandomUtils;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
/**
* @author huangqingshi
* @Date 2019-12-07
*/
public class KafkaWriter {
//本地的kafka机器列表
public static final String BROKER_LIST = "localhost:9092";
//kafka的topic
public static final String TOPIC_USER_ACTION = "USER_ACTION";
//key序列化的方式，采用字符串的形式
public static final String KEY_SERIALIZER = "org.apache.kafka.common.serialization.StringSerializer";
//value的序列化的方式
public static final String VALUE_SERIALIZER = "org.apache.kafka.common.serialization.StringSerializer";
//用户的行为列表
public static final List<String> userBehaviors = Arrays.asList("pv", "buy", "cart", "fav");
public static void writeToKafka() throws Exception{
Properties props = new Properties();
props.put("bootstrap.servers", BROKER_LIST);
props.put("key.serializer", KEY_SERIALIZER);
props.put("value.serializer", VALUE_SERIALIZER);
KafkaProducer<String, String> producer = new KafkaProducer<>(props);
UserAction userAction = new UserAction();
userAction.setUserId(RandomUtils.nextLong(1, 100));
userAction.setItemId(RandomUtils.nextLong(1, 1000));
userAction.setCategoryId(RandomUtils.nextInt(1, 30));
userAction.setBehavior(userBehaviors.get(RandomUtils.nextInt(0, 3)));
userAction.setTimestamp(System.currentTimeMillis());
//转换成JSON
String userActionJson = JSON.toJSONString(userAction);
//包装成kafka发送的记录
ProducerRecord<String, String> record = new ProducerRecord<String, String>(TOPIC_USER_ACTION, null,
null, userActionJson);
//发送到缓存
producer.send(record);
System.out.println("向kafka发送数据:" + userActionJson);
//立即发送
producer.flush();
}
public static void main(String[] args) {
while(true) {
try {
//每1秒写一条数据
TimeUnit.SECONDS.sleep(1);
writeToKafka();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
接下来还是创建数据库的连接工具类。
package myflinktopn.db;
import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
/**
* @author huangqingshi
* @Date 2019-12-07
*/
public class DbUtils {
private static DruidDataSource dataSource;
public static Connection getConnection() throws Exception {
dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/testdb");
dataSource.setUsername("root");
dataSource.setPassword("root");
//设置初始化连接数，最大连接数，最小闲置数
dataSource.setInitialSize(10);
dataSource.setMaxActive(50);
dataSource.setMinIdle(5);
//返回连接
return dataSource.getConnection();
}
}
接下来写sink到数据库的MySqlSink类，用于将结果接数据保存到数据库。
package myflinktopn.sink;
import myflinktopn.TopNJob;
import myflinktopn.db.DbUtils;
import myflinktopn.pojo.UserAction;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Timestamp;
import java.util.List;
/**
* @author huangqingshi
* @Date 2019-12-07
*/
public class MySqlSink extends RichSinkFunction<List<TopNJob.ItemBuyCount>> {
private PreparedStatement ps;
private Connection connection;
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
//获取数据库连接，准备写入数据库
connection = DbUtils.getConnection();
String sql = "insert into itembuycount(itemId, buyCount, createDate) values (?, ?, ?); ";
ps = connection.prepareStatement(sql);
System.out.println("-------------open------------");
}
@Override
public void close() throws Exception {
super.close();
//关闭并释放资源
if(connection != null) {
connection.close();
}
if(ps != null) {
ps.close();
}
System.out.println("-------------close------------");
}
@Override
public void invoke(List<TopNJob.ItemBuyCount> topNItems, Context context) throws Exception {
for(TopNJob.ItemBuyCount itemBuyCount : topNItems) {
ps.setLong(1, itemBuyCount.itemId);
ps.setLong(2, itemBuyCount.buyCount);
ps.setTimestamp(3, new Timestamp(itemBuyCount.windowEnd));
ps.addBatch();
}
//一次性写入
int[] count = ps.executeBatch();
System.out.println("-------------invoke------------");
System.out.println("成功写入Mysql数量：" + count.length);
}
}
接下来咱们看一下实现TopNJob的全部代码，然后再继续分析下里边的细节。
package myflinktopn;
import com.alibaba.fastjson.JSONObject;
import myflinktopn.kafka.KafkaWriter;
import myflinktopn.pojo.UserAction;
import myflinktopn.sink.MySqlSink;
import org.apache.flink.api.common.functions.AggregateFunction;
import org.apache.flink.api.common.functions.FilterFunction;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.api.common.state.ListState;
import org.apache.flink.api.common.state.ListStateDescriptor;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple1;
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.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.KeyedProcessFunction;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.functions.windowing.WindowFunction;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer010;
import org.apache.flink.util.Collector;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Properties;
/**
* @author huangqingshi
* @Date 2019-12-13
*/
public class TopNJob {
//最对延迟到达的时间
public static final long MAX_EVENT_DELAY = 10L;
public static void main(String[] args) throws Exception {
//构建流执行环境
StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
//设置并行度1，方便打印
env.setParallelism(1);
/** ProcessingTime：事件被处理的时间。也就是由机器的系统时间来决定。
EventTime：事件发生的时间。一般就是数据本身携带的时间。
*/
//设置下eventTime，默认为processTime即系统处理时间，我们需要统计一小时内的数据，也就是数据带的时间eventTime
env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
//kafka
Properties prop = new Properties();
prop.put("bootstrap.servers", KafkaWriter.BROKER_LIST);
prop.put("zookeeper.connect", "localhost:2181");
prop.put("group.id", KafkaWriter.TOPIC_USER_ACTION);
prop.put("key.serializer", KafkaWriter.KEY_SERIALIZER);
prop.put("value.serializer", KafkaWriter.VALUE_SERIALIZER);
prop.put("auto.offset.reset", "latest");
DataStreamSource<String> dataStreamSource = env.addSource(new FlinkKafkaConsumer010<>(
KafkaWriter.TOPIC_USER_ACTION,
new SimpleStringSchema(),
prop
));
//从kafka里读取数据，转换成UserAction对象
DataStream<UserAction> dataStream = dataStreamSource.map(value -> JSONObject.parseObject(value, UserAction.class));
//将乱序的数据进行抽取出来，设置watermark，数据如果晚到10秒的会被丢弃
DataStream<UserAction> timedData = dataStream.assignTimestampsAndWatermarks(new UserActionTSExtractor());
//为了统计5分钟购买的最多的，所以我们需要过滤出购买的行为
DataStream<UserAction> filterData = timedData.filter(new FilterFunction<UserAction>() {
@Override
public boolean filter(UserAction userAction) throws Exception {
return userAction.getBehavior().contains("buy");
}
});
//窗口统计点击量 滑动的窗口 5分钟一次 统计一小时最高的 比如 [09:00, 10:00), [09:05, 10:05), [09:10, 10:10)…
DataStream<ItemBuyCount> windowedData = filterData
.keyBy("itemId")
.timeWindow(Time.minutes(60L), Time.minutes(5L))
.aggregate(new CountAgg(), new WindowResultFunciton());
//Top N 计算最热门的商品
DataStream<List<ItemBuyCount>> topItems = windowedData
.keyBy("windowEnd")
//点击前3的商品
.process(new TopNHotItems(3));
topItems.addSink(new MySqlSink());
//topItems.print();
env.execute("Top N Job");
}
/**
* 用于行为时间戳抽取器，最多十秒延迟，也就是晚到10秒的数据会被丢弃掉
*/
public static class UserActionTSExtractor extends BoundedOutOfOrdernessTimestampExtractor<UserAction> {
public UserActionTSExtractor() {
super(Time.seconds(MAX_EVENT_DELAY));
}
@Override
public long extractTimestamp(UserAction userAction) {
return userAction.getTimestamp();
}
}
/**
* 商品购买量（窗口操作的输出类型）
*/
public static class ItemBuyCount {
public long itemId; //商品ID;
public long windowEnd; //窗口结束时间戳
public long buyCount; //购买数量
public static ItemBuyCount of(long itemId, long windowEnd, long buyCount) {
ItemBuyCount itemBuyCount = new ItemBuyCount();
itemBuyCount.itemId = itemId;
itemBuyCount.windowEnd = windowEnd;
itemBuyCount.buyCount = buyCount;
return itemBuyCount;
}
}
/**
*
* COUNT 聚合函数实现，每出现一条记录加一。AggregateFunction<输入，汇总，输出>
*/
public static class CountAgg implements AggregateFunction<UserAction, Long, Long> {
@Override
public Long createAccumulator() {
return 0L;
}
@Override
public Long add(UserAction userAction, Long acc) {
return acc + 1;
}
@Override
public Long getResult(Long acc) {
return acc;
}
@Override
public Long merge(Long acc1, Long acc2) {
return acc1 + acc2;
}
}
/**
* 用于输出结果的窗口WindowFunction<输入，输出，键，窗口>
*/
public static class WindowResultFunciton implements WindowFunction<Long, ItemBuyCount, Tuple, TimeWindow> {
@Override
public void apply(
Tuple key, //窗口主键即itemId
TimeWindow window, //窗口
Iterable<Long> aggregationResult, //集合函数的结果，即count的值
Collector<ItemBuyCount> collector //输出类型collector
) throws Exception {
Long itemId = ((Tuple1<Long>) key).f0;
Long count =aggregationResult.iterator().next();
collector.collect(ItemBuyCount.of(itemId, window.getEnd(), count));
}
}
/**
* 求某个窗口中前N名的热门点击商品，key为窗口时间戳，输出为Top N 的结果字符串
*/
public static class TopNHotItems extends KeyedProcessFunction<Tuple, ItemBuyCount, List<ItemBuyCount>> {
private final int topSize;
public TopNHotItems(int topSize) {
this.topSize = topSize;
}
//用于存储商品与购买数的状态，待收齐同一个窗口的数据后，再触发 Top N 计算
private ListState<ItemBuyCount> itemState;
@Override
public void open(Configuration parameters) throws Exception {
super.open(parameters);
//状态注册
ListStateDescriptor<ItemBuyCount> itemViewStateDesc = new ListStateDescriptor<ItemBuyCount>(
"itemState-state", ItemBuyCount.class
);
itemState = getRuntimeContext().getListState(itemViewStateDesc);
}
@Override
public void processElement(
ItemBuyCount input,
Context context,
Collector<List<ItemBuyCount>> collector
) throws Exception {
//每条数据都保存到状态
itemState.add(input);
//注册 windowEnd+1 的 EventTime Timer, 当触发时，说明收集好了所有 windowEnd的商品数据
context.timerService().registerEventTimeTimer(input.windowEnd + 1);
}
@Override
public void onTimer(long timestamp, OnTimerContext ctx, Collector<List<ItemBuyCount>> out) throws Exception {
//获取收集到的所有商品点击量
List<ItemBuyCount> allItems = new ArrayList<ItemBuyCount>();
for(ItemBuyCount item : itemState.get()) {
allItems.add(item);
}
//提前清除状态中的数据，释放空间
itemState.clear();
//按照点击量从大到小排序
allItems.sort(new Comparator<ItemBuyCount>() {
@Override
public int compare(ItemBuyCount o1, ItemBuyCount o2) {
return (int) (o2.buyCount - o1.buyCount);
}
});
List<ItemBuyCount> itemBuyCounts = new ArrayList<>();
//将排名信息格式化成String，方便打印
StringBuilder result = new StringBuilder();
result.append("========================================\n");
result.append("时间：").append(new Timestamp(timestamp-1)).append("\n");
for (int i=0;i<topSize;i++) {
ItemBuyCount currentItem = allItems.get(i);
// No1: 商品ID=12224 购买量=2
result.append("No").append(i).append(":")
.append(" 商品ID=").append(currentItem.itemId)
.append(" 购买量=").append(currentItem.buyCount)
.append("\n");
itemBuyCounts.add(currentItem);
}
result.append("====================================\n\n");
out.collect(itemBuyCounts);
}
}
}
以上里边的步骤：
1. 构建流执行的环境。
2. 设置并行度为1，为了方便下边打印。但是实际上可以不用设置并行度。
3. 设置流时间的特性，即EventTime。流时间一共有三种时间：
1）ProcessingTime时间，即算子处理的时间，默认flink的时间特性。
2）EventTime，事件处理时间，也就是程序所带的时间戳。此例子将使用由业务产生的时间戳作为时间戳。
3）IntestionTime，即到达flink的时间。
4. 连接kafka的属性读取数据。将kafka的数据转换成pojo对象。
5. 将乱序的数据使用BoundedOutOfOrdernessTimestampExtractor进行时间戳抽取和设置watermark。
6. 进行数据过滤，将useAction为buy的数据进行过滤出来，其他的直接丢弃。
7. 采用滑动窗口的方式对数据进行汇总并返回指定类型的数据。一小时为一个窗口，每五分钟往后滑动一下。数据的形式为[9:00 10:00), [9:05 10:05), [9:10 10:10)依次类推。
8. 最后是将数据排序，然后获取topN的数据。
接下来咱们再针对里边的细节看一下，如果数据是生序的数据，则采用AscendingTimestampExtractor进行时间戳抽取，无序可以采用上边5条说的类。有序的只需要进行时间戳抽取，抽取的时间戳就认为是整个的时间，也就是watermark时间，可以理解为全局时间。无序抽取的时候设置一个最晚到达的时间。举个例子，如果一条数据时间为9:04:55, 到达的时间为9:05:05，这样这条数据还是属于窗口[9:00 9:05:01)里边的，而不是[9:05:01 9:10:01)。
这个聚合方法aggregate(new CountAgg(), new WindowResultFunciton())里边声明了两个类，一个是聚合功能类，一个是结果窗口功能类。也就是使用第一个类将数据进行汇聚，第二个类将数据进行合并汇总并且输出自己定义的窗口结果集ItemBuyCount。
最后就是topN功能，这个类实现了KeyedProcessFunction，里边有三个方法 open, processElement, onTimer, 里边还有一个ListState<ItemBuyCount>，用于收集和记录状态信息，保证数据exactly-once语义。
open方法用于进行状态注册。
processElement把数据状态进行添加到list里边，然后注册时间时间windowEnd+1，即数据超过了windowEnd的时候就会触发onTimer时间。
onTimer用于把五分钟收集好的数据进行处理，从数据状态记录中把数据拿出来，然后清理数据状态，释放空间。然后将拿出来的数据进行排序，最后整理成sink所需要的结果集。
最后就把数据进行sink，保存到数据库。
下面看一下数据运行的结果，kafkaWriter打印的日志。
向kafka发送数据:{"behavior":"pv","categoryId":7,"itemId":19,"timestamp":1576325365016,"userId":56}
执行TopNJob，MysqlSink执行的日志打印。
-------------invoke------------ 成功写入Mysql数量：3 [[email protected], [email protected]19739780, [email protected]] -------------invoke------------ 成功写入Mysql数量：3 [[email protected], [email protected], [email protected]] -------------invoke------------ 成功写入Mysql数量：3 [[email protected], [email protected], [email protected]]
写入到数据库的记录如下：
写入的时间都在同一个时刻，获取前三条购买最多的，所以三条写入的时间都一样的。
还有在运行的时候要注意kafkaWriter要多谢一些，因为要收集5分钟的数据，所以至少得跑5分钟。
最后我把代码放到git上了，可以进行访问：https://github.com/stonehqs/flink-topn ，有不对的地方，欢迎指正。
原文地址：https://www.cnblogs.com/huangqingshi/p/12041032.html
时间： 2024-10-10 14:31:04