Flink DataStream 基于Interval Join实时Join过去一段时间内的数据

最新推荐文章于 2024-08-01 12:26:17 发布
最新推荐文章于 2024-08-01 12:26:17 发布
阅读量7k 收藏 19
点赞数 4
分类专栏： Flink 文章标签： Flink Interval Join
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangpei1949/article/details/103108474
版权

Interval Join: 间隔连接。如下示例:一条流(Left Keyed Stream) 按Key Join另一条流(Right Keyed Stream)过去2分钟内(间隔)的数据。

flink_interval_join.png

Interval Join语法

leftKeyedStream
  .intervalJoin(rightKeyedStream)
  // 时间间隔,设定下界和上界
  .between(Time.minutes(-10),Time.seconds(0))
  // 不包含下界
  //.lowerBoundExclusive()
  // 不包含上界
  //.upperBoundExclusive()
  // 自定义ProcessJoinFunction 处理Join到的元素
  .process(ProcessJoinFunction)

注意:

  1. 两条流都缓存在内部State中。leftElement到达，去获取State中rightElement相应时间范围内的数据，然后执行ProcessJoinFunction进行Join操作。

  2. 时间间隔: leftElement默认和[leftElementEventTime + lowerBound, leftElementEventTime + upperBound]时间范围内的rightElement join。

  3. 举例: leftElementEventTime=2019-11-16 17:30:00,lowerBound= -10minute，upperBound=0，则这条leftElement按Key和[2019-11-16 17:20:00,2019-11-16 17:30:00]时间范围内的rightElement join。

  4. Interval Join目前只支持Event Time。

  5. 数据量比较大，可使用RocksDBStateBackend。

每个用户的点击Join这个用户最近10分钟内的浏览

测试数据

// 数据流Left
// 某个用户在某个时刻点击了某个页面
// {"userID": "user_2", "eventTime": "2019-11-16 17:30:02", "eventType": "click", "pageID": "page_1"}

// 数据流Right
// 某个用户在某个时刻浏览了某个商品，以及商品的价值
// {"userID": "user_2", "eventTime": "2019-11-16 17:30:01", "eventType": "browse", "productID": "product_1", "productPrice": 10}

案例

package com.bigdata.flink.dataStreamWindowJoin.tumblingTimeWindow.intervalJoin;

import com.alibaba.fastjson.JSON;
import com.bigdata.flink.beans.UserBrowseLog;
import com.bigdata.flink.beans.UserClickLog;
import lombok.extern.slf4j.Slf4j;
import org.apache.flink.api.common.serialization.SimpleStringSchema;
import org.apache.flink.api.java.utils.ParameterTool;
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.ProcessFunction;
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer010;
import org.apache.flink.util.Collector;
import org.joda.time.DateTime;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;

import java.util.Properties;

/**
 * Summary:
 *  Interval Join
 */
@Slf4j
public class Test {
    public static void main(String[] args) throws Exception{

        args=new String[]{"--application","flink/src/main/java/com/bigdata/flink/dataStreamWindowJoin/application.properties"};

        //1、解析命令行参数
        ParameterTool fromArgs = ParameterTool.fromArgs(args);
        ParameterTool parameterTool = ParameterTool.fromPropertiesFile(fromArgs.getRequired("application"));

        String kafkaBootstrapServers = parameterTool.getRequired("kafkaBootstrapServers");

        String browseTopic = parameterTool.getRequired("browseTopic");
        String browseTopicGroupID = parameterTool.getRequired("browseTopicGroupID");

        String clickTopic = parameterTool.getRequired("clickTopic");
        String clickTopicGroupID = parameterTool.getRequired("clickTopicGroupID");

        //2、设置运行环境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);

        //3、添加Kafka数据源
        // 浏览流
        Properties browseProperties = new Properties();
        browseProperties.put("bootstrap.servers",kafkaBootstrapServers);
        browseProperties.put("group.id",browseTopicGroupID);
        DataStream<UserBrowseLog> browseStream=env
                .addSource(new FlinkKafkaConsumer010<>(browseTopic, new SimpleStringSchema(), browseProperties))
                .process(new BrowseKafkaProcessFunction())
                .assignTimestampsAndWatermarks(new BrowseBoundedOutOfOrdernessTimestampExtractor(Time.seconds(0)));

        // 点击流
        Properties clickProperties = new Properties();
        clickProperties.put("bootstrap.servers",kafkaBootstrapServers);
        clickProperties.put("group.id",clickTopicGroupID);
        DataStream<UserClickLog> clickStream = env
                .addSource(new FlinkKafkaConsumer010<>(clickTopic, new SimpleStringSchema(), clickProperties))
                .process(new ClickKafkaProcessFunction())
                .assignTimestampsAndWatermarks(new ClickBoundedOutOfOrdernessTimestampExtractor(Time.seconds(0)));

        //browseStream.print();
        //clickStream.print();

        //4、Interval Join
        //每个用户的点击Join这个用户最近10分钟内的浏览
        clickStream
                .keyBy("userID")
                .intervalJoin(browseStream.keyBy("userID"))
                // 时间间隔,设定下界和上界
                // 下界: 10分钟前，上界: 当前EventTime时刻
                .between(Time.minutes(-10),Time.seconds(0))
                // 自定义ProcessJoinFunction 处理Join到的元素
                .process(new ProcessJoinFunction<UserClickLog, UserBrowseLog, String>() {
                    @Override
                    public void processElement(UserClickLog left, UserBrowseLog right, Context ctx, Collector<String> out) throws Exception {
                        out.collect(left +" =Interval Join=> "+right);
                    }
                })
                .print();

        env.execute();

    }

