聊聊flink DataStream的window coGroup操作

最新推荐文章于 2023-03-02 18:07:32 发布
最新推荐文章于 2023-03-02 18:07:32 发布
阅读量334 收藏 1
点赞数
文章标签： 大数据 java
原文链接：https://juejin.im/post/5c3973c56fb9a04a07309818
版权

序

本文主要研究一下flink DataStream的window coGroup操作

实例

dataStream.coGroup(otherStream)
    .where(0).equalTo(1)
    .window(TumblingEventTimeWindows.of(Time.seconds(3)))
    .apply (new CoGroupFunction () {...});
复制代码
  • 这里展示了DataStream的window coGroup操作的基本用法

DataStream.coGroup

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/DataStream.java

@Public
public class DataStream<T> {

	//......

	public <T2> CoGroupedStreams<T, T2> coGroup(DataStream<T2> otherStream) {
		return new CoGroupedStreams<>(this, otherStream);
	}

	//......
}
复制代码
  • DataStream的coGroup操作创建的是CoGroupedStreams

CoGroupedStreams

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

@Public
public class CoGroupedStreams<T1, T2> {

	private final DataStream<T1> input1;

	private final DataStream<T2> input2;

	public CoGroupedStreams(DataStream<T1> input1, DataStream<T2> input2) {
		this.input1 = requireNonNull(input1);
		this.input2 = requireNonNull(input2);
	}

	public <KEY> Where<KEY> where(KeySelector<T1, KEY> keySelector)  {
		Preconditions.checkNotNull(keySelector);
		final TypeInformation<KEY> keyType = TypeExtractor.getKeySelectorTypes(keySelector, input1.getType());
		return where(keySelector, keyType);
	}

	public <KEY> Where<KEY> where(KeySelector<T1, KEY> keySelector, TypeInformation<KEY> keyType)  {
		Preconditions.checkNotNull(keySelector);
		Preconditions.checkNotNull(keyType);
		return new Where<>(input1.clean(keySelector), keyType);
	}

	//.......
}
复制代码
  • CoGroupedStreams提供了where操作，用于指定input1的keySelector，它创建并返回Where对象

Where

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

	@Public
	public class Where<KEY> {

		private final KeySelector<T1, KEY> keySelector1;
		private final TypeInformation<KEY> keyType;

		Where(KeySelector<T1, KEY> keySelector1, TypeInformation<KEY> keyType) {
			this.keySelector1 = keySelector1;
			this.keyType = keyType;
		}

		public EqualTo equalTo(KeySelector<T2, KEY> keySelector)  {
			Preconditions.checkNotNull(keySelector);
			final TypeInformation<KEY> otherKey = TypeExtractor.getKeySelectorTypes(keySelector, input2.getType());
			return equalTo(keySelector, otherKey);
		}

		public EqualTo equalTo(KeySelector<T2, KEY> keySelector, TypeInformation<KEY> keyType)  {
			Preconditions.checkNotNull(keySelector);
			Preconditions.checkNotNull(keyType);

			if (!keyType.equals(this.keyType)) {
				throw new IllegalArgumentException("The keys for the two inputs are not equal: " +
						"first key = " + this.keyType + " , second key = " + keyType);
			}

			return new EqualTo(input2.clean(keySelector));
		}

		//......
	}	
复制代码
  • Where对象提供了equalTo操作，用于指定input2的keySelector，它创建并返回EqualTo对象

EqualTo

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

		@Public
		public class EqualTo {

			private final KeySelector<T2, KEY> keySelector2;

			EqualTo(KeySelector<T2, KEY> keySelector2) {
				this.keySelector2 = requireNonNull(keySelector2);
			}

			@PublicEvolving
			public <W extends Window> WithWindow<T1, T2, KEY, W> window(WindowAssigner<? super TaggedUnion<T1, T2>, W> assigner) {
				return new WithWindow<>(input1, input2, keySelector1, keySelector2, keyType, assigner, null, null, null);
			}
		}
复制代码
  • EqualTo对象提供了window操作，它创建并返回WithWindow对象

