Flink【基于时间的双流联结 Demo】

前言

1、基于时间的双流联结（Join）

对于两条流的合并，很多情况我们并不是简单地将所有数据放在一起，而是希望根据某个字段的值将它们联结起来，“配对”去做处理。例如用传感器监控火情时，我们需要将大量温度传感器和烟雾传感器采集到的信息，按照传感器 ID 分组、再将两条流中数据合并起来，如果同时超过设定阈值就要报警。
我们发现，这种需求与关系型数据库中表的 join 操作非常相近。事实上，Flink 中两条流的 connect 操作，就可以通过 keyBy 指定键进行分组后合并，实现了类似于 SQL 中的 join 操作；另外 connect 支持处理函数，可以使用自定义状态和 TimerService 灵活实现各种需求，其实已经能够处理双流合并的大多数场景。不过处理函数是底层接口，所以尽管 connect 能做的事情多，但在一些具体应用场景下还是显得太过抽象了。比如，如果我们希望统计固定时间内两条流数据的匹配情况，那就需要设置定时器、自定义触发逻辑来实现——其实这完全可以用窗口（window）来表示。为了更方便地实现基于时间的合流操作，Flink 的 DataStrema API 提供了两种内置的 join 算子，以及coGroup 算子。

SQL 中 join 一般会翻译为“连接”；这里为了区分不同的算子，一般的合流操作connect 翻译为“连接”，而把 join 翻译为“联结”。

1.1、窗口联结（Join）

如果我们希望将两条流的数据进行合并、且同样针对某段时间进行处理和统计（将属于同一窗口内的两条流相同 key 的数据合并到一起）。Flink 为这种场景专门提供了一个窗口联结（window join）算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理。

1.1.1、窗口联结的调用

窗口联结在代码中的实现，首先需要调用 DataStream 的.join()方法来合并两条流，得到一个 JoinedStreams；接着通过.where()和.equalTo()方法指定两条流中联结的 key；然后通过.window()开窗口，并调用.apply()传入联结窗口函数进行处理计算。通用调用形式如下：

stream1.join(stream2)
 .where(<KeySelector>)    // 指定第一条流中的 key选择器
 .equalTo(<KeySelector>)    // 指定第二条流中的 key选择器
 .window(<WindowAssigner>)    // 定义窗口
 .apply(<JoinFunction>)    // 定义合并逻辑，返回结果

上面代码中.where()的参数是键选择器（KeySelector），用来指定第一条流中的 key；而.equalTo()传入的 KeySelector 则指定了第二条流中的 key。两者相同的元素，如果在同一窗口中，就可以匹配起来，并通过一个“联结函数”（JoinFunction）进行处理了。
这里.window()传入的就是窗口分配器，之前讲到的三种时间窗口都可以用在这里：滚动窗口（tumbling window）、滑动窗口（sliding window）和会话窗口（session window）。而后面调用.apply()可以看作实现了一个特殊的窗口函数。注意：这里只能调用.apply()，没有其他替代的方法。

传入的 JoinFunction 也是一个函数类接口，使用时需要实现内部的.join()方法。这个方法有两个参数，分别表示两条流中成对匹配的数据。JoinFunction 在源码中的定义如下：

public interface JoinFunction<IN1, IN2, OUT> extends Function, Serializable {
 OUT join(IN1 first, IN2 second) throws Exception;
}

这里的 JoinFunciton 并不是真正的“窗口函数”，它只是定义了窗口函数在调用时对匹配数据的具体处理逻辑。

1.1.2、窗口联结的原理

JoinFunction 中的两个参数，分别代表了两条流中的匹配的数据。那什么时候就会匹配好数据，调用.join()方法呢？
事实上，两条流的数据到来之后，首先会按照 key 分组、进入对应的窗口中存储；当到达窗口结束时间时，算子会先统计出窗口内两条流的数据的所有组合，也就是对两条流中的数据做一个笛卡尔积（相当于表的交叉连接，cross join），然后进行遍历，把每一对匹配的数据，作为参数(first，second)传入 JoinFunction 的.join()方法进行计算处理，得到的结果直接输出。所以窗口中每有一对数据成功联结匹配，JoinFunction 的.join()方法就会被调用一次，并输出一个结果。

除了 JoinFunction，在.apply()方法中还可以传入 FlatJoinFunction，用法非常类似，只是内部需要实现的.join()方法没有返回值。结果的输出是通过收集器（Collector）来实现的，所以对于一对匹配数据可以输出任意条结果。

1.1.3、案例

package com.lyh.watermark;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
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.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

