org.apache.flink.streaming.api.datastream

类 JoinedStreams.WithWindow<T1,T2,KEY,W extends Window>

java.lang.Object

org.apache.flink.streaming.api.datastream.JoinedStreams.WithWindow<T1,T2,KEY,W>

类型参数:

T1 - Type of the elements from the first input

T2 - Type of the elements from the second input

KEY - Type of the key. This must be the same for both inputs

W - Type of Window on which the join operation works.

封闭类:

JoinedStreams<T1,T2>

@Public
public static class JoinedStreams.WithWindow<T1,T2,KEY,W extends Window>
extends Object

A join operation that has KeySelectors defined for both inputs as well as a WindowAssigner.

构造器概要

构造器

限定符

构造器和说明

protected

WithWindow(DataStream<T1> input1, DataStream<T2> input2, org.apache.flink.api.java.functions.KeySelector<T1,KEY> keySelector1, org.apache.flink.api.java.functions.KeySelector<T2,KEY> keySelector2, org.apache.flink.api.common.typeinfo.TypeInformation<KEY> keyType, WindowAssigner<? super CoGroupedStreams.TaggedUnion<T1,T2>,W> windowAssigner, Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> trigger, Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> evictor, Time allowedLateness)

方法概要

限定符和类型	方法和说明
JoinedStreams.WithWindow<T1,T2,KEY,W>	allowedLateness(Time newLateness) Sets the time by which elements are allowed to be late.
<T> DataStream<T>	apply(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function) Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.
<T> DataStream<T>	apply(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function, org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType) Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.
<T> DataStream<T>	apply(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function) Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.
<T> DataStream<T>	apply(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function, org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType) Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.
JoinedStreams.WithWindow<T1,T2,KEY,W>	evictor(Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newEvictor) Sets the Evictor that should be used to evict elements from a window before emission.
JoinedStreams.WithWindow<T1,T2,KEY,W>	trigger(Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newTrigger) Sets the Trigger that should be used to trigger window emission.
<T> SingleOutputStreamOperator<T>	with(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function) 已过时。 This method will be removed once the apply(FlatJoinFunction) method is fixed in the next major version of Flink (2.0).
<T> SingleOutputStreamOperator<T>	with(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function, org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType) 已过时。 This method will be replaced by apply(FlatJoinFunction, TypeInformation) in Flink 2.0. So use the apply(FlatJoinFunction, TypeInformation) in the future.
<T> SingleOutputStreamOperator<T>	with(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function) 已过时。 This method will be removed once the apply(JoinFunction) method is fixed in the next major version of Flink (2.0).
<T> SingleOutputStreamOperator<T>	with(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function, org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType) 已过时。 This method will be removed once the apply(JoinFunction, TypeInformation) method is fixed in the next major version of Flink (2.0).

从类继承的方法 java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料

WithWindow

@PublicEvolving
protected WithWindow(DataStream<T1> input1,
                                     DataStream<T2> input2,
                                     org.apache.flink.api.java.functions.KeySelector<T1,KEY> keySelector1,
                                     org.apache.flink.api.java.functions.KeySelector<T2,KEY> keySelector2,
                                     org.apache.flink.api.common.typeinfo.TypeInformation<KEY> keyType,
                                     WindowAssigner<? super CoGroupedStreams.TaggedUnion<T1,T2>,W> windowAssigner,
                                     Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> trigger,
                                     Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> evictor,
                                     Time allowedLateness)

方法详细资料

trigger

@PublicEvolving
public JoinedStreams.WithWindow<T1,T2,KEY,W> trigger(Trigger<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newTrigger)

Sets the Trigger that should be used to trigger window emission.

evictor

@PublicEvolving
public JoinedStreams.WithWindow<T1,T2,KEY,W> evictor(Evictor<? super CoGroupedStreams.TaggedUnion<T1,T2>,? super W> newEvictor)

Sets the Evictor that should be used to evict elements from a window before emission.

Note: When using an evictor window performance will degrade significantly, since pre-aggregation of window results cannot be used.

allowedLateness

@PublicEvolving
public JoinedStreams.WithWindow<T1,T2,KEY,W> allowedLateness(Time newLateness)

Sets the time by which elements are allowed to be late.

另请参阅:

WindowedStream.allowedLateness(Time)

apply

public <T> DataStream<T> apply(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function)

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This method's return type does not support setting an operator-specific parallelism. Due to binary backwards compatibility, this cannot be altered. Use the with(JoinFunction) method to set an operator-specific parallelism.

with

@PublicEvolving
 @Deprecated
public <T> SingleOutputStreamOperator<T> with(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function)

已过时。 This method will be removed once the apply(JoinFunction) method is fixed in the next major version of Flink (2.0).

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This is a temporary workaround while the apply(JoinFunction) method has the wrong return type and hence does not allow one to set an operator-specific parallelism

apply

public <T> DataStream<T> apply(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function,
                               org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType)

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This method's return type does not support setting an operator-specific parallelism. Due to binary backwards compatibility, this cannot be altered. Use the with(JoinFunction, TypeInformation), method to set an operator-specific parallelism.

with

@PublicEvolving
 @Deprecated
public <T> SingleOutputStreamOperator<T> with(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function,
                                                                           org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType)

已过时。 This method will be replaced by apply(FlatJoinFunction, TypeInformation) in Flink 2.0. So use the apply(FlatJoinFunction, TypeInformation) in the future.

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This is a temporary workaround while the apply(JoinFunction, TypeInformation) method has the wrong return type and hence does not allow one to set an operator-specific parallelism

apply

public <T> DataStream<T> apply(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function)

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This method's return type does not support setting an operator-specific parallelism. Due to binary backwards compatibility, this cannot be altered. Use the with(FlatJoinFunction), method to set an operator-specific parallelism.

with

@PublicEvolving
 @Deprecated
public <T> SingleOutputStreamOperator<T> with(org.apache.flink.api.common.functions.FlatJoinFunction<T1,T2,T> function)

已过时。 This method will be removed once the apply(FlatJoinFunction) method is fixed in the next major version of Flink (2.0).

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This is a temporary workaround while the apply(FlatJoinFunction) method has the wrong return type and hence does not allow one to set an operator-specific parallelism.

apply

public <T> DataStream<T> apply(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function,
                               org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType)

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This method's return type does not support setting an operator-specific parallelism. Due to binary backwards compatibility, this cannot be altered. Use the with(JoinFunction, TypeInformation), method to set an operator-specific parallelism.

with

@PublicEvolving
 @Deprecated
public <T> SingleOutputStreamOperator<T> with(org.apache.flink.api.common.functions.JoinFunction<T1,T2,T> function,
                                                                           org.apache.flink.api.common.typeinfo.TypeInformation<T> resultType)

已过时。 This method will be removed once the apply(JoinFunction, TypeInformation) method is fixed in the next major version of Flink (2.0).

Completes the join operation with the user function that is executed for each combination of elements with the same key in a window.

Note: This is a temporary workaround while the apply(FlatJoinFunction, TypeInformation) method has the wrong return type and hence does not allow one to set an operator-specific parallelism