flink 学习（十三）数据流连接 join

最新推荐文章于 2024-02-20 16:51:06 发布
最新推荐文章于 2024-02-20 16:51:06 发布
阅读量2k 收藏 3
点赞数
分类专栏： flink 文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RenshenLi/article/details/124355633
版权

目录

一、inner join

        两个流中的数据，通过join连接，在通过where和equalsTo条件判断后，条件成立并且处在同一个窗口内的数据会触发后续的窗口操作。

1.开启nc

开启两个端口，模拟两个数据来源

nc -lp 8888
nc -lp 8899

2.示例

 @Test
    public void joinTumblingTest() throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.STREAMING)
                .setParallelism(1);
        //数据流1
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream1 = env.socketTextStream("172.16.10.159", 8888)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1));
        ;
        //数据流2
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream2 = env.socketTextStream("172.16.10.159", 8899)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1));
        ;
        //连接两个数据流
        stream1.join(stream2)
                //第一个流的条件
                .where(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //第二个流的条件
                .equalTo(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //滚动窗口，时间间隔10毫秒
                .window(TumblingEventTimeWindows.of(Time.milliseconds(10)))
                .apply(new JoinFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple3<String, Integer, Integer>>() {
                    @Override
                    public Tuple3<String, Integer, Integer> join(Tuple2<String, Integer> first, Tuple2<String, Integer> second) throws Exception {
                        return new Tuple3<>(first.f0, first.f1, second.f1);
                    }
                })
                .print("join");
        env.execute("joinTumblingTest");
    }

3.测试

数据流1

a,1
a,5
b,6
a,10

数据流2

a,7
a,8
a,11

由于滑动窗口设置的时间间隔是10毫秒，当窗口关闭的时候，处在0~10毫秒内的数据会触发join操作

结果

join> (a,1,7)
join> (a,1,8)
join> (a,5,7)
join> (a,5,8)

在这里插入图片描述

二、sliding-inner-join

        下面测试滑动窗口的内连接

1.示例

滑动窗口时间间隔是4毫秒，滑动间隔是2毫秒

 @Test
    public void joinSlidingTest() throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.STREAMING)
                .setParallelism(1);
        //数据流1
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream1 = env.socketTextStream("172.16.10.159", 8888)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1));
        ;
        //数据流2
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream2 = env.socketTextStream("172.16.10.159", 8899)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1));
        ;
        //连接两个数据流
        stream1.join(stream2)
                //第一个流的条件
                .where(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //第二个流的条件
                .equalTo(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //滚动窗口，时间间隔10毫秒
                .window(SlidingEventTimeWindows.of(Time.milliseconds(4),Time.milliseconds(2)))
                .apply(new JoinFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple3<String, Integer, Integer>>() {
                    @Override
                    public Tuple3<String, Integer, Integer> join(Tuple2<String, Integer> first, Tuple2<String, Integer> second) throws Exception {
                        return new Tuple3<>(first.f0, first.f1, second.f1);
                    }
                })
                .print("sliding-inner-join");
        env.execute("joinSlidingTest");
    }

2.测试

数据流1输入 a,2 和 a,4
数据流2输入a,3 和 a,4

当达到滑动窗口时间间隔4毫秒时触发join连接，打印出 sliding-inner-join> (a,2,3)
在这里插入图片描述
接着
数据流1输入 a,5 和 a,6
数据流2输入a,5 和 a,6

此时到达滑动间隔2毫秒，则4~6之间的数据会触发join操作

在这里插入图片描述

三、session-inner-join

        下面测试会话窗口的内连接

1.示例

会话窗口，时间间隔10毫秒

	@Test
    public void joinSessionTest() throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.STREAMING)
                .setParallelism(1);
        //数据流1
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream1 = env.socketTextStream("172.16.10.159", 8888)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1));
        ;
        //数据流2
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream2 = env.socketTextStream("172.16.10.159", 8899)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1));
        ;
        //连接两个数据流
        stream1.join(stream2)
                //第一个流的条件
                .where(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //第二个流的条件
                .equalTo(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //会话窗口，时间间隔10毫秒
                .window(EventTimeSessionWindows.withGap(Time.milliseconds(10)))
                .apply(new JoinFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple3<String, Integer, Integer>>() {
                    @Override
                    public Tuple3<String, Integer, Integer> join(Tuple2<String, Integer> first, Tuple2<String, Integer> second) throws Exception {
                        return new Tuple3<>(first.f0, first.f1, second.f1);
                    }
                })
                .print("session-inner-join");
        env.execute("joinSessionTest");
    }

2.测试

在这里插入图片描述

数据流1输入 a,3 和 a,14
数据流2输入a,5 和 a,20

四、left-join

两个数据流左连接

1.示例

@Test
    public void leftJoinTest() throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.STREAMING)
                .setParallelism(1);
        //数据流1
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream1 = env.socketTextStream("172.16.10.159", 8888)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        return null;
                    }
                });
        //数据流2
        SingleOutputStreamOperator<Tuple2<String, Integer>> stream2 = env.socketTextStream("172.16.10.159", 8899)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        return null;
                    }
                });
        //连接两个数据流
        stream1.coGroup(stream2)
                //第一个流的条件
                .where(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //第二个流的条件
                .equalTo(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                })
                //滚动窗口，时间间隔10毫秒
                .window(TumblingEventTimeWindows.of(Time.milliseconds(10)))
                .apply(new CoGroupFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple3<String, Integer, Integer>>() {
                    @Override
                    public void coGroup(Iterable<Tuple2<String, Integer>> first, Iterable<Tuple2<String, Integer>> second, Collector<Tuple3<String, Integer, Integer>> out) throws Exception {
                        //左连接
                        for (Tuple2<String, Integer> left : first) {
                            boolean isJoin = false;
                            for (Tuple2<String, Integer> right : second) {
                                isJoin = true;
                                out.collect(new Tuple3<>(left.f0, left.f1, right.f1));
                            }
                            //右侧没有数据
                            if (!isJoin) {
                                out.collect(new Tuple3<>(left.f0, left.f1, null));
                            }
                        }

                    }
                })
                .print("left join");
        env.execute("coGroupTest");
    }