WithWindow

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

	@Public
	public static class WithWindow<T1, T2, KEY, W extends Window> {
		private final DataStream<T1> input1;
		private final DataStream<T2> input2;

		private final KeySelector<T1, KEY> keySelector1;
		private final KeySelector<T2, KEY> keySelector2;

		private final TypeInformation<KEY> keyType;

		private final WindowAssigner<? super TaggedUnion<T1, T2>, W> windowAssigner;

		private final Trigger<? super TaggedUnion<T1, T2>, ? super W> trigger;

		private final Evictor<? super TaggedUnion<T1, T2>, ? super W> evictor;

		private final Time allowedLateness;

		private WindowedStream<TaggedUnion<T1, T2>, KEY, W> windowedStream;

		protected WithWindow(DataStream<T1> input1,
				DataStream<T2> input2,
				KeySelector<T1, KEY> keySelector1,
				KeySelector<T2, KEY> keySelector2,
				TypeInformation<KEY> keyType,
				WindowAssigner<? super TaggedUnion<T1, T2>, W> windowAssigner,
				Trigger<? super TaggedUnion<T1, T2>, ? super W> trigger,
				Evictor<? super TaggedUnion<T1, T2>, ? super W> evictor,
				Time allowedLateness) {
			this.input1 = input1;
			this.input2 = input2;

			this.keySelector1 = keySelector1;
			this.keySelector2 = keySelector2;
			this.keyType = keyType;

			this.windowAssigner = windowAssigner;
			this.trigger = trigger;
			this.evictor = evictor;

			this.allowedLateness = allowedLateness;
		}

		@PublicEvolving
		public WithWindow<T1, T2, KEY, W> trigger(Trigger<? super TaggedUnion<T1, T2>, ? super W> newTrigger) {
			return new WithWindow<>(input1, input2, keySelector1, keySelector2, keyType,
					windowAssigner, newTrigger, evictor, allowedLateness);
		}

		@PublicEvolving
		public WithWindow<T1, T2, KEY, W> evictor(Evictor<? super TaggedUnion<T1, T2>, ? super W> newEvictor) {
			return new WithWindow<>(input1, input2, keySelector1, keySelector2, keyType,
					windowAssigner, trigger, newEvictor, allowedLateness);
		}

		@PublicEvolving
		public WithWindow<T1, T2, KEY, W> allowedLateness(Time newLateness) {
			return new WithWindow<>(input1, input2, keySelector1, keySelector2, keyType,
					windowAssigner, trigger, evictor, newLateness);
		}

		public <T> DataStream<T> apply(CoGroupFunction<T1, T2, T> function) {

			TypeInformation<T> resultType = TypeExtractor.getCoGroupReturnTypes(
				function,
				input1.getType(),
				input2.getType(),
				"CoGroup",
				false);

			return apply(function, resultType);
		}

		@PublicEvolving
		@Deprecated
		public <T> SingleOutputStreamOperator<T> with(CoGroupFunction<T1, T2, T> function) {
			return (SingleOutputStreamOperator<T>) apply(function);
		}

		public <T> DataStream<T> apply(CoGroupFunction<T1, T2, T> function, TypeInformation<T> resultType) {
			//clean the closure
			function = input1.getExecutionEnvironment().clean(function);

			UnionTypeInfo<T1, T2> unionType = new UnionTypeInfo<>(input1.getType(), input2.getType());
			UnionKeySelector<T1, T2, KEY> unionKeySelector = new UnionKeySelector<>(keySelector1, keySelector2);

			DataStream<TaggedUnion<T1, T2>> taggedInput1 = input1
					.map(new Input1Tagger<T1, T2>())
					.setParallelism(input1.getParallelism())
					.returns(unionType);
			DataStream<TaggedUnion<T1, T2>> taggedInput2 = input2
					.map(new Input2Tagger<T1, T2>())
					.setParallelism(input2.getParallelism())
					.returns(unionType);

			DataStream<TaggedUnion<T1, T2>> unionStream = taggedInput1.union(taggedInput2);

			// we explicitly create the keyed stream to manually pass the key type information in
			windowedStream =
					new KeyedStream<TaggedUnion<T1, T2>, KEY>(unionStream, unionKeySelector, keyType)
					.window(windowAssigner);

			if (trigger != null) {
				windowedStream.trigger(trigger);
			}
			if (evictor != null) {
				windowedStream.evictor(evictor);
			}
			if (allowedLateness != null) {
				windowedStream.allowedLateness(allowedLateness);
			}

			return windowedStream.apply(new CoGroupWindowFunction<T1, T2, T, KEY, W>(function), resultType);
		}

		@PublicEvolving
		@Deprecated
		public <T> SingleOutputStreamOperator<T> with(CoGroupFunction<T1, T2, T> function, TypeInformation<T> resultType) {
			return (SingleOutputStreamOperator<T>) apply(function, resultType);
		}

		@VisibleForTesting
		Time getAllowedLateness() {
			return allowedLateness;
		}

		@VisibleForTesting
		WindowedStream<TaggedUnion<T1, T2>, KEY, W> getWindowedStream() {
			return windowedStream;
		}
	}
