org.apache.flink.streaming.api.windowing.triggers;
Trigger
public abstract class Trigger<T, W extends Window> implements Serializable { /** * Called for every element that gets added to a pane. The result of this will determine * whether the pane is evaluated to emit results. * * @param element The element that arrived. * @param timestamp The timestamp of the element that arrived. * @param window The window to which the element is being added. * @param ctx A context object that can be used to register timer callbacks. */ public abstract TriggerResult onElement(T element, long timestamp, W window, TriggerContext ctx) throws Exception; /** * Called when a processing-time timer that was set using the trigger context fires. * * @param time The timestamp at which the timer fired. * @param window The window for which the timer fired. * @param ctx A context object that can be used to register timer callbacks. */ public abstract TriggerResult onProcessingTime(long time, W window, TriggerContext ctx) throws Exception; /** * Called when an event-time timer that was set using the trigger context fires. * * @param time The timestamp at which the timer fired. * @param window The window for which the timer fired. * @param ctx A context object that can be used to register timer callbacks. */ public abstract TriggerResult onEventTime(long time, W window, TriggerContext ctx) throws Exception; /** * Called when several windows have been merged into one window by the * {@link org.apache.flink.streaming.api.windowing.assigners.WindowAssigner}. * * @param window The new window that results from the merge. * @param ctx A context object that can be used to register timer callbacks and access state. */ public TriggerResult onMerge(W window, OnMergeContext ctx) throws Exception { throw new RuntimeException("This trigger does not support merging."); }
Trigger决定pane何时被evaluated，实现一系列接口，来判断各种情况下是否需要trigger
看看具体的trigger的实现，
ProcessingTimeTrigger
/** * A {@link Trigger} that fires once the current system time passes the end of the window * to which a pane belongs. */ public class ProcessingTimeTrigger implements Trigger<Object, TimeWindow> { private static final long serialVersionUID = 1L; private ProcessingTimeTrigger() {} @Override public TriggerResult onElement(Object element, long timestamp, TimeWindow window, TriggerContext ctx) { ctx.registerProcessingTimeTimer(window.maxTimestamp()); //对于processingTime，element的trigger时间是current+window，所以这里需要注册定时器去触发 return TriggerResult.CONTINUE; } @Override public TriggerResult onEventTime(long time, TimeWindow window, TriggerContext ctx) throws Exception { return TriggerResult.CONTINUE; } @Override public TriggerResult onProcessingTime(long time, TimeWindow window, TriggerContext ctx) {//触发后调用 return TriggerResult.FIRE_AND_PURGE; } @Override public String toString() { return "ProcessingTimeTrigger()"; } /** * Creates a new trigger that fires once system time passes the end of the window. */ public static ProcessingTimeTrigger create() { return new ProcessingTimeTrigger(); } }
可以看到只有在onProcessingTime的时候，是FIRE_AND_PURGE，其他时候都是continue
再看个CountTrigger，
public class CountTrigger<W extends Window> extends Trigger<Object, W> { private final long maxCount; private final ReducingStateDescriptor<Long> stateDesc = new ReducingStateDescriptor<>("count", new Sum(), LongSerializer.INSTANCE); private CountTrigger(long maxCount) { this.maxCount = maxCount; } @Override public TriggerResult onElement(Object element, long timestamp, W window, TriggerContext ctx) throws Exception { ReducingState<Long> count = ctx.getPartitionedState(stateDesc); //从backend取出conunt state count.add(1L); //加1 if (count.get() >= maxCount) { count.clear(); return TriggerResult.FIRE; } return TriggerResult.CONTINUE; } @Override public TriggerResult onEventTime(long time, W window, TriggerContext ctx) { return TriggerResult.CONTINUE; } @Override public TriggerResult onProcessingTime(long time, W window, TriggerContext ctx) throws Exception { return TriggerResult.CONTINUE; } @Override public TriggerResult onMerge(W window, OnMergeContext ctx) throws Exception { ctx.mergePartitionedState(stateDesc); //先调用merge，底层backend里面的window进行merge ReducingState<Long> count = ctx.getPartitionedState(stateDesc); //merge后再取出state，count，进行判断 if (count.get() >= maxCount) { return TriggerResult.FIRE; } return TriggerResult.CONTINUE; }
很简单，既然是算count，那么和time相关的自然都是continue
对于count，是在onElement中触发，每次来element都会走到这个逻辑
当累积的count > 设定的count时，就会返回Fire，注意，这里这是fire，并不会purge
并将计数清0
TriggerResult
TriggerResult是个枚举，
enum TriggerResult { CONTINUE(false, false), FIRE_AND_PURGE(true, true), FIRE(true, false), PURGE(false, true); private final boolean fire; private final boolean purge; }
两个选项，fire，purge，2×2，所以4种可能性
两个Result可以merge，
/** * Merges two {@code TriggerResults}. This specifies what should happen if we have * two results from a Trigger, for example as a result from * {@link Trigger#onElement(Object, long, Window, Trigger.TriggerContext)} and * {@link Trigger#onEventTime(long, Window, Trigger.TriggerContext)}. * * <p> * For example, if one result says {@code CONTINUE} while the other says {@code FIRE} * then {@code FIRE} is the combined result; */ public static TriggerResult merge(TriggerResult a, TriggerResult b) { if (a.purge || b.purge) { if (a.fire || b.fire) { return FIRE_AND_PURGE; } else { return PURGE; } } else if (a.fire || b.fire) { return FIRE; } else { return CONTINUE; } }
TriggerContext
为Trigger做些环境的工作，比如管理timer，和处理state
这些接口在，Trigger中的接口逻辑里面都会用到，所以在Trigger的所有接口上，都需要传入context
/** * A context object that is given to {@link Trigger} methods to allow them to register timer * callbacks and deal with state. */ public interface TriggerContext { long getCurrentProcessingTime(); long getCurrentWatermark(); /** * Register a system time callback. When the current system time passes the specified * time {@link Trigger#onProcessingTime(long, Window, TriggerContext)} is called with the time specified here. * * @param time The time at which to invoke {@link Trigger#onProcessingTime(long, Window, TriggerContext)} */ void registerProcessingTimeTimer(long time); void registerEventTimeTimer(long time); void deleteProcessingTimeTimer(long time); void deleteEventTimeTimer(long time); <S extends State> S getPartitionedState(StateDescriptor<S, ?> stateDescriptor); }
OnMergeContext 仅仅是多了一个接口，
public interface OnMergeContext extends TriggerContext { <S extends MergingState<?, ?>> void mergePartitionedState(StateDescriptor<S, ?> stateDescriptor); }
WindowOperator.Context作为TriggerContext的一个实现，
/** * {@code Context} is a utility for handling {@code Trigger} invocations. It can be reused * by setting the {@code key} and {@code window} fields. No internal state must be kept in * the {@code Context} */ public class Context implements Trigger.OnMergeContext { protected K key; //Context对应的window上下文 protected W window; protected Collection<W> mergedWindows; //onMerge中被赋值 @SuppressWarnings("unchecked") public <S extends State> S getPartitionedState(StateDescriptor<S, ?> stateDescriptor) { try { return WindowOperator.this.getPartitionedState(window, windowSerializer, stateDescriptor); //从backend里面读出改window的状态，即window buffer } catch (Exception e) { throw new RuntimeException("Could not retrieve state", e); } } @Override public <S extends MergingState<?, ?>> void mergePartitionedState(StateDescriptor<S, ?> stateDescriptor) { if (mergedWindows != null && mergedWindows.size() > 0) { try { WindowOperator.this.getStateBackend().mergePartitionedStates(window, //在backend层面把mergedWindows merge到window中 mergedWindows, windowSerializer, stateDescriptor); } catch (Exception e) { throw new RuntimeException("Error while merging state.", e); } } } @Override public void registerProcessingTimeTimer(long time) { Timer<K, W> timer = new Timer<>(time, key, window); // make sure we only put one timer per key into the queue if (processingTimeTimers.add(timer)) { processingTimeTimersQueue.add(timer); //If this is the first timer added for this timestamp register a TriggerTask if (processingTimeTimerTimestamps.add(time, 1) == 0) { //如果这个window是第一次注册的话 ScheduledFuture<?> scheduledFuture = WindowOperator.this.registerTimer(time, WindowOperator.this); //对于processTime必须注册定时器主动触发 processingTimeTimerFutures.put(time, scheduledFuture); } } } @Override public void registerEventTimeTimer(long time) { Timer<K, W> timer = new Timer<>(time, key, window); if (watermarkTimers.add(timer)) { watermarkTimersQueue.add(timer); } } //封装一遍trigger的接口，并把self作为context传入trigger的接口中 public TriggerResult onElement(StreamRecord<IN> element) throws Exception { return trigger.onElement(element.getValue(), element.getTimestamp(), window, this); } public TriggerResult onProcessingTime(long time) throws Exception { return trigger.onProcessingTime(time, window, this); } public TriggerResult onEventTime(long time) throws Exception { return trigger.onEventTime(time, window, this); } public TriggerResult onMerge(Collection<W> mergedWindows) throws Exception { this.mergedWindows = mergedWindows; return trigger.onMerge(window, this); } }
Evictor
/** * An {@code Evictor} can remove elements from a pane before it is being processed and after * window evaluation was triggered by a * {@link org.apache.flink.streaming.api.windowing.triggers.Trigger}. * * <p> * A pane is the bucket of elements that have the same key (assigned by the * {@link org.apache.flink.api.java.functions.KeySelector}) and same {@link Window}. An element can * be in multiple panes of it was assigned to multiple windows by the * {@link org.apache.flink.streaming.api.windowing.assigners.WindowAssigner}. These panes all * have their own instance of the {@code Evictor}. * * @param <T> The type of elements that this {@code Evictor} can evict. * @param <W> The type of {@link Window Windows} on which this {@code Evictor} can operate. */ public interface Evictor<T, W extends Window> extends Serializable { /** * Computes how many elements should be removed from the pane. The result specifies how * many elements should be removed from the beginning. * * @param elements The elements currently in the pane. * @param size The current number of elements in the pane. * @param window The {@link Window} */ int evict(Iterable<StreamRecord<T>> elements, int size, W window); }
Evictor的目的就是在Trigger fire后，但在element真正被处理前，从pane中remove掉一些数据
比如你虽然是每小时触发一次，但是只是想处理最后10分钟的数据，而不是所有数据。。。
CountEvictor
/** * An {@link Evictor} that keeps only a certain amount of elements. * * @param <W> The type of {@link Window Windows} on which this {@code Evictor} can operate. */ public class CountEvictor<W extends Window> implements Evictor<Object, W> { private static final long serialVersionUID = 1L; private final long maxCount; private CountEvictor(long count) { this.maxCount = count; } @Override public int evict(Iterable<StreamRecord<Object>> elements, int size, W window) { if (size > maxCount) { return (int) (size - maxCount); } else { return 0; } } /** * Creates a {@code CountEvictor} that keeps the given number of elements. * * @param maxCount The number of elements to keep in the pane. */ public static <W extends Window> CountEvictor<W> of(long maxCount) { return new CountEvictor<>(maxCount); } }
初始化count，表示想保留多少elements(from end)
evict返回需要删除的elements数目（from begining）
如果element数大于保留数，我们需要删除size – maxCount（from begining）
反之，就全保留
TimeEvictor
/** * An {@link Evictor} that keeps elements for a certain amount of time. Elements older * than {@code current_time - keep_time} are evicted. * * @param <W> The type of {@link Window Windows} on which this {@code Evictor} can operate. */ public class TimeEvictor<W extends Window> implements Evictor<Object, W> { private static final long serialVersionUID = 1L; private final long windowSize; public TimeEvictor(long windowSize) { this.windowSize = windowSize; } @Override public int evict(Iterable<StreamRecord<Object>> elements, int size, W window) { int toEvict = 0; long currentTime = Iterables.getLast(elements).getTimestamp(); long evictCutoff = currentTime - windowSize; for (StreamRecord<Object> record: elements) { if (record.getTimestamp() > evictCutoff) { break; } toEvict++; } return toEvict; } }
TimeEvictor设置需要保留的时间，
用最后一条的时间作为current，current-windowSize，作为界限，小于这个时间的要evict掉
这里的前提是，数据是时间有序的