2.测试

当数据时间间隔大于10毫秒时，进行左连接输出

在这里插入图片描述

五、interval-join

进行连接的两个流a和b，如果满足
b.timestamp ∈ [a.timestamp + lowerBound; a.timestamp + upperBound]
或者
a.timestamp + lowerBound <= b.timestamp <= a.timestamp + upperBound
即b的时间戳位于a的时间戳的下限和上限的范围内，可以触发join操作。

1.示例

@Test
    public void intervalJoinTest() throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setRuntimeMode(RuntimeExecutionMode.STREAMING)
                .setParallelism(1);
        //数据流1
        KeyedStream<Tuple2<String, Integer>, String> stream1 = env.socketTextStream("172.16.10.159", 8888)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1))
                .keyBy(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                });
        //数据流2
        KeyedStream<Tuple2<String, Integer>, String> stream2 = env.socketTextStream("172.16.10.159", 8899)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] s = value.split(",");
                        return new Tuple2<>(s[0], Integer.parseInt(s[1]));
                    }
                })
                .assignTimestampsAndWatermarks(WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps().withTimestampAssigner((element, recordTimestamp) -> element.f1))
                .keyBy(new KeySelector<Tuple2<String, Integer>, String>() {
                    @Override
                    public String getKey(Tuple2<String, Integer> value) throws Exception {
                        return value.f0;
                    }
                });
        //连接两个数据流
        stream1.intervalJoin(stream2)
                //事件时间
                .inEventTime()
                //定义上下界
                .between(Time.milliseconds(-2), Time.milliseconds(2))
                //不包含下界
                .lowerBoundExclusive()
                .process(new ProcessJoinFunction<Tuple2<String, Integer>, Tuple2<String, Integer>, Tuple3<String,Integer, Integer>>() {
                    @Override
                    public void processElement(Tuple2<String, Integer> left, Tuple2<String, Integer> right, Context ctx, Collector<Tuple3<String, Integer, Integer>> out) throws Exception {
                        out.collect(new Tuple3<>(left.f0, left.f1, right.f1));
                    }
                })
                .print("interval-join");
        env.execute("intervalJoinTest");
    }