复制代码
  • WithWindow可以设置windowAssigner、trigger、evictor、allowedLateness，它提供apply操作(with操作被标记为废弃)
  • apply操作接收CoGroupFunction，它内部是先根据两个keySelector创建UnionKeySelector，然后对两个input stream分别使用Input1Tagger及Input2Tagger进行map转换为TaggedUnion对象的stream，然后执行taggedInput1.union(taggedInput2)得到unionStream，之后使用UnionKeySelector将unionStream转换为KeyedStream，之后在对KeyedStream执行window操作，把原来的windowAssigner、trigger、evictor、allowedLateness都赋值过去，最后将用户定义的CoGroupFunction包装为CoGroupWindowFunction，然后调用windowedStream.apply方法
  • 可以看到apply操作内部转化的WindowedStream，其element类型为TaggedUnion；WindowedStream使用的KeyedStream，它的KeySelector为UnionKeySelector；而KeyedStream是基于TaggedUnion类型的DataStream，是taggedInput1.union(taggedInput2)操作而来；而taggedInput1及taggedInput2是对原始input stream进行map操作而来，使用的MapFunction分别是Input1Tagger及Input2Tagger

CoGroupFunction

flink-core-1.7.0-sources.jar!/org/apache/flink/api/common/functions/CoGroupFunction.java

@Public
@FunctionalInterface
public interface CoGroupFunction<IN1, IN2, O> extends Function, Serializable {

	void coGroup(Iterable<IN1> first, Iterable<IN2> second, Collector<O> out) throws Exception;
}
复制代码
  • CoGroupFunction继承了Function，它定义了coGroup方法，该方法接收两个Iterable类型的element集合

Input1Tagger及Input2Tagger

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

	private static class Input1Tagger<T1, T2> implements MapFunction<T1, TaggedUnion<T1, T2>> {
		private static final long serialVersionUID = 1L;

		@Override
		public TaggedUnion<T1, T2> map(T1 value) throws Exception {
			return TaggedUnion.one(value);
		}
	}

	private static class Input2Tagger<T1, T2> implements MapFunction<T2, TaggedUnion<T1, T2>> {
		private static final long serialVersionUID = 1L;

		@Override
		public TaggedUnion<T1, T2> map(T2 value) throws Exception {
			return TaggedUnion.two(value);
		}
	}
复制代码
  • Input1Tagger及Input2Tagger实现了MapFunction，该map方法返回的类型为TaggedUnion

TaggedUnion

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

	@Internal
	public static class TaggedUnion<T1, T2> {
		private final T1 one;
		private final T2 two;

		private TaggedUnion(T1 one, T2 two) {
			this.one = one;
			this.two = two;
		}

		public boolean isOne() {
			return one != null;
		}

		public boolean isTwo() {
			return two != null;
		}

		public T1 getOne() {
			return one;
		}

		public T2 getTwo() {
			return two;
		}

		public static <T1, T2> TaggedUnion<T1, T2> one(T1 one) {
			return new TaggedUnion<>(one, null);
		}

		public static <T1, T2> TaggedUnion<T1, T2> two(T2 two) {
			return new TaggedUnion<>(null, two);
		}
	}
复制代码
  • TaggedUnion里头有one、two两个属性，它提供了两个静态工厂方法one及two，可以看到TaggedUnion对象要么one为null，要么two为null，不可能两个同时有值

UnionKeySelector

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

	private static class UnionKeySelector<T1, T2, KEY> implements KeySelector<TaggedUnion<T1, T2>, KEY> {
		private static final long serialVersionUID = 1L;

		private final KeySelector<T1, KEY> keySelector1;
		private final KeySelector<T2, KEY> keySelector2;

		public UnionKeySelector(KeySelector<T1, KEY> keySelector1,
				KeySelector<T2, KEY> keySelector2) {
			this.keySelector1 = keySelector1;
			this.keySelector2 = keySelector2;
		}

		@Override
		public KEY getKey(TaggedUnion<T1, T2> value) throws Exception{
			if (value.isOne()) {
				return keySelector1.getKey(value.getOne());
			} else {
				return keySelector2.getKey(value.getTwo());
			}
		}
	}