    /**
     * 解析Kafka数据
     */
    static class BrowseKafkaProcessFunction extends ProcessFunction<String, UserBrowseLog> {
        @Override
        public void processElement(String value, Context ctx, Collector<UserBrowseLog> out) throws Exception {
            try {
                UserBrowseLog log = JSON.parseObject(value, UserBrowseLog.class);
                if(log!=null){
                    out.collect(log);
                }
            }catch (Exception ex){
                log.error("解析Kafka数据异常...",ex);
            }
        }
    }

    /**
     * 解析Kafka数据
     */
    static class ClickKafkaProcessFunction extends ProcessFunction<String, UserClickLog> {
        @Override
        public void processElement(String value, Context ctx, Collector<UserClickLog> out) throws Exception {
            try {
                UserClickLog log = JSON.parseObject(value, UserClickLog.class);
                if(log!=null){
                    out.collect(log);
                }
            }catch (Exception ex){
                log.error("解析Kafka数据异常...",ex);
            }
        }
    }

    /**
     * 提取时间戳生成水印
     */
    static class BrowseBoundedOutOfOrdernessTimestampExtractor extends BoundedOutOfOrdernessTimestampExtractor<UserBrowseLog> {

        BrowseBoundedOutOfOrdernessTimestampExtractor(Time maxOutOfOrderness) {
            super(maxOutOfOrderness);
        }

        @Override
        public long extractTimestamp(UserBrowseLog element) {
            DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
            DateTime dateTime = DateTime.parse(element.getEventTime(), dateTimeFormatter);
            return dateTime.getMillis();
        }
    }

    /**
     * 提取时间戳生成水印
     */
    static class ClickBoundedOutOfOrdernessTimestampExtractor extends BoundedOutOfOrdernessTimestampExtractor<UserClickLog> {

        ClickBoundedOutOfOrdernessTimestampExtractor(Time maxOutOfOrderness) {
            super(maxOutOfOrderness);
        }

        @Override
        public long extractTimestamp(UserClickLog element) {
            DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
            DateTime dateTime = DateTime.parse(element.getEventTime(), dateTimeFormatter);
            return dateTime.getMillis();
        }
    }

}

结果

向两个Topic中发送如下数据

// 点击记录Topic
{"userID": "user_2", "eventTime": "2019-11-16 17:30:00", "eventType": "click", "pageID": "page_1"}

// 浏览记录Topic
{"userID": "user_2", "eventTime": "2019-11-16 17:19:00", "eventType": "browse", "productID": "product_1", "productPrice": 10}
{"userID": "user_2", "eventTime": "2019-11-16 17:20:00", "eventType": "browse", "productID": "product_1", "productPrice": 10}
{"userID": "user_2", "eventTime": "2019-11-16 17:22:00", "eventType": "browse", "productID": "product_1", "productPrice": 10}
{"userID": "user_2", "eventTime": "2019-11-16 17:26:00", "eventType": "browse", "productID": "product_1", "productPrice": 10}
{"userID": "user_2", "eventTime": "2019-11-16 17:30:00", "eventType": "browse", "productID": "product_1", "productPrice": 10}
{"userID": "user_2", "eventTime": "2019-11-16 17:31:00", "eventType": "browse", "productID": "product_1", "productPrice": 10}

获取到的输出结果，可以看到user_2在2019-11-16 17:30:00时间点的点击已经Join到这个用户在[2019-11-16 17:20:00,2019-11-16 17:30:00]时间范围的浏览。

