Flink déclenchement Déclencheurs

Les déclencheurs (triggers)

Fenêtre de déclenchement est déterminé (le distributeur est formé par la fenêtre) quand il est prêt par le traitement de fonction de fenêtre. Chaque WindowAssigner est livré avec un déclencheur par défaut. Si le déclencheur par défaut ne correspond pas à vos besoins, vous pouvez utiliser la gâchette (...) pour spécifier un déclencheur personnalisé.

Interface de déclenchement déclencheur a cinq méthodes permettent le déclencheur de répondre aux différents événements:

• onElement () pour chaque élément dans la fenêtre va appeler la méthode.

• Lorsque déclenchement du temporisateur de temps d'événement onEventTime () est appelée.

• Lorsque déclenchement du temporisateur de temps de traitement onProcessingTime () sera appelée.

• onMerge () associé à un bascules état bascule et deux états fusionner leurs fenêtres respectives lorsqu'elles sont combinées, par exemple, une fenêtre de conversation.

• Procédé clear () est de supprimer la fenêtre d'exécution.

Deux choses à noter au sujet de la méthode ci-dessus:

1). Les trois premières méthodes pour déterminer comment faire fonctionner l'événement d'entrée en retournant un TriggerResult.

Le CONTINUEZ : ne rien faire.

INCENDIE : calcul de déclenchement.

PURE : éléments clairs de la fenêtre.

FIRE_AND_PURE : calcul de déclenchement et des éléments de fenêtre transparente.

2). Le procédé de l'une quelconque d'entre elles peut être utilisée pour le fonctionnement futur du temps de traitement d'enregistrement de l'événement de temporisateur ou

Feu et purge

Une fois le déclencheur pour déterminer la fenêtre est prêt pour le traitement, il déclenchera que les rendements ou FIRE FIRE_AND_PURGE. Ceci est l'opérateur de fenêtre de signal émis les résultats de la fenêtre en cours. Étant donné ProcessWindowFunction une fenêtre avec tous les éléments sont passés à travers le ProcessWindowFunction (peut être évincé en les faisant passer à plus tard). Windows a ReduceFunction, AggregateFunction ou FoldFunction la seule question les résultats de polymérisation urgents.

Lorsque le déclencheur est déclenché, il peut être un incendie ou FIRE_AND_PURGE. FIRE en même temps conserver le contenu de la fenêtre, FIRE_AND_PURGE supprimer son contenu. Par défaut, la réalisation de la gâchette de pré-déclenchement INCENDIE uniquement et n'efface pas l'état de la fenêtre.

注意⚠️：
清除将仅删除窗口的内容，并将保留有关该窗口的任何潜在元信息以及任何触发状态。

déclencheurs par défaut

déclenchement par défaut WindowAssigner adapté à de nombreux cas d'utilisation. Par exemple, tous les événements ont une fenêtre de EventTimeTrigger distributeur de temps que le déclenchement par défaut. Une fois WaterMark d'ici la fin de la fenêtre, le déclencheur est déclenché.

注意⚠️：
GlobalWindow的默认触发器是NeverTrigger，它从不触发。因此，在使用GlobalWindow时，您始终必须定义一个自定义触发器。
通过使用trigger（）指定触发器，您将覆盖WindowAssigner的默认触发器。例如，如果为TumblingEventTimeWindows指定CountTrigger，
则将不再基于时间进度而是仅通过计数来获取窗口触发。现在，如果要基于时间和计数做出反应，则必须编写自己的自定义触发器。

Intégré et déclencheurs personnalisés

Flink a un certain intégré dans déclencheur.

• EventTimeTrigger pour déclencher le calcul des événements temporels et le mécanisme de fenêtre de filigrane.

• déclencheur ProcessingTimeTrigger basé sur le temps de traitement.

• CountTrigger nombre d'éléments est supérieur à une fenêtre prédéfinie, puis régler les valeurs limites calcul déclencher.

• PurgingTrigger en tant que paramètre de l'autre trigger, qui a été convertie en une purge flip-flop.

Si vous avez besoin de mettre en œuvre un déclencheur personnalisé, vous devez réaliser la classe Trigger. S'il vous plaît noter que l' API évolue et peut encore changer dans les versions futures de Flink.

import org.apache.flink.streaming.api.windowing.triggers.Trigger;
import org.apache.flink.streaming.api.windowing.triggers.TriggerResult;
import org.apache.flink.streaming.api.windowing.windows.TimeWindow;

/**
 * <p/>
 * <li>title: DataStream 触发器</li>
 * <li>@author: li.pan</li>
 * <li>Date: 2019/12/29 5:00 下午</li>
 * <li>Version: V1.0</li>
 * <li>Description: 自定义元素个数触发器</li>
 */
public class CustomProcessingTimeTrigger extends Trigger<Object, TimeWindow> {
    private static final long serialVersionUID = 1L;

    private CustomProcessingTimeTrigger() {}

    private static int flag = 0;
    @Override
    public TriggerResult onElement(Object element, long timestamp, TimeWindow window, TriggerContext ctx) {
        ctx.registerProcessingTimeTimer(window.maxTimestamp());
        // CONTINUE是代表不做输出，也即是，此时我们想要实现比如100条输出一次，
        // 而不是窗口结束再输出就可以在这里实现。
        if(flag > 9){
            flag = 0;
            return TriggerResult.FIRE;
        }else{
            flag++;
        }
        System.out.println("onElement : "+element);
        return TriggerResult.CONTINUE;
    }

    @Override
    public TriggerResult onEventTime(long time, TimeWindow window, TriggerContext ctx) throws Exception {
        return TriggerResult.FIRE_AND_PURGE;
    }

    @Override
    public TriggerResult onProcessingTime(long time, TimeWindow window, TriggerContext ctx) {
        return TriggerResult.FIRE_AND_PURGE;
    }

    @Override
    public void clear(TimeWindow window, TriggerContext ctx) throws Exception {
        ctx.deleteProcessingTimeTimer(window.maxTimestamp());
    }

    @Override
    public boolean canMerge() {
        return true;
    }

    @Override
    public void onMerge(TimeWindow window, OnMergeContext ctx) {
        // only register a timer if the time is not yet past the end of the merged window
        // this is in line with the logic in onElement(). If the time is past the end of
        // the window onElement() will fire and setting a timer here would fire the window twice.
        long windowMaxTimestamp = window.maxTimestamp();
        if (windowMaxTimestamp > ctx.getCurrentProcessingTime()) {
            ctx.registerProcessingTimeTimer(windowMaxTimestamp);
        }
    }

    @Override
    public String toString() {
        return "ProcessingTimeTrigger()";
    }

    /**
     * 创建一个自定义触发器对象
     */
    public static CustomProcessingTimeTrigger create() {
        return new CustomProcessingTimeTrigger();
    }

}