复制代码
  • UnionKeySelector有两个KeySelector属性，它的getKey操作根据TaggedUnion来判断，如果是one，则使用keySelector1.getKey(value.getOne())，否则使用keySelector2.getKey(value.getTwo())

DataStream.union

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/DataStream.java

@Public
public class DataStream<T> {

	//......

	@SafeVarargs
	public final DataStream<T> union(DataStream<T>... streams) {
		List<StreamTransformation<T>> unionedTransforms = new ArrayList<>();
		unionedTransforms.add(this.transformation);

		for (DataStream<T> newStream : streams) {
			if (!getType().equals(newStream.getType())) {
				throw new IllegalArgumentException("Cannot union streams of different types: "
						+ getType() + " and " + newStream.getType());
			}

			unionedTransforms.add(newStream.getTransformation());
		}
		return new DataStream<>(this.environment, new UnionTransformation<>(unionedTransforms));
	}

	//......
}
复制代码
  • DataStream的union操作，使用UnionTransformation创建了一个新的DataStream；注意union操作需要两个stream使用相同类型的element，这就是为什么WithWindow的apply操作对两个input stream分别使用Input1Tagger及Input2Tagger进行map转换为TaggedUnion对象来统一两个stream的element类型的原因

CoGroupWindowFunction

flink-streaming-java_2.11-1.7.0-sources.jar!/org/apache/flink/streaming/api/datastream/CoGroupedStreams.java

	private static class CoGroupWindowFunction<T1, T2, T, KEY, W extends Window>
			extends WrappingFunction<CoGroupFunction<T1, T2, T>>
			implements WindowFunction<TaggedUnion<T1, T2>, T, KEY, W> {

		private static final long serialVersionUID = 1L;

		public CoGroupWindowFunction(CoGroupFunction<T1, T2, T> userFunction) {
			super(userFunction);
		}

		@Override
		public void apply(KEY key,
				W window,
				Iterable<TaggedUnion<T1, T2>> values,
				Collector<T> out) throws Exception {

			List<T1> oneValues = new ArrayList<>();
			List<T2> twoValues = new ArrayList<>();

			for (TaggedUnion<T1, T2> val: values) {
				if (val.isOne()) {
					oneValues.add(val.getOne());
				} else {
					twoValues.add(val.getTwo());
				}
			}
			wrappedFunction.coGroup(oneValues, twoValues, out);
		}
	}
复制代码
  • CoGroupWindowFunction继承了WrappingFunction(WrappingFunction继承了AbstractRichFunction，覆盖了父类的open、close、setRuntimeContext方法，用于管理wrappedFunction)，实现了WindowFunction接口，其apply方法对TaggedUnion类型的Iterable数据进行拆解，分别拆分到oneValues及twoValues中，然后调用用户定义的CoGroupFunction的coGroup方法