public class WindowJoinDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<Tuple2<String, Integer>> ds1 = env.fromElements(
                Tuple2.of("a", 1),
                Tuple2.of("a", 2),
                Tuple2.of("b", 1),
                Tuple2.of("c", 1)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        SingleOutputStreamOperator<Tuple3<String, Integer,Integer>> ds2 = env.fromElements(
                Tuple3.of("a", 1,1),
                Tuple3.of("a", 6,1),
                Tuple3.of("b", 1,1),
                Tuple3.of("c", 5,1)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple3<String, Integer,Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        // window join
        DataStream<String> join = ds1.join(ds2)
                .where(r1 -> r1.f0) // 流1 的 key选择器
                .equalTo(r2 -> r2.f0)// 流2 的key选择器
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                // apply 的参数: param1: 流1的类型 param2: 流2的类型 param3: 返回值类型
                .apply(new JoinFunction<Tuple2<String, Integer>, Tuple3<String, Integer, Integer>, String>() {
                    @Override
                    public String join(Tuple2<String, Integer> first, Tuple3<String, Integer, Integer> second) throws Exception {
                        return first + " <------> " + second;
                    }
                });

        join.print();

        env.execute();
    }
}

这里，我们定义了两条数据流：

  流1            流2
(编号,时间s) (编号,时间s,其它)
("a", 1)     ("a", 1,1)
("a", 2)     ("a", 6,1)
("b", 1)     ("b", 1,1)
("c", 1)     ("c", 5,1)

并划分窗口大小为 5s，希望能够对同一时间窗口内两条流的数据进行一个联结。

运行结果：

(a,1) <------> (a,1,1)
(a,2) <------> (a,1,1)
(b,1) <------> (b,1,1)

可以看到，对于不在同一时间窗口内的数据，它是无法联结的。

总结

必须落在同一时间窗口内的数据才能匹配
根据 key 进行匹配
只能匹配相同 key 的，类似于 inner join

SELECT * FROM table1 t1, table2 t2 WHERE t1.id = t2.id;

1.2、间隔联结（Interval join）

Flink 并不建议使用窗口联结（Window Join），因为缺点很明显：在有些场景下，我们要处理的时间间隔可能并不是固定的。比如，在交易系统中，需要实时地对每一笔交易进行核验，保证两个账户转入转出数额相等，也就是所谓的“实时对账”。两次转账的数据可能写入了不同的日志流，它们的时间戳应该相差不大，所以我们可以考虑只统计一段时间内是否有出账入账的数据匹配。这时显然不应该用滚动窗口或滑动窗口来处理——因为匹配的两个数据有可能刚好“卡在”窗口边缘两侧，于是窗口内就都没有匹配了；会话窗口虽然时间不固定，但也明显不适合这个场景。基于时间的窗口联结已经无能为力了。
为了应对这样的需求，Flink 提供了一种叫作“间隔联结”（interval join）的合流操作。顾名思义，间隔联结的思路就是针对一条流的每个数据，开辟出其时间戳前后的一段时间间隔，看这期间是否有来自另一条流的数据匹配。

1.2.1、间隔联结的原理

间隔联结具体的定义方式是，我们给定两个时间点，分别叫作间隔的“上界”（upperBound）和“下界”（lowerBound）；于是对于一条流（不妨叫作 A）中的任意一个数据元素 a，就可以开辟一段时间间隔：[a.timestamp + lowerBound, a.timestamp + upperBound],即以 a 的时间戳为中心，下至下界点、上至上界点的一个闭区间：我们就把这段时间作为可以匹配另一条流数据的“窗口”范围。所以对于另一条流（不妨叫 B）中的数据元素 b，如果它的时间戳落在了这个区间范围内，a 和 b 就可以成功配对，进而进行计算输出结果。所以匹配的条件为：a.timestamp + lowerBound <= b.timestamp <= a.timestamp + upperBound这里需要注意，做间隔联结的两条流 A 和 B，也必须基于相同的 key；下界 lowerBound应该小于等于上界 upperBound，两者都可正可负；间隔联结目前只支持事件时间语义。

1.2.2、案例

package com.lyh.watermark;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
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.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;