2.测试

数据流1输入

a,5

数据,流2输入

a,3
a,4
a,6
a,7
a,8

根据定义的上下界是 -2 和 2，数据流2中数据位于 5-2 和 5+2 之间的数据会进行join操作

在这里插入图片描述

_lrs
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
剑指大数据——Flink学习精要_java版
04-21
剑指大数据——Flink学习精要_java版
FlinkSql系列6之 Interval Join
feiyangailing的博客
03-30 4582
FlinkSql系列6之 Interval Join 前言 本次我们来学习flinksql的Interval Join,这个方式主要是针对两个流在一定时间区间内的join,支持事件时间和处理时间，而且这个流每次只会产生一条数据，是一个完全的追加流。 一、Interval Join是什么？ Interval Join 可以让⼀条流去 Join 另⼀条流中前后⼀段时间内的数据。 1.1 Inner Interval Join 只有两条流中的满足时间区间符合，并且满足其他的join条件，这时候才会匹配的上并
Flink join详解（含两类API及coGroup、connect详解）
weixin_51981189的博客
02-20 1652
join、regular join、interval join、temporal join、connect、coGroup
Flink 流数据批量写入数据库
12-26
Flink常常存在将流数据写入数据库的场景，一般是通过继承RichSinkFunction来实现对数据的写入。如果sink之前不做优化处理，写入时都是单条写入。单条写入有许多弊端： 1、写入频繁造成数据库压力大 2、写入速度慢、效率低，造成反压 所以需要使用批量写入的方式，那如何实现呢？
Flink入门：读取Kafka实时数据流，实现WordCount
01-07
本文主要介绍Flink接收一个Kafka文本数据流，进行WordCount词频统计，然后输出到标准输出上。通过本文你可以了解如何编写和运行Flink程序。 代码拆解 首先要设置Flink的执行环境： // 创建Flink执行环境 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); 设置Kafka相关参数，连接对应的服务器和端口号，读取名为Shakespeare的Topic中的数据源，将数据源命名为stream： // Kafka参数 Properties propert
flink学习教程，flink学习案例
05-15
flink学习教程，flink学习案例
Flink之详解InnerJoin、leftJoin以及窗口延迟时间的问题
IT_但丁的博客
03-16 4831
文章目录以案例驱动对join的认知一、前提：二、InnerJoin代码 以案例驱动对join的认知 一、前提： 要想两个数据流进行Join，必须对两个流数据划分相同的窗口，在同一个窗口中，进行数据的Join连接。 这里使用EventTime，划分滚动窗口 二、InnerJoin代码 package cn._51doit.day10.join; import org.apache.flink....
FlinkSql中的join查询
qq_42456324的博客
11-06 1606
使用简单和离线数仓一样：因为历史，因为资源问题一般只用做有界数据流的 Join，或者。
Flink（五十八）—— 双流中实现Inner Join、Left Join与Right Join
weixin_42073629的博客
10-22 970
简介 之前文章中提到JoinedStream与CoGroupedStream，例如下列代码： dataStream.join(otherStream) .where(0).equalTo(1) .window(TumblingEventTimeWindows.of(Time.seconds(3))) .apply { ... } 由于joinedStream与coGroupedStream来自于一个特定的window，且在一个关联上的key中实现，因此，Flink中的双流jo
Flink Window中的 inner join、left join、right join
扛麻袋的少年的博客
02-21 3778
Flink学习笔记(二十六)：Flink 中的两个流，也是可以实现 Join 操作的。如果两个流要实现 Join 操作，必须满足以下两点： 流需要能够等待，即：两个流必须在同一个窗口中； 双流等值 Join，即：两个流中，必须有一个字段相等才能够 Join 上。 1.Flink 中支持 双流join 的算子   Flin...
Flink join（流流）详解（一）
Aspirin's Nest
12-09 2012
本文基于flink 1.11进行测试。 前言 本文仅仅作为一个Flink join入门demo的记录，会用到Flink1.11 事件时间（event time）、watermark、watermarkstrategy使用详细案例文章的知识。 代码 创建用于join的两个数据源 package it.kenn.source; import org.apache.flink.streaming.api.functions.source.SourceFunction; import scala.
基于Java的Flink流批一体数据处理快速集成开发框架设计源码
最新发布
03-29
这是一个基于Java的Flink流批一体数据处理快速集成开发框架设计，使用Java语言开发，包含203个文件。主要文件类型包括169个Java源文件、11个XML文件、7个gitignore文件、3个PNG图片文件、2个Markdown文档、2个...
大数据Flink（八十八）：Interval Join（时间区间 Join）
Lansonli（蓝深李）的博客
09-24 1222
刚刚的案例也讲了，Regular Join 会产生回撤流，但是在实时数仓中一般写入的 sink 都是类似于 Kafka 这样的消息队列，然后后面接 clickhouse 等引擎，这些引擎又不具备处理回撤流的能力。可以发现 Inner Interval Join 和其他三种 Outer Interval Join 的区别在于，Outer 在随着时间推移的过程中，如果有数据过期了之后，会根据是否是 Outer 将没有 Join 到的数据也给输出。：Interval Join 在离线的概念中是没有的。
Flink教程(22) 窗口 interval join的使用案例
Java Spring Elasticsearch
04-01 2118
Flink 窗口 interval join的使用一、前言二、interval join介绍三、语法案例 一、前言 在之前的博客两条流关联 window窗口的 join leftJoin使用案例中，介绍了window join的使用方法。 但是window join可能稍微复杂和麻烦，现在在真实的工作中，用interval join的情况比较多。 interval join相对逻辑简单，好理解些。 二、interval join介绍 interval join只支持事件时间的场景 只能支持两条流的关联 在
flink实战--双流join之原理解析
hellojoy的博客
10-27 2158
flink实战--双流join之原理解析 JOIN简介 谈flink双流JOIN之前，我们先谈一下大家最熟悉的mysql表join，我们知道表join有如下几种，具体区别就不在介绍了。那么流的join和表的join有什么区别呢？本文我们介绍一下。 CROSS JOIN - 交叉连接，计算笛卡儿积； INNER JOIN - 内连接，返回满足条件的记录； OUTER JOIN LEFT - 返回左表所有行，右表不存在补NULL； RIGHT - 返回右表所有行，左边不存在补NULL； FULL -
Flink intervalJoin 使用 -转载
qq_31866793的博客
12-09 1856
1.前言 Flink中基于DataStream的join，只能实现在同一个窗口的两个数据流进行join，但是在实际中常常会存在数据乱序或者延时的情况，导致两个流的数据进度不一致，就会出现数据跨窗口的情况，那么数据就无法在同一个窗口内join。 Flink基于KeyedStream提供的interval join机制，intervaljoin 连接两个keyedStream, 按照相同的key在一...
大数据之flink中join用法
大数据同盟会的博客
02-14 4105
1、将两个流中的数据进行join处理 package cn._51doit.flink.day05; import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.java.functions.KeySelector; import org.apache.flink.api.java.tuple.Tuple3; import org.apache.flink.api.java.tuple.Tup
Flink 双流Join
METON的博客
11-13 1335
支持的join类型 Apache Flink目前支持INNER JOIN和LEFT OUTER JOIN（SELF 可以转换为普通的INNER和OUTER)。在语义上面Apache Flink严格遵守标准SQL的语义 CROSS INNER OUTER SELF ON WHERE Apache Flink N Y Y Y 必选 可选 双流Join的分类： Join大体分类只有两种：Window ...
Flink 处理函数
mengxianglong123的博客
03-31 1908
概述   之前所介绍的流处理 API，无论是基本的转换、聚合，还是更为复杂的窗口操作，其实都是基于 DataStream 进行转换的；所以可以统称为DataStream API，这也是 Flink 编程的核心。而我们知道，为了让代码有更强大的表现力和易用性，Flink 本身提供了多层API，DataStream API 只是中间的一环。   在更底层，我们可以不定义任何具体的算子（比如map，filter，或者window），而只是提炼出一个统一的“处理”（process）操作——它是所有转换算子的一个概
flink join流
11-30
flink中的join操作可以将两个或多个数据流中的元素进行关联，从而生成一个新的数据流。flink支持多种类型的join操作，包括inner join、left join、right join和full outer join等。下面是一个简单的flink join流的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_lrs

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值