Package org.apache.flink.streaming.runtime.operators

Class TimestampsAndWatermarksOperator<T>

  • Type Parameters:
    T - The type of the input elements
    All Implemented Interfaces:
    Serializable, org.apache.flink.api.common.operators.ProcessingTimeService.ProcessingTimeCallback, org.apache.flink.api.common.state.CheckpointListener, Input<T>, KeyContext, KeyContextHandler, OneInputStreamOperator<T,​T>, StreamOperator<T>, StreamOperatorStateHandler.CheckpointedStreamOperator, YieldingOperator<T>
    public class TimestampsAndWatermarksOperator<T>
extends AbstractStreamOperator<T>
implements OneInputStreamOperator<T,​T>, org.apache.flink.api.common.operators.ProcessingTimeService.ProcessingTimeCallback
    A stream operator that may do one or both of the following: extract timestamps from events and generate watermarks.

    These two responsibilities run in the same operator rather than in two different ones, because the implementation of the timestamp assigner and the watermark generator is frequently in the same class (and should be run in the same instance), even though the separate interfaces support the use of different classes.

    See Also:
    Serialized Form

    • Constructor Detail

      • TimestampsAndWatermarksOperator

        public TimestampsAndWatermarksOperator​(StreamOperatorParameters<T> parameters,
                                       org.apache.flink.api.common.eventtime.WatermarkStrategy<T> watermarkStrategy,
                                       boolean emitProgressiveWatermarks)

    • Method Detail

      • open

        public void open()
          throws Exception
        Description copied from class: AbstractStreamOperator
        This method is called immediately before any elements are processed, it should contain the operator's initialization logic, e.g. state initialization.

        The default implementation does nothing.

        Specified by:
        open in interface StreamOperator<T>
        Overrides:
        open in class AbstractStreamOperator<T>
        Throws:
        Exception - An exception in this method causes the operator to fail.

      • close

        public void close()
           throws Exception
        Description copied from interface: StreamOperator
        This method is called at the very end of the operator's life, both in the case of a successful completion of the operation, and in the case of a failure and canceling.

        This method is expected to make a thorough effort to release all resources that the operator has acquired.

        NOTE:It can not emit any records! If you need to emit records at the end of processing, do so in the StreamOperator.finish() method.

        Specified by:
        close in interface StreamOperator<T>
        Overrides:
        close in class AbstractStreamOperator<T>
        Throws:
        Exception

      • onProcessingTime

        public void onProcessingTime​(long timestamp)
                      throws Exception
        Specified by:
        onProcessingTime in interface org.apache.flink.api.common.operators.ProcessingTimeService.ProcessingTimeCallback
        Throws:
        Exception

      • finish

        public void finish()
            throws Exception
        Description copied from interface: StreamOperator
        This method is called at the end of data processing.

        The method is expected to flush all remaining buffered data. Exceptions during this flushing of buffered data should be propagated, in order to cause the operation to be recognized as failed, because the last data items are not processed properly.

        After this method is called, no more records can be produced for the downstream operators.

        WARNING: It is not safe to use this method to commit any transactions or other side effects! You can use this method to flush any buffered data that can later on be committed e.g. in a CheckpointListener.notifyCheckpointComplete(long).

        NOTE:This method does not need to close any resources. You should release external resources in the StreamOperator.close() method.

        Specified by:
        finish in interface StreamOperator<T>
        Overrides:
        finish in class AbstractStreamOperator<T>
        Throws:
        Exception - An exception in this method causes the operator to fail.