小结

  • DataStream提供了coGroup方法，用于执行window coGroup操作，它返回的是CoGroupedStreams；CoGroupedStreams主要是提供where操作来构建Where对象；Where对象主要提供equalTo操作用于构建EqualTo对象；EqualTo对象提供window操作用于构建WithWindow对象；WithWindow可以设置windowAssigner、trigger、evictor、allowedLateness，它提供apply操作
  • CoGroupedStreams的WithWindow对象的apply操作接收CoGroupFunction，它内部是先根据两个keySelector创建UnionKeySelector，然后对两个input stream分别使用Input1Tagger及Input2Tagger进行map转换为TaggedUnion对象的stream，然后执行taggedInput1.union(taggedInput2)得到unionStream，之后使用UnionKeySelector将unionStream转换为KeyedStream，之后在对KeyedStream执行window操作，把原来的windowAssigner、trigger、evictor、allowedLateness都赋值过去，最后将用户定义的CoGroupFunction包装为CoGroupWindowFunction，然后调用windowedStream.apply方法
  • CoGroupedStreams的WithWindow对象的apply操作借助了DataStream的union操作类合并两个stream，然后转换为KeyedStream，这里关键的两个类分别是TaggedUnion及UnionKeySelector；TaggedUnion里头有one、two两个属性，它提供了两个静态工厂方法one及two，可以看到TaggedUnion对象要么one为null，要么two为null，不可能两个同时有值；UnionKeySelector有两个KeySelector属性，它的getKey操作根据TaggedUnion来判断，如果是one，则使用keySelector1.getKey(value.getOne())，否则使用keySelector2.getKey(value.getTwo())(借助TaggedUnion类统一两个stream的element类型，然后好执行union操作)
  • CoGroupWindowFunction继承了WrappingFunction(WrappingFunction继承了AbstractRichFunction，覆盖了父类的open、close、setRuntimeContext方法，用于管理wrappedFunction)，实现了WindowFunction接口，其apply方法对TaggedUnion类型的Iterable数据进行拆解，分别拆分到oneValues及twoValues中，然后调用用户定义的CoGroupFunction的coGroup方法
  • CoGroupFunction继承了Function，它定义了coGroup方法，该方法接收两个Iterable类型的element集合；JoinedStreams的WithWindow对象的apply方法内部将JoinFunction或者FlatJoinFunction包装为CoGroupFunction(JoinFunction使用JoinCoGroupFunction包装，FlatJoinFunction使用FlatJoinCoGroupFunction包装)，然后去调用CoGroupedStreams的WithWindow的apply方法；而JoinCoGroupFunction及FlatJoinCoGroupFunction继承了WrappingFunction，同时实现CoGroupFunction接口定义的coGroup方法，默认是遍历第一个集合，对其每个元素遍历第二个集合，挨个执行JoinFunction或FlatJoinFunction的join方法(这里的操作对集合为空的情况不做任何操作，因而实现的就是inner join效果；用户使用coGroup操作可以自定义CoGroupFunction实现outer join)

doc