UserClickLog{userID='user_2', eventTime='2019-11-16 17:30:00', eventType='click', pageID='page_1'} =Interval Join=> UserBrowseLog{userID='user_2', eventTime='2019-11-16 17:26:00', eventType='browse', productID='product_1', productPrice=10}
UserClickLog{userID='user_2', eventTime='2019-11-16 17:30:00', eventType='click', pageID='page_1'} =Interval Join=> UserBrowseLog{userID='user_2', eventTime='2019-11-16 17:20:00', eventType='browse', productID='product_1', productPrice=10}
UserClickLog{userID='user_2', eventTime='2019-11-16 17:30:00', eventType='click', pageID='page_1'} =Interval Join=> UserBrowseLog{userID='user_2', eventTime='2019-11-16 17:30:00', eventType='browse', productID='product_1', productPrice=10}
UserClickLog{userID='user_2', eventTime='2019-11-16 17:30:00', eventType='click', pageID='page_1'} =Interval Join=> UserBrowseLog{userID='user_2', eventTime='2019-11-16 17:22:00', eventType='browse', productID='product_1', productPrice=10}
wangpei1949
关注
专栏目录
Flink intervalJoin 使用与原理分析
微信搜：import_bigdata，大数据领域硬核原创作者
08-29 1077
声明：本系列博客部分是根据SGG的视频整理而成，非常适合大家入门学习。部分文章是通过爬虫等技术手段采集的，目的是学习分享，如果有版权问题请留言，随时删除。 《2021年最新版大数据面试题全面开启更新》 在上一篇的分析【Flink DataStream中CoGroup实现原理与三种 join 实现】中基于DataStream的join只能实现在同一个窗口的两个数据流之间进行join, 但是在实际中常常是会存在数据乱序或者延时的情况，导致两个流的数据进度不一致，就会出现数据跨窗口的情况，那么数据就无
Flink intervalJoin 使用和原理分析
longlovefilm的博客
08-16 1605
Flink中基于DataStream的join，只能实现在同一个窗口的两个数据流进行join，但是在实际中常常会存在数据乱序或者延时的情况，导致两个流的数据进度不一致，就会出现数据跨窗口的情况，那么数据就无法在同一个窗口内join。这两个方法调用的都是processElement方法。（1）获取记录的值和时间戳，判断是否延时，当到达的记录的时间戳小于水位线时，说明该数据延时，不去处理，不去关联另一条流的数据。假设目前流到达的数据的时间戳为10s，between传进去的时间分别为1s，5s，...
Flink intervalJoin 使用 -转载
qq_31866793的博客
12-09 1916
1.前言 Flink中基于DataStream的join，只能实现在同一个窗口的两个数据流进行join，但是在实际中常常会存在数据乱序或者延时的情况，导致两个流的数据进度不一致，就会出现数据跨窗口的情况，那么数据就无法在同一个窗口内join。 Flink基于KeyedStream提供的interval join机制，intervaljoin 连接两个keyedStream, 按照相同的key在一...
TiDB系列之：使用Flink TiDB CDC Connector采集数据
最新发布
zhengzaifeidelushang的博客
08-01 1683
TiDB CDC 连接器允许从 TiDB 数据库读取快照数据和增量数据。本文档介绍如何设置 TiDB CDC 连接器以对 TiDB 数据库运行 SQL 查询。
Flink IntervalJoin 笔记
qq_42496461的博客
04-24 544
之后就是计算cleanupTime，调用internalTimerService.registerEventTimeTimer注册清理该element的timer，定时的清理时间，就是当下流入的数据的时间+relativeUpperBound，当watermark大于该时间就需要清理。)将数据输出给ProcessJoinFunction调用，ourTimestamp表示流入的数据时间，timestamp表示对应join的数据时间，不满足要求的直接跳过，满足要求的就调用collect方法(
大数据Flink（八十八）：Interval Join（时间区间 Join）
Lansonli（蓝深李）的博客
09-24 1844
刚刚的案例也讲了，Regular Join 会产生回撤流，但是在实时数仓中一般写入的 sink 都是类似于 Kafka 这样的消息队列，然后后面接 clickhouse 等引擎，这些引擎又不具备处理回撤流的能力。可以发现 Inner Interval Join 和其他三种 Outer Interval Join 的区别在于，Outer 在随着时间推移的过程中，如果有数据过期了之后，会根据是否是 Outer 将没有 Join 到的数据也给输出。：Interval Join 在离线的概念中是没有的。
FlinkSql系列6之 Interval Join
feiyangailing的博客
03-30 5035
FlinkSql系列6之 Interval Join 前言 本次我们来学习flinksql的Interval Join,这个方式主要是针对两个流在一定时间区间内的join,支持事件时间和处理时间，而且这个流每次只会产生一条数据，是一个完全的追加流。 一、Interval Join是什么？ Interval Join 可以让⼀条流去 Join 另⼀条流中前后⼀段时间内的数据。 1.1 Inner Interval Join 只有两条流中的满足时间区间符合，并且满足其他的join条件，这时候才会匹配的上并
Flink进阶教程：如何在两个DataStream上进行Join操作
皮皮鲁的AI星球
01-18 2597
批处理经常要解决的问题是将两个数据源做关联Join操作。比如，很多手机APP都有一个用户数据源User，同时APP会记录用户的行为，我们称之为Behavior，两个表按照userId来进行Join。在流处理场景下，Flink也支持了Join，只不过Flink是在一个时间窗口上来进行两个表的Join。 目前，Flink支持了两种Join：Window Join（窗口连接）和Interval Joi...
Flink DataStream API详解
lhp12355的博客
08-07 567
Flink API介绍 Flink提供了三层API，每层在简洁性和表达性之间进行了不同的权衡。 flink-api ProcessFunction是Flink提供的最具表现力的功能接口，它提供了对时间和状态的细粒度控制，能够任意修改状态。所以ProcessFunction能够为许多有事件驱动的应用程序实现复杂的事件处理逻辑。 DataStream API为许多通用的流处理操作提供原语，比如window。DataStream API适用于Java和Scala，它基于函数实现，比如map()、redu
Flink之IntervalJoin介绍
影子
03-11 2268
InterValJoin算子 间隔流，一条流去join另一条流去过去一段时间内的数据，该算子将keyedStream与keyedStream转化为DataStream；再给定的时间边界内（默认包含边界），相当于一个窗口，按指定的key对俩个KeyedStream进行Join操作，把符合join条件的俩个event拉倒一起，然后咋么处理右用户来决定。 1、key1 == key2 && e1.timestamp +lowerBound <= e2.timestamp +upperBoun
Flink DataStream自定义实现IntervalLeftOuterJoin
stable_zl的博客
08-01 150
因为Flink DataStream内置的Join操作，只有Inner Join，而对于Outer Join支持的比较少，Window Outer Join我们可以用cogroup来实现，而Interval Outer Join相对复杂，所以自己参考Flink IntervalJoinOperator实现了一个IntervalLeftOuterJoinFunction
44、Flink 的 Interval Join 详解
猫猫爱吃小鱼粮
05-27 591
Flink 的 Interval Join 详解
Flink Interval Join 使用和原理分析
http://www.54tianzhisheng.cn/
11-02 2413
点击上方 "zhisheng"关注,星标或置顶一起成长Flink 从入门到精通系列文章前言Flink中基于DataStream的join，只能实现在同一个窗口的两个数...
Flink Interval Join使用以及源码解析
百看不如一RUN
02-21 3648
在之前的Join算子中，一般使用的是coGroup算子，因为一个算子可以提供多种语义，但是也是有一些弊端的。因为coGroup只能实现在同一个窗口的两个数据流之间进行join，在实际的计算过程中，往往会遇到当req发生时，resp迟迟无法响应，这个时候，就会出现一个跨窗口的问题。
Flink-电商用户行为分析(每隔 5 分钟输出最近一小时内点击量最多的前 N 个商品)
Knight
07-05 7525
数据 链接：https://pan.baidu.com/s/1InfWoNYUeV1KYyvFS1aXuA 提取码：z3p4 程序主体 import org.apache.flink.streaming.api.scala.StreamExecutionEnvironment import org.apache.flink.api.scala._ import org.apache.flink.streaming.api.TimeCharacteristic //640533,3168550,47198
Flink SQL Regular Join 、Interval Join、Temporal Join、Lookup Join 详解
猫猫爱吃小鱼粮
11-06 2054
Flink SQL Regular Join 、Interval Join、Temporal Join、Lookup Join 详解
flinksql日期
qq_34158117的博客
06-07 3210
获取前一天的日期： DATE_FORMAT(TIMESTAMPADD(DAY, -1, CURRENT_TIMESTAMP), 'yyyyMMdd')
基于Flink的实时数据处理平台架构和技术实现
在基于Flink构建用户实时基础行为工程中，可以使用Flink的这些特点来实现高性能、低延迟的流处理和批处理，并且可以处理每天超过12亿条实时数据，数据实时性达到秒级，QPS可支持10万的用户实时基础行为工程的技术...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值