迟到数据处理 和 基本时间的合流

一、迟到的数据处理

        1.推迟水印推进

      在水印产生时，设置一个乱序容忍度，推迟系统时间的推进，保证窗口计算被延迟执行，为乱序的数据争取更多的时间进入窗口。

WatermarkStrategy.forBoundedOutOfOrderness(Duration.ofSeconds(10));

        2.设置窗口延迟关闭  

         Flink的窗口，也允许迟到数据。当触发了窗口计算后，会先计算当前的结果，但是此时并不会关闭窗口。

        以后每来一条迟到数据，就触发一次这条数据所在窗口计算(增量计算)。直到wartermark 超过了窗口结束时间+推迟时间，此时窗口会真正关闭。

.window(TumblingEventTimeWindows.of(Time.seconds(5)))
.allowedLateness(Time.seconds(3))

注意：

        允许迟到只能运行在event time 上 

       3. 使用测流接收迟到的数据

.windowAll(TumblingEventTimeWindows.of(Time.seconds(5)))

.allowedLateness(Time.seconds(3))

.sideOutputLateData(lateWS)

二、基本时间的合流-----双流联结(Join)

        1.窗口联结(Window Join)

        Flink为基于一段时间的双流合并专门提供了一个窗口联结算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理。

          窗口联结的调用

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

stream1.join(stream2)
        .where()
        .equalTo()
        .window()
        .apply()

        上面代码中.where()的参数是键选择器（KeySelector），用来指定第一条流中的key；而.equalTo()传入的KeySelector则指定了第二条流中的key。两者相同的元素，如果在同一窗口中，就可以匹配起来，并通过一个“联结函数”（JoinFunction）进行处理了。

        这里.window()传入的就是窗口分配器，之前讲到的三种时间窗口都可以用在这里：滚动窗口（tumbling window）、滑动窗口（sliding window）和会话窗口（session window）。

        而后面调用.apply()可以看作实现了一个特殊的窗口函数。注意这里只能调用.apply()，没有其他替代的方法。

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

        其实仔细观察可以发现，窗口join的调用语法和我们熟悉的SQL中表的join非常相似：

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

        这句SQL中where子句的表达，等价于inner join ... on，所以本身表示的是两张表基于id的“内连接”（inner join）。而Flink中的window join，同样类似于inner join。也就是说，最后处理输出的，只有两条流中数据按key配对成功的那些；如果某个窗口中一条流的数据没有任何另一条流的数据匹配，那么就不会调用JoinFunction的.join()方法，也就没有任何输出了。 

java：

public class WindowJoinExample {  
  
    public static void main(String[] args) throws Exception {  
  
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();  
  
        // 创建点击事件流  
        DataStream> clickStream = env.fromElements(  
                Tuple2.of("user1", "item1"),  
                Tuple2.of("user2", "item2"),  
                Tuple2.of("user1", "item3")  
        ).keyBy(t -> t.f0) // 按用户ID进行分区  
         .window(TumblingProcessingTimeWindows.of(Time.seconds(5))) // 定义5秒的滚动窗口  
         .map(new MapFunction, Tuple2>() {  
             @Override  
             public Tuple2 map(Tuple2 value) throws Exception {  
                 return new Tuple2<>(value.f0, "click:" + value.f1);  
             }  
         });  
  
        // 创建购买事件流  
        DataStream> buyStream = env.fromElements(  
                Tuple2.of("user1", "item1"),  
                Tuple2.of("user3", "item2"),  
                Tuple2.of("user1", "item4")  
        ).keyBy(t -> t.f0) // 按用户ID进行分区  
         .window(TumblingProcessingTimeWindows.of(Time.seconds(5))) // 定义5秒的滚动窗口  
         .map(new MapFunction, Tuple2>() {  
             @Override  
             public Tuple2 map(Tuple2 value) throws Exception {  
                 return new Tuple2<>(value.f0, "buy:" + value.f1);  
             }  
         });  
  
        // 联结点击和购买事件流  
        DataStream joinedStream = clickStream  
                .join(buyStream)  
                .where(t -> t.f0) // 使用第一个元素（用户ID）作为联结键  
                .equalTo(t -> t.f0) // 使用第一个元素（用户ID）作为联结键  
                .window(TumblingProcessingTimeWindows.of(Time.seconds(5))) // 联结窗口，应该与前面定义的窗口大小相同  
                .apply(new JoinFunction, Tuple2, String>() {  
                    @Override  
                    public String join(Tuple2 click, Tuple2 buy) throws Exception {  
                        return click.f0 + " clicked and bought: " + click.f1 + ", " + buy.f1;  
                    }  
                });  
  
        // 打印结果  
        joinedStream.print();  
  
        // 执行Flink作业  
        env.execute("Window Join Example");  
    }  
}