weixin_33997389
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Flink 多流转换 （六） 窗口同组联结（Window CoGroup）
weixin_45417821的博客
04-23 1028
文章目录 除窗口联结和间隔联结之外，Flink 还提供了一个“窗口同组联结”（window coGroup）操作。它的用法跟 window join 非常类似，也是将两条流合并之后开窗处理匹配的元素，调用时只需要将.join()换为.coGroup()就可以了。 stream1.coGroup(stream2) .where(<KeySelector>) .equalTo(<KeySelector>) .window(TumblingEventTimeWindows.of(Ti
flink Window Join、Interval Join、Window CoGroup (两流匹配 指定key联结，开窗口进行窗口操作)
热门推荐
不是一枚开发
06-05 6万+
  Flink 提供了一个窗口联结（window join）算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理  窗口联结在代码中的实现，首先需要调用 DataStream 的.join()方法来合并两条流，得到一个 JoinedStreams；接着通过.where()和.equalTo()方法指定两条流中联结的 key；然后通过.window()开窗口，并调用.apply()传入联结窗口函数进行处理计算   .where()的参数是键选择器（KeySelector），
Flink项目学习笔记之——Operators之CoGroup及Join操作
大数据研习社
03-21 744
说明：本文为《Flink大数据项目实战》学习笔记，想通过视频系统学习Flink这个最火爆的大数据计算框架的同学，推荐学习CSDN官网课程： Flink大数据项目实战：http://t.cn/ExrHPl9 Window CoGroup与Join 1.1回顾RDBMS各种join 假设有两个表A和B 1.CROSS JOIN（AB的笛卡尔积/交叉联接） 省略写法为join,由...
Flink - CoGroup
weixin_33862188的博客
07-21 727
使用方式， dataStream.coGroup(otherStream) .where(0).equalTo(1) .window(TumblingEventTimeWindows.of(Time.seconds(3))) .apply (new CoGroupFunction () {...});   可以看到coGroup只是产生CoGr...
Flink中coGroup的笔记
MingZiWoChiLe的博客
03-10 3746
flink datastream api 示例大全
最新发布
10-19
Flink DataStream API是Apache Flink流处理框架的核心部分，用于处理无界和有界数据流。这个API提供了丰富的操作符来构建复杂的数据处理管道。以下是对标题和描述中涉及的知识点的详细解释： 1. **异步IO...
通俗易懂之Flink DataStream API开发
02-07
本篇将深入探讨流处理的基本概念，以及Flink DataStream API的使用，包括算子操作、水印机制、状态管理、容错机制、异步IO、端对端一次性语义、Streaming file sink的运用，以及综合案例的开发。 1. **流处理基础**...
Flink DataStream编程.pdf
07-17
Flink 2019峰会 阿里大牛的技术分享， 在线教程有github：** ，第6个文档 详细讲解Flink的datastream api基础概念和运行原理。值得收藏
基于Flink DataStream API的流批一体处理.pdf
03-21
基于Flink DataStream API的流批一体处理
flink_DataStream:利用DataStream处理流数据
04-20
标题中的"flink_DataStream:利用DataStream处理流数据"指的是Apache Flink的DataStream API，它是一个用于处理无界和有界数据流的高级抽象。在本文中，我们将深入探讨Flink如何通过DataStream API来实现高效的流数据...
最新 Flink 1.13 多流转换（Union、Connect、Window Join、Interval Join、Window CoGroup）快速入门、详细教程
博文约礼
04-06 1538
一、分流；二、基本合流；1. 联合（Union）；2. 连接（Connect）；2.2 广播连接流（BroadcastConnectedStreams）；三、基于时间的合流--双流联结（Join）；1.窗口联结（Window Join）;2. 间隔联结（Interval Join）；3. 窗口同组联结（Window CoGroup）；四、Flink 常见的维表 Join 方案；1. 预加载；2. 热存储；3.广播维表；4. Temporal join
Flink的ConGroup算子介绍
影子
03-11 756
ConGroup是Join的底层算子，就是Join算子也是通过CoGroup算子来实现的。 CoCgoup是在同一个窗口当中对同一个key上的俩组集合进行操作，比Join算子更通用，可以实现Inner Join、LeftJoin、RightJoin的效果，CoGroup的作用基本和Join基本相同，但是有一点不一样的是，如果未能找到新来的数据与另一个流在window中存在的匹配数据，仍可将该条记录进行输出，该算子只能在window中使用，但是就Inner Join而言推荐使用Join，因为Join在策略上
Flink流计算编程--在双流中体会joinedStream与coGroupedStream
lmalds的专栏
06-23 1万+
Flink DataStream Join CoGroup scala
Flink DataStream中CoGroup实现原理与三种 join 实现
张普的专栏
11-05 3425
点击上方蓝字关注~ CoGroupCoGroup 表示联合分组，将两个不同的DataStream联合起来，在相同的窗口内按照相同的key分组处理，先通过一个d...
Flink 原理与实现：数据流上的类型和操作
lx1309244704的博客
12-10 409
转载来源：http://wuchong.me/blog/2016/05/20/flink-internals-streams-and-operations-on-streams/ Flink 为流处理和批处理分别提供了 DataStream API 和 DataSet API。正是这种高层的抽象和 flunent API 极大地便利了用户编写大数据应用。不过很多初学者在看到官方 Streamin...
Flink Operator之CoGroup、Join以及Connect
不清不慎的博客
05-13 1万+
在Flink中由很多Operator，大致分为两类，DataStream和DataSet，即流处理数据和批处理数据，这an文章主要讲解CoGroup、Join和Connect的使用，之所以将它们放在一起是因为它们比较相似，但也有所不同，在DataStream和DataSet中都存在这三个Operator，下面我们将分别讲述。 一、CoGroup 该操作是将两个数据流/集合按照key进行group，...
Flink流计算编程：双流中实现Inner Join、Left Join与Right Join
lmalds的专栏
08-01 2万+
Flink coGroup
聊聊flink Table的Group Windows
weixin_34319111的博客
01-26 425
序 本文主要研究一下flink Table的Group Windows 实例 Table table = input .window([Window w].as("w")) // define window with alias w .groupBy("w") // group the table by window w .select("b.sum"); // aggregat...
flink(1.14) 简单demo演示, 使用windowAll +sideOutputLateData + cogroup+connect, 解决interval join 数据可能丢失问题
hzymarine的博客
03-02 1368
flink(1.14) 简单demo演示, 使用windowAll +sideOutputLateData + cogroup+connect, 解决interval join 数据可能丢失问题
Flink DataStream
06-03
Flink DataStream 是 Apache Flink 中用于处理流式数据的 API，它提供了丰富的操作符和工具，支持流式数据的转换、聚合、分组、连接等操作。Flink DataStream API 提供了高度的可编程性和灵活性，允许用户通过编写 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值