public class IntervalJoinDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<Tuple2<String, Integer>> ds1 = env.fromElements(
                Tuple2.of("a", 1),
                Tuple2.of("a", 2),
                Tuple2.of("b", 2),
                Tuple2.of("c", 3)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        SingleOutputStreamOperator<Tuple3<String, Integer,Integer>> ds2 = env.fromElements(
                Tuple3.of("a", 1,1),
                Tuple3.of("a", 3,1),
                Tuple3.of("b", 1,1),
                Tuple3.of("c", 2,1)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple3<String, Integer,Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        // interval join

        // 1. 分别做 keyby
        KeyedStream<Tuple2<String, Integer>, String> ks1 = ds1.keyBy(r1 -> r1.f0);
        KeyedStream<Tuple3<String, Integer, Integer>, String> ks2 = ds2.keyBy(r2 -> r2.f0);
        //2. 调用 interval join
        SingleOutputStreamOperator<String> process = ks1.intervalJoin(ks2)
                .between(Time.seconds(-2L), Time.seconds(2L))
                .process(new ProcessJoinFunction<Tuple2<String, Integer>, Tuple3<String, Integer, Integer>, String>() {
                    @Override
                    public void processElement(Tuple2<String, Integer> left, Tuple3<String, Integer, Integer> right, Context ctx, Collector<String> out) throws Exception {
                        out.collect(left + " <--------> " + right);
                    }
                });

        process.print();

        env.execute();
    }
}

我们同样定义了两条流：

  流1            流2
(编号,时间s) (编号,时间s,其它)
("a", 1)     ("a", 1,1)
("a", 2)     ("a", 3,1)
("b", 2)     ("b", 1,1)
("c", 3)     ("c", 2,1)

运行结果：

(a,1) <--------> (a,1,1)
(a,1) <--------> (a,3,1)
(a,2) <--------> (a,1,1)
(a,2) <--------> (a,3,1)
(b,2) <--------> (b,1,1)
(c,3) <--------> (c,2,1)

可以看到，划分上下界相当于划分了一个[a.timestamp + lowerBound, a.timestamp + upperBound]的窗口（但其实不是窗口）。

1.3、迟到数据的处理

如果划分上下界后，还有迟到的数据怎么办？也就是两条流的 key 是可以匹配的，但是水位线已经被来了的数据推进到超出上界了，所以已经触发计算输出了，而这时候比如 ks1 有一条数据姗姗来迟，它是属于上下界范围内的，但是由于我们的水位线已经推进到超出上下界范围之外了，那么这个时候怎么处理呢？

我们会把它放到侧输出流，一般做一个展示或者输出。

package com.lyh.watermark;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.KeyedStream;
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 org.apache.flink.util.OutputTag;

import java.time.Duration;

public class IntervalJoinWithLateDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<Tuple2<String, Integer>> ds1 = env
                .socketTextStream("localhost",9999)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] datas = value.split(",");
                        return Tuple2.of(datas[0],Integer.valueOf(datas[1]));
                    }
                })
        .assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple2<String, Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        SingleOutputStreamOperator<Tuple3<String, Integer,Integer>> ds2 = env
                .socketTextStream("localhost",8888)
                .map(new MapFunction<String, Tuple3<String, Integer,Integer>>() {
                    @Override
                    public Tuple3<String, Integer,Integer> map(String value) throws Exception {
                        String[] datas = value.split(",");
                        return Tuple3.of(datas[0],Integer.valueOf(datas[1]),Integer.valueOf(datas[2]));
                    }
                })
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                // 允许迟到 3s
                                .<Tuple3<String, Integer,Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                                .withTimestampAssigner((value, ts) -> (value.f1 * 1000L)
                ));

        // interval join

        // 1. 分别做 keyby
        KeyedStream<Tuple2<String, Integer>, String> ks1 = ds1.keyBy(r1 -> r1.f0);
        KeyedStream<Tuple3<String, Integer, Integer>, String> ks2 = ds2.keyBy(r2 -> r2.f0);
        //2. 调用 interval join
        OutputTag<Tuple2<String,Integer>> ks1Late = new OutputTag<>("ks1-late", Types.TUPLE(Types.STRING, Types.INT));
        OutputTag<Tuple3<String,Integer,Integer>> ks2Late = new OutputTag<>("ks2-late", Types.TUPLE(Types.STRING, Types.INT,Types.INT));
        SingleOutputStreamOperator<String> process = ks1.intervalJoin(ks2)
                .between(Time.seconds(-2L), Time.seconds(2L))
                .sideOutputLeftLateData(ks1Late)
                .sideOutputRightLateData(ks2Late)
                .process(new ProcessJoinFunction<Tuple2<String, Integer>, Tuple3<String, Integer, Integer>, String>() {
                    @Override
                    public void processElement(Tuple2<String, Integer> left, Tuple3<String, Integer, Integer> right, Context ctx, Collector<String> out) throws Exception {
                        out.collect(left + " <--------> " + right);
                    }
                });

        process.print("主流");
        process.getSideOutput(ks1Late).print("ks1 迟到数据");
        process.getSideOutput(ks2Late).print("ks2 迟到数据");

        env.execute();
    }
}

运行结果：

主流> (a,4) <--------> (a,3,3)
主流> (a,10) <--------> (a,11,11)
ks1 迟到数据> (a,3)
ks2 迟到数据> (a,5,5)