（十）Flink Datastream API 编程指南 算子-3 window join和interval join

Window Join

一个window join将共享同一个键并位于同一窗口中的两个流的元素联接起来。这些窗口可以通过使用窗口分配器来定义，并在来自两个流的元素上求值。

然后将两边的元素传递给用户定义的JoinFunction或FlatJoinFunction，用户可以发出满足连接条件的结果。

一般用法可以总结如下:

stream.join(otherStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(<WindowAssigner>)
    .apply(<JoinFunction>);

一些语义注释:

• 两个流元素的成对组合的创建类似于内部连接，这意味着如果一个流的元素没有来自另一个流的相应元素可以连接，那么它们将不会被触发。
• 那些加入的元素的时间戳将会是最大的时间戳，这个时间戳仍然在各自的窗口中。例如，一个以[5,10)为边界的窗口将导致连接元素的时间戳为9。

Tumbling Window Join

当执行翻滚窗口连接时，所有具有公共键和公共翻滚窗口的元素将作为成对组合进行连接，并传递给JoinFunction或FlatJoinFunction。因为它的行为类似于内部连接，所以一个流的元素如果在翻滚窗口中没有来自另一个流的元素，就不会被触发!

如图所示，我们定义了一个大小为2毫秒的翻滚窗口，其结果为[0,1]，[2,3]，…图片显示了每个窗口中所有元素的成对组合，这些元素将被传递给JoinFunction。注意，在翻滚窗口[6,7]中没有任何元素被触发，因为在绿色的流中没有元素与橙色的元素(⑥和⑦)相连接。

package com.flink.datastream.join;

import org.apache.flink.api.common.functions.JoinFunction;
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.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

/**
 * @author DeveloperZJQ
 * @since 2022-6-5
 */
public class TumblingWindowJoin {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        String ip = "127.0.0.1";
        if (args.length == 1) {
            ip = args[0];
        }
        DataStreamSource<String> orangeStream = env.socketTextStream(ip, 9999);
        DataStreamSource<String> greenStream = env.socketTextStream(ip, 9998);

        DataStream<String> joinStream = orangeStream.join(greenStream)
                .where(one -> one)
                .equalTo(two -> two)
 # TumblingProcessingTimeWindows 如果使用事件翻滚窗口分配器的话，需要指定时间戳，这里图方便，就直接使用的处理时间窗口                .window(TumblingProcessingTimeWindows.of(Time.seconds(2)))
                .apply((JoinFunction<String, String, String>) (first, second) -> first + "," + second);

        joinStream.print();

        env.execute();
    }
}

Sliding Window Join

当执行滑动窗口连接时，所有具有公共键和公共滑动窗口的元素都作为成对组合进行连接，并传递给JoinFunction或FlatJoinFunction。一个流的元素如果没有当前滑动窗口中来自另一个流的元素，则不会被触发!注意，有些元素可能在一个滑动窗口中连接，但在另一个窗口中不连接!

在本例中，我们使用大小为2毫秒的滑动窗口，并将其滑动1毫秒，从而得到[-1,0]，[0,1]，[1,2]，[2,3]，…x轴下面的join元素是传递给每个滑动窗口的JoinFunction的元素。在这里你还可以看到，例如窗口[2,3]中橙色的②和绿色的③是如何连接的，但没有与窗口[1,2]中的任何东西连接。

import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.windowing.assigners.SlidingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

...

DataStream<Integer> orangeStream = ...;
DataStream<Integer> greenStream = ...;

orangeStream.join(greenStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(SlidingEventTimeWindows.of(Time.milliseconds(2) /* size */, Time.milliseconds(1) /* slide */))
    .apply (new JoinFunction<Integer, Integer, String> (){
        @Override
        public String join(Integer first, Integer second) {
            return first + "," + second;
        }
    });

Session Window Join

当执行会话窗口连接时，所有具有相同键的元素(当“组合”时满足会话标准)将以成对组合的方式连接起来，并传递给JoinFunction或FlatJoinFunction。这再次执行一个内部连接，因此如果有一个会话窗口只包含来自一个流的元素，则不会发出任何输出!

这里我们定义了一个会话窗口连接，其中每个会话至少间隔1ms。有三个会话，在前两个会话中，来自两个流的连接元素被传递给JoinFunction。在第三个session中，绿色流中没有任何元素，所以⑧和⑨是不连接的!

import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.windowing.assigners.EventTimeSessionWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
 
...

DataStream<Integer> orangeStream = ...;
DataStream<Integer> greenStream = ...;

orangeStream.join(greenStream)
    .where(<KeySelector>)
    .equalTo(<KeySelector>)
    .window(EventTimeSessionWindows.withGap(Time.milliseconds(1)))
    .apply (new JoinFunction<Integer, Integer, String> (){
        @Override
        public String join(Integer first, Integer second) {
            return first + "," + second;
        }
    });

Interval Join

interval join使用一个通用键连接两个流(现在我们称之为A和B)的元素，其中流B的元素的时间戳与流A中元素的时间戳处于相对时间间隔内。
这也可以更正式地表示为b.timestamp∈[a]。时间戳+下界;a.timestamp + upperBound]或a.timestamp + lowerBound <= b.timestamp <= a.timestamp + upperBound.

其中a和b是A和B的元素，它们共享一个共同的键。下界和上界都可以是负的或正的，只要下界总是小于或等于上界。间隔连接目前只执行内部连接。

当一对元素被传递给ProcessJoinFunction时，它们将被分配两个元素更大的时间戳(可以通过ProcessJoinFunction. context访问)。

interval join 目前只支持事件时间。

在上面的例子中，我们将两个流“橙色”和“绿色”连接起来，下界为-2毫秒，上界为+1毫秒。默认情况下，这些边界是包含的，但是可以应用lowerboundexclusive()和upperboundexclusive()来改变行为。

使用更正式的符号，这将转化为
orangeElem.ts + lowerBound <= greenElem.ts <= orangeElem.ts + upperBound
如三角形所示。

import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.windowing.time.Time;

...

DataStream<Integer> orangeStream = ...;
DataStream<Integer> greenStream = ...;

orangeStream
    .keyBy(<KeySelector>)
    .intervalJoin(greenStream.keyBy(<KeySelector>))
    .between(Time.milliseconds(-2), Time.milliseconds(1))
    .process (new ProcessJoinFunction<Integer, Integer, String(){

        @Override
        public void processElement(Integer left, Integer right, Context ctx, Collector<String> out) {
            out.collect(left + "," + right);
        }
    });