scala：

val env = StreamExecutionEnvironment.getExecutionEnvironment  

env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

val userActivity = env.addSource(new UserActivitySource) // 假设UserActivitySource是生成用户活动数据的源头  

val orders = env.addSource(new OrderSource) // 假设OrderSource是生成订单数据的源头

val windowedUserOrders = orders  
  .keyBy("userId") // 按用户ID进行分组  
  .timeWindow(Time.minutes(30)) // 定义30分钟的窗口  
  .sum("orderId") // 计算每个窗口内的订单数量

windowedUserOrders.print()  
  
env.execute("Window Join Example")

        2.间隔联结(Interval Join)

        在有些场景下，我们要处理的时间间隔可能并不是固定的。这时显然不应该用滚动窗口或滑动窗口来处理——因为匹配的两个数据有可能刚好“卡在”窗口边缘两侧，于是窗口内就都没有匹配了；会话窗口虽然时间不固定，但也明显不适合这个场景。基于时间的窗口联结已经无能为力了。

        为了应对这样的需求，Flink提供了一种叫作“间隔联结”（interval join）的合流操作。顾名思义，间隔联结的思路就是针对一条流的每个数据，开辟出其时间戳前后的一段时间间隔，看这期间是否有来自另一条流的数据匹配。

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，两者都可正可负；间隔联结目前只支持事件时间语义。

        如下图所示，我们可以清楚地看到间隔联结的方式：

        下方的流A去间隔联结上方的流B，所以基于A的每个数据元素，都可以开辟一个间隔区间。我们这里设置下界为-2毫秒，上界为1毫秒。于是对于时间戳为2的A中元素，它的可匹配区间就是[0, 3],流B中有时间戳为0、1的两个元素落在这个范围内，所以就可以得到匹配数据对（2, 0）和（2, 1）。同样地，A中时间戳为3的元素，可匹配区间为[1, 4]，B中只有时间戳为1的一个数据可以匹配，于是得到匹配数据对（3, 1）。

        所以我们可以看到，间隔联结同样是一种内连接（inner join）。与窗口联结不同的是，interval join做匹配的时间段是基于流中数据的，所以并不确定；而且流B中的数据可以不只在一个区间内被匹配。

2）间隔联结的调用

        间隔联结在代码中，是基于KeyedStream的联结（join）操作。DataStream在keyBy得到KeyedStream之后，可以调用.intervalJoin()来合并两条流，传入的参数同样是一个KeyedStream，两者的key类型应该一致；得到的是一个IntervalJoin类型。后续的操作同样是完全固定的：先通过.between()方法指定间隔的上下界，再调用.process()方法，定义对匹配数据对的处理操作。调用.process()需要传入一个处理函数，这是处理函数家族的最后一员：“处理联结函数”ProcessJoinFunction。

        通用调用形式如下：

stream1
    .keyBy()
    .intervalJoin(stream2.keyBy())
    .between(Time.milliseconds(-2), Time.milliseconds(1))
    .process (new ProcessJoinFunction out) {
            out.collect(left + "," + right);
        }
    });

        可以看到，抽象类ProcessJoinFunction就像是ProcessFunction和JoinFunction的结合，内部同样有一个抽象方法.processElement()。与其他处理函数不同的是，它多了一个参数，这自然是因为有来自两条流的数据。参数中left指的就是第一条流中的数据，right则是第二条流中与它匹配的数据。每当检测到一组匹配，就会调用这里的.processElement()方法，经处理转换之后输出结果。