建设网站需要购买,ip访问 wordpress,软件开发文档的基本格式,php中网站不同模板后台逻辑代码怎么管理连接流
1 Union
最简单的合流操作#xff0c;就是直接将多条流合在一起#xff0c;叫作流的“联合”#xff08;union#xff09;。联合操作要求必须流中的数据类型必须相同#xff0c;合并之后的新流会包括所有流中的元素#xff0c;数据类型不变。这种合流方式非常简…连接流
1 Union
最简单的合流操作就是直接将多条流合在一起叫作流的“联合”union。联合操作要求必须流中的数据类型必须相同合并之后的新流会包括所有流中的元素数据类型不变。这种合流方式非常简单粗暴就像公路上多个车道汇在一起一样。 在代码中我们只要基于 DataStream 直接调用.union()方法传入其他 DataStream 作为参数就可以实现流的联合了得到的依然是一个 DataStream
stream1.union(stream2, stream3, ...)union()的参数可以是多个 DataStream所以联合操作可以实现多条流的合并。这里需要考虑一个问题。在事件时间语义下水位线是时间的进度标志不同的流中可能水位线的进展快慢完全不同如果它们合并在一起水位线又该以哪个为准呢还以要考虑水位线的本质含义是“之前的所有数据已经到齐了”所以对于合流之后的水位线也是要以最小的那个为准这样才可以保证所有流都不会再传来之前的数据。换句话说多流合并时处理的时效性是以最慢的那个流为准的。我们自然可以想到这与之前介绍的并行任务水位线传递的规则是完全一致的多条流的合并某种意义上也可以看作是多个并行任务向同一个下游任务汇合的过程。
package com.rosh.flink.combine;import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.rosh.flink.pojo.UserPojo;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.ProcessFunction;
import org.apache.flink.util.Collector;import java.time.Duration;public class UnionTest {public static void main(String[] args) throws Exception {StreamExecutionEnvironment env StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);// nc -lk 7777DataStreamSourceString stream1 env.socketTextStream(hadoop4, 7777);// nc -lk 7778DataStreamSourceString stream2 env.socketTextStream(hadoop4, 7778);//转换SingleOutputStreamOperatorUserPojo user1DS stream1.map(new MapFunctionString, UserPojo() {Overridepublic UserPojo map(String value) throws Exception {return getUserPojo(value);}}).assignTimestampsAndWatermarks(WatermarkStrategy.UserPojoforBoundedOutOfOrderness(Duration.ofSeconds(5)).withTimestampAssigner(new SerializableTimestampAssignerUserPojo() {Overridepublic long extractTimestamp(UserPojo element, long recordTimestamp) {return element.getTimestamp();}}));SingleOutputStreamOperatorUserPojo user2DS stream2.map(new MapFunctionString, UserPojo() {Overridepublic UserPojo map(String value) throws Exception {return getUserPojo(value);}}).assignTimestampsAndWatermarks(WatermarkStrategy.UserPojoforBoundedOutOfOrderness(Duration.ofSeconds(3)).withTimestampAssigner(new SerializableTimestampAssignerUserPojo() {Overridepublic long extractTimestamp(UserPojo element, long recordTimestamp) {return element.getTimestamp();}}));//联合DataStreamUserPojo unionDS user1DS.union(user2DS);SingleOutputStreamOperatorString resultDS unionDS.process(new ProcessFunctionUserPojo, String() {Overridepublic void processElement(UserPojo value, ProcessFunctionUserPojo, String.Context ctx, CollectorString out) throws Exception {out.collect(水位线: ctx.timerService().currentWatermark());}});resultDS.print();//执行env.execute(UnionTest);}/*** {userId:1,name:rosh,uri:/goods/1,timestamp:1000}* {userId:1,name:rosh,uri:/goods/1,timestamp:5000}*/private static UserPojo getUserPojo(String str) {JSONObject jsonObject JSON.parseObject(str);Integer userId jsonObject.getInteger(userId);String name jsonObject.getString(name);String uri jsonObject.getString(uri);Long timestamp jsonObject.getLong(timestamp);return new UserPojo(userId, name, uri, timestamp);}}2 连接Connect
流的联合虽然简单不过受限于数据类型不能改变灵活性大打折扣所以实际应用较少出现。除了联合unionFlink 还提供了另外一种方便的合流操作——连接connect。顾名思义这种操作就是直接把两条流像接线一样对接起来。
为了处理更加灵活连接操作允许流的数据类型不同。但我们知道一个 DataStream 中的数据只能有唯一的类型所以连接得到的并不是 DataStream而是一个“连接流”ConnectedStreams。连接流可以看成是两条流形式上的“统一”被放在了一个同一个流中事实上内部仍保持各自的数据形式不变彼此之间是相互独立的。要想得到新的 DataStream还需要进一步定义一个“同处理”co-process转换操作用来说明对于不同来源、不同类型的数据怎样分别进行处理转换、得到统一的输出类型。所以整体上来两条流的连接就像是“一国两制”两条流可以保持各自的数据类型、处理方式也可以不同不过最终还是会统一到同一个 DataStream 中。 在代码实现上需要分为两步首先基于一条 DataStream 调用.connect()方法传入另外一条 DataStream 作为参数将两条流连接起来得到一个 ConnectedStreams然后再调用同处理方法得到 DataStream。这里可以的调用的同处理方法有.map()/.flatMap()以及.process()方法。
两条流的连接connect与联合union操作相比最大的优势就是可以处理不同类型的流的合并使用更灵活、应用更广泛。当然它也有限制就是合并流的数量只能是 2而 union 可以同时进行多条流的合并。这也非常容易理解union 限制了类型不变所以直接合并没有问题而 connect 是“一国两制”后续处理的接口只定义了两个转换方法如果扩展需要重新定义接口所以不能“一国多制”。
package com.rosh.flink.test;import org.apache.flink.streaming.api.datastream.ConnectedStreams;
import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoMapFunction;public class ConnectTest {public static void main(String[] args) throws Exception {StreamExecutionEnvironment env StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);//创建流DataStreamSourceInteger integerDS env.fromElements(1, 2, 3, 4, 5);DataStreamSourceLong longDS env.fromElements(1L, 2L, 3L, 4L, 5L);//connectConnectedStreamsInteger, Long connectDS integerDS.connect(longDS);//mapSingleOutputStreamOperatorString rsDS connectDS.map(new CoMapFunctionInteger, Long, String() {Overridepublic String map1(Integer value) throws Exception {return Integer value;}Overridepublic String map2(Long value) throws Exception {return Long: value;}});//打印rsDS.print();env.execute(ConnectTest);}
}****CoProcessFunction****对于连接流 ConnectedStreams 的处理操作需要分别定义对两条流的处理转换因此接口中就会有两个相同的方法需要实现用数字“1”“2”区分在两条流中的数据到来时分别调 用。我们把这种接口叫作“协同处理函数”co-process function。与 CoMapFunction 类似如果是调用.flatMap()就需要传入一个 CoFlatMapFunction需要实现 flatMap1()、flatMap2()两个 方法而调用.process()时传入的则是一个 CoProcessFunction。抽象类 CoProcessFunction 在源码中定义如下
public abstract class CoProcessFunctionIN1, IN2, OUT extends AbstractRichFunction {...public abstract void processElement1(IN1 value, Context ctx, CollectorOUT out) throws Exception;public abstract void processElement2(IN2 value, Context ctx, CollectorOUT out) throws Exception;public void onTimer(long timestamp, OnTimerContext ctx, CollectorOUT out) throws Exception {}public abstract class Context {...}...
}我们可以看到很明显 CoProcessFunction 也是“处理函数”家族中的一员用法非常相似。它需要实现的就是 processElement1()、processElement2()两个方法在每个数据到来时会根据来源的流调用其中的一个方法进行处理。CoProcessFunction 同样可以通过上下文 ctx 来访问 timestamp、水位线并通过 TimerService 注册定时器另外也提供了.onTimer()方法用于定义定时触发的处理操作。
下面是 CoProcessFunction 的一个具体示例我们可以实现一个实时对账的需求也就是app 的支付操作和第三方的支付操作的一个双流 Join。App 的支付事件和第三方的支付事件将会互相等待 5 秒钟如果等不来对应的支付事件那么就输出报警信息。程序如下
package com.rosh.flink.combine;import com.alibaba.fastjson.JSON;
import com.rosh.flink.pojo.OrderPojo;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.state.ValueState;
import org.apache.flink.api.common.state.ValueStateDescriptor;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.CoProcessFunction;
import org.apache.flink.util.Collector;public class CheckBillTest {public static void main(String[] args) throws Exception {StreamExecutionEnvironment env StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);//数据流SingleOutputStreamOperatorOrderPojo appDS env.fromElements(new OrderPojo(1L, order1, 1000L),new OrderPojo(2L, order2, 2000L)).assignTimestampsAndWatermarks(WatermarkStrategy.OrderPojoforMonotonousTimestamps().withTimestampAssigner(new SerializableTimestampAssignerOrderPojo() {Overridepublic long extractTimestamp(OrderPojo orderPojo, long l) {return orderPojo.getTimestamp();}}));SingleOutputStreamOperatorOrderPojo threeDS env.fromElements(new OrderPojo(1L, order1, 3000L),new OrderPojo(2L, order2, 4000L),new OrderPojo(3L, order3, 5000L)).assignTimestampsAndWatermarks(WatermarkStrategy.OrderPojoforMonotonousTimestamps().withTimestampAssigner(new SerializableTimestampAssignerOrderPojo() {Overridepublic long extractTimestamp(OrderPojo orderPojo, long l) {return orderPojo.getTimestamp();}}));//connectSingleOutputStreamOperatorString resultDS appDS.connect(threeDS).keyBy(OrderPojo::getId, OrderPojo::getId).process(new OrderProcessFunction());resultDS.print();env.execute(CheckBillTest);}public static class OrderProcessFunction extends CoProcessFunctionOrderPojo, OrderPojo, String {private ValueStateOrderPojo appState;private ValueStateOrderPojo threeState;Overridepublic void open(Configuration parameters) throws Exception {appState getRuntimeContext().getState(new ValueStateDescriptorOrderPojo(app-state, OrderPojo.class));threeState getRuntimeContext().getState(new ValueStateDescriptorOrderPojo(three-state, OrderPojo.class));}/*** app逻辑*/Overridepublic void processElement1(OrderPojo value, CoProcessFunctionOrderPojo, OrderPojo, String.Context ctx, CollectorString out) throws Exception {if (threeState.value() ! null) {out.collect(JSON.toJSONString(value) 【app 对账成功】);threeState.clear();} else {//更新状态appState.update(value);//注册5秒后定时器ctx.timerService().registerEventTimeTimer(value.getTimestamp() 5000L);}}/*** 三方逻辑*/Overridepublic void processElement2(OrderPojo value, CoProcessFunctionOrderPojo, OrderPojo, String.Context ctx, CollectorString out) throws Exception {if (appState.value() ! null) {out.collect(JSON.toJSONString(value) 【three 对账成功】);appState.clear();} else {threeState.update(value);//注册5秒后定时器ctx.timerService().registerEventTimeTimer(value.getTimestamp() 5000L);}}Overridepublic void onTimer(long timestamp, CoProcessFunctionOrderPojo, OrderPojo, String.OnTimerContext ctx, CollectorString out) throws Exception {if (appState.value() ! null) {out.collect(JSON.toJSONString(appState.value()) 【app 对账失败】);}if (threeState.value() ! null) {out.collect(JSON.toJSONString(threeState.value()) 【三方 对账失败】);}appState.clear();threeState.clear();}}}3 窗口联结Window Join
基于时间的操作最基本的当然就是时间窗口了。我们之前已经介绍过 Window API 的用法主要是针对单一数据流在某些时间段内的处理计算。那如果我们希望将两条流的数据进行 合并、且同样针对某段时间进行处理和统计又该怎么做呢Flink 为这种场景专门提供了一个窗口联结window join算子可以定义时间窗口并将两条流中共享一个公共键key的数据放在窗口中进行配对处理。
窗口联结的调用
窗口联结在代码中的实现首先需要调用 DataStream 的.join()方法来合并两条流得到一个 JoinedStreams接着通过.where()和.equalTo()方法指定两条流中联结的 key然后通过.window()开窗口并调用.apply()传入联结窗口函数进行处理计算。通用调用形式如下
stream1.join(stream2) .where(KeySelector) .equalTo(KeySelector) .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 JoinFunctionIN1, IN2, OUT extends Function, Serializable {OUT join(IN1 first, IN2 second) throws Exception;}这里需要注意JoinFunciton 并不是真正的“窗口函数”它只是定义了窗口函数在调用时对匹配数据的具体处理逻辑。当然既然是窗口计算在.window()和.apply()之间也可以调用可选 API 去做一些自定义比如用.trigger()定义触发器用.allowedLateness()定义允许延迟时间等等。
JoinFunction 中的两个参数分别代表了两条流中的匹配的数据。这里就会有一个问题什么时候就会匹配好数据调用.join()方法呢接下来我们就来介绍一下窗口 join 的具体处理流程。
两条流的数据到来之后首先会按照 key 分组、进入对应的窗口中存储当到达窗口结束时间时算子会先统计出窗口内两条流的数据的所有组合也就是对两条流中的数据做一个笛卡尔积相当于表的交叉连接cross join然后进行遍历把每一对匹配的数据作为参数(firstsecond)传入 JoinFunction 的.join()方法进行计算处理得到的结果直接输出。所以窗口中每有一对数据成功联结匹配JoinFunction 的.join()方法就会被调用一次并输出一个结果。 除了 JoinFunction在.apply()方法中还可以传入 FlatJoinFunction用法非常类似只是内部需要实现的.join()方法没有返回值。结果的输出是通过收集器Collector来实现的所以对于一对匹配数据可以输出任意条结果。其实仔细观察可以发现窗口 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()方法也就没有任何输出了。
demo:
在电商网站中往往需要统计用户不同行为之间的转化这就需要对不同的行为数据流按照用户 ID 进行分组后再合并以分析它们之间的关联。如果这些是以固定时间周期比如 1 小时来统计的那我们就可以使用窗口 join 来实现这样的需求。
package com.rosh.flink.combine;import com.alibaba.fastjson.JSON;
import org.apache.flink.api.common.eventtime.SerializableTimestampAssigner;
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.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 WindowJoinTest {public static void main(String[] args) throws Exception {StreamExecutionEnvironment env StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);SingleOutputStreamOperatorTuple2String, Long stream1 env.fromElements(Tuple2.of(kobe, 1000L),Tuple2.of(james, 1000L),Tuple2.of(kobe, 2000L),Tuple2.of(james, 2000L)).assignTimestampsAndWatermarks(WatermarkStrategy.Tuple2String, LongforMonotonousTimestamps().withTimestampAssigner(new SerializableTimestampAssignerTuple2String, Long() {Overridepublic long extractTimestamp(Tuple2String, Long element, long recordTimestamp) {return element.f1;}}));SingleOutputStreamOperatorTuple2String, Long stream2 env.fromElements(Tuple2.of(kobe, 3000L),Tuple2.of(james, 3000L),Tuple2.of(kobe, 4000L),Tuple2.of(james, 4000L)).assignTimestampsAndWatermarks(WatermarkStrategy.Tuple2String, LongforMonotonousTimestamps().withTimestampAssigner(new SerializableTimestampAssignerTuple2String, Long() {Overridepublic long extractTimestamp(Tuple2String, Long element, long recordTimestamp) {return element.f1;}}));DataStreamString resultDS stream1.join(stream2).where(t - t.f0).equalTo(t - t.f0).window(TumblingEventTimeWindows.of(Time.seconds(5))).apply(new JoinFunctionTuple2String, Long, Tuple2String, Long, String() {Overridepublic String join(Tuple2String, Long first, Tuple2String, Long second) throws Exception {return JSON.toJSONString(first) JSON.toJSONString(second);}});resultDS.print();env.execute(WindowJoinTest);}}4 间隔联结Interval Join
在有些场景下我们要处理的时间间隔可能并不是固定的。比如在交易系统中需要实时地对每一笔交易进行核验保证两个账户转入转出数额相等也就是所谓的“实时对账”。 两次转账的数据可能写入了不同的日志流它们的时间戳应该相差不大所以我们可以考虑只统计一段时间内是否有出账入账的数据匹配。这时显然不应该用滚动窗口或滑动窗口来处理— —因为匹配的两个数据有可能刚好“卡在”窗口边缘两侧于是窗口内就都没有匹配了会话窗口虽然时间不固定但也明显不适合这个场景。 基于时间的窗口联结已经无能为力了。
为了应对这样的需求Flink 提供了一种叫作“间隔联结”interval join的合流操作。顾名思义间隔联结的思路就是针对一条流的每个数据开辟出其时间戳前后的一段时间间隔 看这期间是否有来自另一条流的数据匹配。
间隔联结具体的定义方式是我们给定两个时间点分别叫作间隔的“上界”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。与窗口联结不同的是intervaljoin 做匹配的时间段是基于流中数据的所以并不确定而且流 B 中的数据可以不只在一个区 间内被匹配。
间隔联结在代码中是基于 KeyedStream 的联结join操作。DataStream 在 keyBy 得到KeyedStream 之后可以调用.intervalJoin()来合并两条流传入的参数同样是一个 KeyedStream 两者的 key 类型应该一致得到的是一个 IntervalJoin 类型。后续的操作同样是完全固定的先通过.between()方法指定间隔的上下界再调用.process()方法定义对匹配数据对的处理操 作。调用.process()需要传入一个处理函数这是处理函数家族的最后一员“处理联结函数”通用调用形式如下
stream1 .keyBy(KeySelector).intervalJoin(stream2.keyBy(KeySelector)).between(Time.milliseconds(-2), Time.milliseconds(1)).process (new ProcessJoinFunctionInteger, Integer, String(){Overridepublic void processElement(Integer left, Integer right, Context ctx, CollectorString out) {out.collect(left , right);}});demo:
在电商网站中某些用户行为往往会有短时间内的强关联。我们这里举一个例子我们有两条流一条是下订单的流一条是浏览数据的流。我们可以针对同一个用户来做这样一个 联结。也就是使用一个用户的下订单的事件和这个用户的最近十分钟的浏览数据进行一个联结查询。
package com.rosh.flink.combine;import com.rosh.flink.pojo.UserPojo;
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.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;public class IntervalJoinTest {public static void main(String[] args) throws Exception {StreamExecutionEnvironment env StreamExecutionEnvironment.getExecutionEnvironment();env.setParallelism(1);//初始化流SingleOutputStreamOperatorTuple3String, String, Long orderDS env.fromElements(Tuple3.of(Mary, order-1, 5000L),Tuple3.of(Alice, order-2, 5000L),Tuple3.of(Bob, order-3, 20000L),Tuple3.of(Alice, order-4, 20000L),Tuple3.of(Cary, order-5, 51000L)).assignTimestampsAndWatermarks(WatermarkStrategy.Tuple3String, String, LongforMonotonousTimestamps().withTimestampAssigner(new SerializableTimestampAssignerTuple3String, String, Long() {Overridepublic long extractTimestamp(Tuple3String, String, Longelement, long recordTimestamp) {return element.f2;}}));SingleOutputStreamOperatorUserPojo clickDS env.fromElements(new UserPojo(1, Bob, ./cart, 2000L),new UserPojo(2, Alice, ./prod?id100, 3000L),new UserPojo(2, Alice, ./prod?id200, 3500L),new UserPojo(1, Bob, ./prod?id2, 2500L),new UserPojo(2, Alice, ./prod?id300, 36000L),new UserPojo(1, Bob, ./home, 30000L),new UserPojo(1, Bob, ./prod?id1, 23000L),new UserPojo(1, Bob, ./prod?id3, 33000L)).assignTimestampsAndWatermarks(WatermarkStrategy.UserPojoforMonotonousTimestamps().withTimestampAssigner(new SerializableTimestampAssignerUserPojo() {Overridepublic long extractTimestamp(UserPojo element, long recordTimestamp) {return element.getTimestamp();}}));//联合SingleOutputStreamOperatorString resultDS orderDS.keyBy(t - t.f0).intervalJoin(clickDS.keyBy(UserPojo::getName)).between(Time.seconds(-5), Time.seconds(10)).process(new ProcessJoinFunctionTuple3String, String, Long, UserPojo, String() {Overridepublic void processElement(Tuple3String, String, Long left, UserPojo right, ProcessJoinFunctionTuple3String, String, Long, UserPojo, String.Context ctx, CollectorString out) throws Exception {out.collect(left right);}});resultDS.print();env.execute(IntervalJoinTest);}}
