java Flink（四十三）Flink Interval Join源码解析以及简单实例

已于 2024-03-19 16:02:32 修改
阅读量979 收藏 7
点赞数 4
分类专栏： Java Flink 文章标签： flink 大数据
于 2024-03-19 15:54:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40771567/article/details/136567296
版权

背景

之前我们在一片文章里简单介绍过Flink的多流合并算子

java Flink（三十六）Flink多流合并算子UNION、CONNECT、CoGroup、Join

今天我们通过Flink 1.14的源码对Flink的Interval Join进行深入的理解。

Interval Join不是两个窗口做关联，更适用于处理乱序数据流之间的关联。它的作用更类似于从左流中a元素本身出发，对右流中一段时间内的数据进行关联（Inner Join：只关联相同Key的数据）。

如图所示：

 下边这条流中的2关联到上范围内的0/1

​

源码解析

Flink版本1.14.4

按住Ctrl+鼠标左键，点击process进入源码

​

 这里process方法是在KeydStream.java下IntervalJoined类下的方法

 包装返回类型的TypeInfomation（TypeInfo的介绍可以看上一篇）

 返回的outputType

SingleOutputStreamOperator使用给定的用户函数完成联接操作，该函数针对每个联接的元素对执行。这种方法允许传递输出类型的显式类型信息。

​

 IntervalJoinOperator初始化

​​

左边界<=右边界检查

获取左流还有右流数据对应的序列化（从TypeInfo获取的）

继续看IntervalJoinOperator中的其余关键实现

open方法用来注册定时器

​

 初始化两个流的map状态

​

处理左侧流中的数据。每当数据到达左流时，它就会被添加到左缓冲区。将从右侧缓冲区中查找该元素可能的候选联接，如果该对位于用户定义的边界内，则将其传递给 ProcessJoinFunction

​ 同理处理右流​

进入数据处理函数

获取数据，取出事件时间

​

 超过当前watermark的数据进行过滤

 ​

数据没问题的话，将数据添加到状态

 ​​

遍历另一条流的状态，遍历其中的数据，把满足时间要求的数据进行collect

​注册一个当前事件时间戳+右边界的定时器

​​

定时器触发后，清空map状态中时间戳-左边界的那条数据​

简单实例 

pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>FlinkCode</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <jdk.version>1.8</jdk.version>
        <jar.name>ubs-data-converter</jar.name>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!--Flink 版本-->
        <flink.version>1.14.4</flink.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka_2.11</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.kafka</groupId>
                    <artifactId>kafka-clients</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-runtime-web_2.11</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.10</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>org.apache.avro</groupId>
            <artifactId>avro</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.avro</groupId>
                <artifactId>avro-maven-plugin</artifactId>
                <version>1.9.2</version>
                <executions>
                    <execution>
                        <phase>generate-sources</phase>
                        <goals>
                            <goal>schema</goal>
                        </goals>
                        <configuration>
                            <sourceDirectory>${project.basedir}/src/main/resources/</sourceDirectory>
                           
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${jdk.version}</source>
                    <target>${jdk.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.1.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <finalName>${jar.name}</finalName>
                            <artifactSet>
                                <excludes>
                                    <exclude>com.google.code.findbugs:jsr305</exclude>
                                    <exclude>org.slf4j:*</exclude>
                                    <exclude>log4j:*</exclude>
                                    <exclude>org.glassfish.jersey.core:jersey-common</exclude>
                                </excludes>
                            </artifactSet>
                            <relocations>
                                <relocation>
                                    <pattern>com.google.common</pattern>
                                    <shadedPattern>com.shade.google.common</shadedPattern>
                                </relocation>
                                <relocation>
                                    <pattern>org.apache.kafka</pattern>
                                    <shadedPattern>org.shade.apache.kafka</shadedPattern>
                                </relocation>
                            </relocations>
                            <filters>
                                <filter>
                                    <artifact>*</artifact>
                                    <includes>
                                        <include>org/apache/htrace/**</include>
                                        <include>org/apache/avro/**</include>
                                        <include>org/apache/flink/streaming/**</include>
                                        <include>org/apache/flink/connector/**</include>
                                        <include>org/apache/kafka/**</include>
                                        <include>org/apache/hive/**</include>
                                        <include>org/apache/hadoop/hive/**</include>
                                        <include>org/apache/curator/**</include>
                                        <include>org/apache/zookeeper/**</include>
                                        <include>org/apache/jute/**</include>
                                        <include>org/apache/thrift/**</include>
                                        <include>org/apache/http/**</include>
                                        <include>org/I0Itec/**</include>
                                        <include>jline/**</include>
                                        <include>com/yammer/**</include>
                                        <include>kafka/**</include>
                                        <include>org/apache/hadoop/hbase/**</include>
                                        <include>com/alibaba/fastjson/**</include>
                                        <include>org/elasticsearch/action/**</include>
                                        <include>io/confluent/**</include>
                                        <include>com/fasterxml/**</include>
                                        <include>org/elasticsearch/**</include>
                                        <include>hbase-default.xml</include>
                                        <include>hbase-site.xml</include>
                                    </includes>
                                </filter>
                                <filter>
                                    <artifact>org.apache.hadoop.hive.*:*</artifact>
                                    <excludes>
                                        <exclude></exclude>
                                        <exclude></exclude>
                                        <exclude></exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

user bean

package ubs.app.intervaljoin.bean;

import lombok.*;

@Data
@AllArgsConstructor
@Setter
@Getter
@NoArgsConstructor
public class User{
    Integer id;

    Long t;
    
}

 order bean 

package ubs.app.intervaljoin.bean;

import lombok.*;

@Data
@AllArgsConstructor
@Setter
@Getter
@NoArgsConstructor
public class Order {

    Integer id;

    Long price;

    Long time;

}

main

package ubs.app.intervaljoin;


import org.apache.flink.api.common.eventtime.*;
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.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;
import ubs.app.intervaljoin.bean.Order;
import ubs.app.intervaljoin.bean.User;
import ubs.app.intervaljoin.source.OrderSource;
import ubs.app.intervaljoin.source.UserSource;

import java.time.Duration;

public class IntervalJoinApp  {
    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        //设置watermark
        WatermarkStrategy<User> userWatermarkStrategy = WatermarkStrategy.<User>forBoundedOutOfOrderness(Duration.ofSeconds(1))
                .withTimestampAssigner(new SerializableTimestampAssigner<User>() {

                    @Override
                    public long extractTimestamp(User element, long recordTimestamp) {
                        return element.getT();
                    }
                });

        DataStream<User> userDataStreamSource = env.addSource(new UserSource()).assignTimestampsAndWatermarks(userWatermarkStrategy);
        //设置watermark
        WatermarkStrategy<Order> orderWatermarkStrategy = WatermarkStrategy.<Order>forBoundedOutOfOrderness(Duration.ofSeconds(1))
                .withTimestampAssigner(new SerializableTimestampAssigner<Order>() {
                    @Override
                    public long extractTimestamp(Order element, long recordTimestamp) {
                        return element.getTime();
                    }
                });
        DataStream<Order> orderDataStreamSource = env.addSource(new OrderSource()).assignTimestampsAndWatermarks(orderWatermarkStrategy);

        env.setParallelism(1);
        SingleOutputStreamOperator<String> process = userDataStreamSource.keyBy(o -> o.getId())
                .intervalJoin(orderDataStreamSource.keyBy(o -> o.getId()))
                .between(Time.seconds(-5), Time.seconds(0))
                .process(
                        new ProcessJoinFunction<User, Order, String>() {

                            @Override
                            public void processElement(User left, Order right, ProcessJoinFunction<User, Order, String>.Context ctx, Collector<String> out) throws Exception {
                                Integer lid = left.getId();
                                Long lt = left.getT();
                                Integer rid = right.getId();
                                long rt = right.getTime();
                                out.collect(String.format("左%s 左时间%s 右%s 右时间%s 关联到了 %s", lid, lt/1000, rid, rt/1000, rt/1000-lt/1000));
                            }
                        }
                );
        process.print();
        env.execute();
    }
}

小菜菜1223
关注
专栏目录
Flink Window中的 inner join、left join、right join
扛麻袋的少年的博客
02-21 3836
Flink学习笔记(二十六)：Flink 中的两个流，也是可以实现 Join 操作的。如果两个流要实现 Join 操作，必须满足以下两点： 流需要能够等待，即：两个流必须在同一个窗口中； 双流等值 Join，即：两个流中，必须有一个字段相等才能够 Join 上。 1.Flink 中支持 双流join 的算子   Flin...
Flink intervalJoin 使用 -转载
qq_31866793的博客
12-09 1907
1.前言 Flink中基于DataStream的join，只能实现在同一个窗口的两个数据流进行join，但是在实际中常常会存在数据乱序或者延时的情况，导致两个流的数据进度不一致，就会出现数据跨窗口的情况，那么数据就无法在同一个窗口内join。 Flink基于KeyedStream提供的interval join机制，intervaljoin 连接两个keyedStream, 按照相同的key在一...
Flink temporal table join研究
Deepexi_Date的博客
03-07 2568
作者：王东阳 前言 ANSI-SQL 2011 中提出了Temporal 的概念，Oracle，SQLServer，DB2等大的数据库厂商也先后实现了这个标准。Temporal Table记录了历史上任何时间点所有的数据改动，Temporal Table具有普通table的特性，有具体独特的DDL/DML/QUERY语法，时间是其核心属性。历史意味着时间，意味着快照Snapshot。 Apache Flink遵循ANSI-SQL标准，Apache Flink中Temporal Table的概念也源于ANSI
Java中的数据流处理框架：Apache Flink
最新发布
省赚客开发者博客
08-03 390
Flink是一款用于处理数据流和批处理的分布式处理框架。Apache Flink是一款功能强大的流处理框架，适用于各种实时数据处理场景。通过其强大的API和灵活的扩展能力，Flink可以帮助开发者轻松构建高性能、低延迟的数据处理应用。本文介绍了Flink的基本使用方法和一些高级特性，帮助你快速上手流处理应用的开发。Apache Flink是一个开源流处理框架，专为分布式、状态化的数据流处理而设计。Flink提供了丰富的窗口操作，用于处理数据流中的时间窗口。Flink支持有状态的流处理，通过。
Flink之IntervalJoin介绍
影子
03-11 2254
InterValJoin算子 间隔流，一条流去join另一条流去过去一段时间内的数据，该算子将keyedStream与keyedStream转化为DataStream；再给定的时间边界内（默认包含边界），相当于一个窗口，按指定的key对俩个KeyedStream进行Join操作，把符合join条件的俩个event拉倒一起，然后咋么处理右用户来决定。 1、key1 == key2 && e1.timestamp +lowerBound <= e2.timestamp +upperBoun
大数据Flink（八十八）：Interval Join（时间区间 Join）
Lansonli（蓝深李）的博客
09-24 1768
刚刚的案例也讲了，Regular Join 会产生回撤流，但是在实时数仓中一般写入的 sink 都是类似于 Kafka 这样的消息队列，然后后面接 clickhouse 等引擎，这些引擎又不具备处理回撤流的能力。可以发现 Inner Interval Join 和其他三种 Outer Interval Join 的区别在于，Outer 在随着时间推移的过程中，如果有数据过期了之后，会根据是否是 Outer 将没有 Join 到的数据也给输出。：Interval Join 在离线的概念中是没有的。
Flink IntervalJoin
Claroja
12-21 165
package com.claroja; import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner; import org.apache.flink.api.common.eventtime.WatermarkStrategy; import org.apache.flink.api.java.tuple.Tuple3; import org.apache.flink.streaming.api.TimeChara
flink 的interval join源码分析
weixin_40809627的博客
05-22 741
flink在流与流的join中，与其他window join相比，window中的关联通常是两个流中对应的window中的消息可以发生关联， 不能跨window，Interval Join则没有window的概念，直接用时间戳作为关联的条件，更具表达力。由于流消息的无限性以及消息乱序的影响，本应关联上的消息可能进入处理系统的时间有较大差异，一条流中的消息，可能需要和另一条流的多条消息关联，因此流流关联时，通常需要类似如下关联条件： 等值条件如 a.id = b.id 时间戳范围条件 ： a.timesta
【Flink知识汇总】【Join专题】
weixin_43589563的博客
03-30 1987
Flink Join 专题Join 的应用场景批Join和流Join的区别Flink 双流Join1. Window Join认识Window JoinFlink APISQL API解决方案的特点解决方案的适用场景2. Interval Join2.1 认识Interval Join2.2 Flink API2.3 SQL API2.4 解决方案的特点2.5 解决方案的适用场景3. Regular Join3.1 认识Regular Join3.2 SQL API3.3 解决方案的特点3.4 解决方案的适
FLink 源码分析--（四）Regular Join(普通join)
LS_ice的专栏
09-03 4107
文章目录一、Flink Join介绍1、Join分类A、Regular Join（普通join）B、Time Window JoinC、Join LETERALD、Join Temporal Table时态表E、维表Join2、Regular Join说明3、Regular Join特性 一、Flink Join介绍 1、Join分类 在上一篇文章FLink 源码分析–（三）Time Window...
flinksql如何关联mysql维表_Flink实战（八十三）：flink-sql使用（十）维表join（五）Flink SQL之维表join之Temporal Table Join...
weixin_33902011的博客
02-23 1263
https://zhuanlan.zhihu.com/p/165962937?utm_source=qq维表是数仓中的一个概念，维表中的维度属性是观察数据的角度，在建设离线数仓的时候，通常是将维表与事实表进行关联构建星型模型。在实时数仓中，同样也有维表与事实表的概念，其中事实表通常存储在kafka中，维表通常存储在外部设备中(比如MySQL，HBase)。对于每条流式数据，可以关联一个外部维表数据...
《Flink应用实战》(四)--合并流-IntervalJoin算子
一锅粥
06-14 1392
Flink 中的两个流要实现 Join 操作，必须满足以下两点：流需要能够等待，即：两个流必须在同一个窗口中；双流等值 Join，即：两个流中，必须有一个字段相等才能够 Join 上。Flink 中支持双流 Join 的算子目前已知有5种，如下：：union 支持双流 Join，也支持多流 Join。多个流类型必须一致；：connector 支持双流 Join，两个流的类型可以不一致；：该方法只支持 inner join，即：相同窗口下，两个流中，Key都存在且相同时才会关联成功；：同样能够实现双流 Joi
Flink Interval Join使用以及源码解析
百看不如一RUN
02-21 3618
在之前的Join算子中，一般使用的是coGroup算子，因为一个算子可以提供多种语义，但是也是有一些弊端的。因为coGroup只能实现在同一个窗口的两个数据流之间进行join，在实际的计算过程中，往往会遇到当req发生时，resp迟迟无法响应，这个时候，就会出现一个跨窗口的问题。
Flink IntervalJoin 笔记
qq_42496461的博客
04-24 521
之后就是计算cleanupTime，调用internalTimerService.registerEventTimeTimer注册清理该element的timer，定时的清理时间，就是当下流入的数据的时间+relativeUpperBound，当watermark大于该时间就需要清理。)将数据输出给ProcessJoinFunction调用，ourTimestamp表示流入的数据时间，timestamp表示对应join的数据时间，不满足要求的直接跳过，满足要求的就调用collect方法(
Flink 多流转换 （五） 间隔联结（Interval Join）
weixin_45417821的博客
04-23 1424
文章目录间隔联结的调用间隔联结实例 顾名思义，间隔联结的思路就是针对一条流的每个数据，开辟出其时间戳前后的一段时间间隔，看这期间是否有来自另一条流的数据匹配 间隔连接通过一个共同的key连接两个流（A&B）中的数据，流 B 的数据具有时间戳位于流 A 中元素的相对时间间隔中。 这也可以更正式地表达成 b.timestamp ∈ [a.timestamp + lowerBound; a.timestamp + upperBound] 或者 a.timestamp + lowerBound <=
FlinkSql系列6之 Interval Join
feiyangailing的博客
03-30 4971
FlinkSql系列6之 Interval Join 前言 本次我们来学习flinksql的Interval Join,这个方式主要是针对两个流在一定时间区间内的join,支持事件时间和处理时间，而且这个流每次只会产生一条数据，是一个完全的追加流。 一、Interval Join是什么？ Interval Join 可以让⼀条流去 Join 另⼀条流中前后⼀段时间内的数据。 1.1 Inner Interval Join 只有两条流中的满足时间区间符合，并且满足其他的join条件，这时候才会匹配的上并
flink join 之 interval join
延宝小白马的博客
07-30 345
还有一个很重要的点是：与regular join相比较，interval join只支持带有时间属性的append-only流。Flink Regular Join是最为基础的、没有缓存剔除策略的Join，两个表的输入和更新都会对全局可见，会影响之后所有的Join 结果。Interval join需要至少一个 equi-join 谓词和一个限制了双方时间的 join 条件。interval join 其实就是一种开窗的 regular join，他由flink自身维护状态缓存Row无限增大的问题。
44、Flink 的 Interval Join 详解
猫猫爱吃小鱼粮
05-27 556
Flink 的 Interval Join 详解
flink interval join 的源码你能具体分析一下吗
07-17
下面是对Flink中Interval Join的源码分析： 1. 首先，用户需要指定两个输入流以及连接条件和时间窗口大小等参数来创建一个Interval Join操作。 2. 在Flink中，Interval Join是通过CoProcessFunction来实现的。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值