Package io.vertx.rxjava3.kafka.client.consumer

Class KafkaConsumer<K,​V>

    • Method Detail

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • pipe

        public Pipe<KafkaConsumerRecord<K,​V>> pipe()
        Pause this stream and return a to transfer the elements of this stream to a destination .

        The stream will be resumed when the pipe will be wired to a WriteStream.

        Specified by:
        pipe in interface ReadStream<K>
        Returns:
        a pipe

      • pipeTo

        public io.reactivex.rxjava3.core.Completable pipeTo​(WriteStream<KafkaConsumerRecord<K,​V>> dst)
        Pipe this ReadStream to the WriteStream.

        Elements emitted by this stream will be written to the write stream until this stream ends or fails.

        Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.

        Specified by:
        pipeTo in interface ReadStream<K>
        Parameters:
        dst - the destination write stream
        Returns:

      • rxPipeTo

        public io.reactivex.rxjava3.core.Completable rxPipeTo​(WriteStream<KafkaConsumerRecord<K,​V>> dst)
        Pipe this ReadStream to the WriteStream.

        Elements emitted by this stream will be written to the write stream until this stream ends or fails.

        Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.

        Specified by:
        rxPipeTo in interface ReadStream<K>
        Parameters:
        dst - the destination write stream
        Returns:

      • create

        public static <K,​V> KafkaConsumer<K,​V> create​(Vertx vertx,
                                                          Map<String,​String> config)
        Create a new KafkaConsumer instance
        Parameters:
        vertx - Vert.x instance to use
        config - Kafka consumer configuration
        Returns:
        an instance of the KafkaConsumer

      • create

        public static <K,​V> KafkaConsumer<K,​V> create​(Vertx vertx,
                                                          Map<String,​String> config,
                                                          Class<K> keyType,
                                                          Class<V> valueType)
        Create a new KafkaConsumer instance
        Parameters:
        vertx - Vert.x instance to use
        config - Kafka consumer configuration
        keyType - class type for the key deserialization
        valueType - class type for the value deserialization
        Returns:
        an instance of the KafkaConsumer

      • create

        public static <K,​V> KafkaConsumer<K,​V> create​(Vertx vertx,
                                                          KafkaClientOptions options)
        Create a new KafkaConsumer instance
        Parameters:
        vertx - Vert.x instance to use
        options - Kafka consumer options
        Returns:
        an instance of the KafkaConsumer

      • create

        public static <K,​V> KafkaConsumer<K,​V> create​(Vertx vertx,
                                                          KafkaClientOptions options,
                                                          Class<K> keyType,
                                                          Class<V> valueType)
        Create a new KafkaConsumer instance
        Parameters:
        vertx - Vert.x instance to use
        options - Kafka consumer options
        keyType - class type for the key deserialization
        valueType - class type for the value deserialization
        Returns:
        an instance of the KafkaConsumer

      • pause

        public KafkaConsumer<K,​V> pause()
        Description copied from interface: ReadStream
        Pause the ReadStream, it sets the buffer in fetch mode and clears the actual demand.

        While it's paused, no data will be sent to the data handler.

        Specified by:
        pause in interface ReadStream<K>
        Returns:
        a reference to this, so the API can be used fluently

      • resume

        public KafkaConsumer<K,​V> resume()
        Description copied from interface: ReadStream
        Resume reading, and sets the buffer in flowing mode.

        If the ReadStream has been paused, reading will recommence on it.

        Specified by:
        resume in interface ReadStream<K>
        Returns:
        a reference to this, so the API can be used fluently

      • fetch

        public KafkaConsumer<K,​V> fetch​(long amount)
        Description copied from interface: ReadStream
        Fetch the specified amount of elements. If the ReadStream has been paused, reading will recommence with the specified amount of items, otherwise the specified amount will be added to the current stream demand.
        Specified by:
        fetch in interface ReadStream<K>
        Returns:
        a reference to this, so the API can be used fluently

      • endHandler

        public KafkaConsumer<K,​V> endHandler​(Handler<Void> endHandler)
        Description copied from interface: ReadStream
        Set an end handler. Once the stream has ended, and there is no more data to be read, this handler will be called.
        Specified by:
        endHandler in interface ReadStream<K>
        Returns:
        a reference to this, so the API can be used fluently

      • demand

        public long demand()
        Returns the current demand.
          If the stream is in flowing mode will return Long.
        • If the stream is in fetch mode, will return the current number of elements still to be delivered or 0 if paused.
        Returns:
        current demand

      • subscribe

        public io.reactivex.rxjava3.core.Completable subscribe​(String topic)
        Subscribe to the given topic to get dynamically assigned partitions.

        Due to internal buffering of messages, when changing the subscribed topic the old topic may remain in effect (as observed by the record handler}) until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new topic.

        Parameters:
        topic - topic to subscribe to
        Returns:
        current KafkaConsumer instance

      • rxSubscribe

        public io.reactivex.rxjava3.core.Completable rxSubscribe​(String topic)
        Subscribe to the given topic to get dynamically assigned partitions.

        Due to internal buffering of messages, when changing the subscribed topic the old topic may remain in effect (as observed by the record handler}) until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new topic.

        Parameters:
        topic - topic to subscribe to
        Returns:
        current KafkaConsumer instance

      • subscribe

        public io.reactivex.rxjava3.core.Completable subscribe​(Set<String> topics)
        Subscribe to the given list of topics to get dynamically assigned partitions.

        Due to internal buffering of messages, when changing the subscribed topics the old set of topics may remain in effect (as observed by the record handler}) until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new set of topics.

        Parameters:
        topics - topics to subscribe to
        Returns:
        current KafkaConsumer instance

      • rxSubscribe

        public io.reactivex.rxjava3.core.Completable rxSubscribe​(Set<String> topics)
        Subscribe to the given list of topics to get dynamically assigned partitions.

        Due to internal buffering of messages, when changing the subscribed topics the old set of topics may remain in effect (as observed by the record handler}) until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new set of topics.

        Parameters:
        topics - topics to subscribe to
        Returns:
        current KafkaConsumer instance

      • assign

        public io.reactivex.rxjava3.core.Completable assign​(TopicPartition topicPartition)
        Manually assign a partition to this consumer.

        Due to internal buffering of messages, when reassigning the old partition may remain in effect (as observed by the record handler)} until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new partition.

        Parameters:
        topicPartition - partition which want assigned
        Returns:
        current KafkaConsumer instance

      • rxAssign

        public io.reactivex.rxjava3.core.Completable rxAssign​(TopicPartition topicPartition)
        Manually assign a partition to this consumer.

        Due to internal buffering of messages, when reassigning the old partition may remain in effect (as observed by the record handler)} until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new partition.

        Parameters:
        topicPartition - partition which want assigned
        Returns:
        current KafkaConsumer instance

      • assign

        public io.reactivex.rxjava3.core.Completable assign​(Set<TopicPartition> topicPartitions)
        Manually assign a list of partition to this consumer.

        Due to internal buffering of messages, when reassigning the old set of partitions may remain in effect (as observed by the record handler)} until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new set of partitions.

        Parameters:
        topicPartitions - partitions which want assigned
        Returns:
        current KafkaConsumer instance

      • rxAssign

        public io.reactivex.rxjava3.core.Completable rxAssign​(Set<TopicPartition> topicPartitions)
        Manually assign a list of partition to this consumer.

        Due to internal buffering of messages, when reassigning the old set of partitions may remain in effect (as observed by the record handler)} until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new set of partitions.

        Parameters:
        topicPartitions - partitions which want assigned
        Returns:
        current KafkaConsumer instance

      • assignment

        public io.reactivex.rxjava3.core.Single<Set<TopicPartition>> assignment()
        Get the set of partitions currently assigned to this consumer.
        Returns:
        current KafkaConsumer instance

      • rxAssignment

        public io.reactivex.rxjava3.core.Single<Set<TopicPartition>> rxAssignment()
        Get the set of partitions currently assigned to this consumer.
        Returns:
        current KafkaConsumer instance

      • unsubscribe

        public io.reactivex.rxjava3.core.Completable unsubscribe()
        Unsubscribe from topics currently subscribed with subscribe.
        Returns:
        current KafkaConsumer instance

      • rxUnsubscribe

        public io.reactivex.rxjava3.core.Completable rxUnsubscribe()
        Unsubscribe from topics currently subscribed with subscribe.
        Returns:
        current KafkaConsumer instance

      • subscription

        public io.reactivex.rxjava3.core.Single<Set<String>> subscription()
        Get the current subscription.
        Returns:
        current KafkaConsumer instance

      • rxSubscription

        public io.reactivex.rxjava3.core.Single<Set<String>> rxSubscription()
        Get the current subscription.
        Returns:
        current KafkaConsumer instance

      • pause

        public io.reactivex.rxjava3.core.Completable pause​(TopicPartition topicPartition)
        Suspend fetching from the requested partition.

        Due to internal buffering of messages, the will continue to observe messages from the given topicPartition until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will not see messages from the given topicPartition.

        Parameters:
        topicPartition - topic partition from which suspend fetching
        Returns:
        current KafkaConsumer instance

      • rxPause

        public io.reactivex.rxjava3.core.Completable rxPause​(TopicPartition topicPartition)
        Suspend fetching from the requested partition.

        Due to internal buffering of messages, the will continue to observe messages from the given topicPartition until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will not see messages from the given topicPartition.

        Parameters:
        topicPartition - topic partition from which suspend fetching
        Returns:
        current KafkaConsumer instance

      • pause

        public io.reactivex.rxjava3.core.Completable pause​(Set<TopicPartition> topicPartitions)
        Suspend fetching from the requested partitions.

        Due to internal buffering of messages, the will continue to observe messages from the given topicPartitions until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will not see messages from the given topicPartitions.

        Parameters:
        topicPartitions - topic partition from which suspend fetching
        Returns:
        current KafkaConsumer instance

      • rxPause

        public io.reactivex.rxjava3.core.Completable rxPause​(Set<TopicPartition> topicPartitions)
        Suspend fetching from the requested partitions.

        Due to internal buffering of messages, the will continue to observe messages from the given topicPartitions until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will not see messages from the given topicPartitions.

        Parameters:
        topicPartitions - topic partition from which suspend fetching
        Returns:
        current KafkaConsumer instance

      • paused

        public io.reactivex.rxjava3.core.Single<Set<TopicPartition>> paused()
        Get the set of partitions that were previously paused by a call to pause(Set).
        Returns:

      • rxPaused

        public io.reactivex.rxjava3.core.Single<Set<TopicPartition>> rxPaused()
        Get the set of partitions that were previously paused by a call to pause(Set).
        Returns:

      • resume

        public io.reactivex.rxjava3.core.Completable resume​(TopicPartition topicPartition)
        Resume specified partition which have been paused with pause.
        Parameters:
        topicPartition - topic partition from which resume fetching
        Returns:
        current KafkaConsumer instance

      • rxResume

        public io.reactivex.rxjava3.core.Completable rxResume​(TopicPartition topicPartition)
        Resume specified partition which have been paused with pause.
        Parameters:
        topicPartition - topic partition from which resume fetching
        Returns:
        current KafkaConsumer instance

      • resume

        public io.reactivex.rxjava3.core.Completable resume​(Set<TopicPartition> topicPartitions)
        Resume specified partitions which have been paused with pause.
        Parameters:
        topicPartitions - topic partition from which resume fetching
        Returns:
        current KafkaConsumer instance

      • rxResume

        public io.reactivex.rxjava3.core.Completable rxResume​(Set<TopicPartition> topicPartitions)
        Resume specified partitions which have been paused with pause.
        Parameters:
        topicPartitions - topic partition from which resume fetching
        Returns:
        current KafkaConsumer instance

      • partitionsRevokedHandler

        public KafkaConsumer<K,​V> partitionsRevokedHandler​(Handler<Set<TopicPartition>> handler)
        Set the handler called when topic partitions are revoked to the consumer
        Parameters:
        handler - handler called on revoked topic partitions
        Returns:
        current KafkaConsumer instance

      • partitionsAssignedHandler

        public KafkaConsumer<K,​V> partitionsAssignedHandler​(Handler<Set<TopicPartition>> handler)
        Set the handler called when topic partitions are assigned to the consumer
        Parameters:
        handler - handler called on assigned topic partitions
        Returns:
        current KafkaConsumer instance

      • seek

        public io.reactivex.rxjava3.core.Completable seek​(TopicPartition topicPartition,
                                                  long offset)
        Overrides the fetch offsets that the consumer will use on the next poll.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartition - topic partition for which seek
        offset - offset to seek inside the topic partition
        Returns:
        current KafkaConsumer instance

      • rxSeek

        public io.reactivex.rxjava3.core.Completable rxSeek​(TopicPartition topicPartition,
                                                    long offset)
        Overrides the fetch offsets that the consumer will use on the next poll.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartition - topic partition for which seek
        offset - offset to seek inside the topic partition
        Returns:
        current KafkaConsumer instance

      • seekToBeginning

        public io.reactivex.rxjava3.core.Completable seekToBeginning​(TopicPartition topicPartition)
        Seek to the first offset for each of the given partition.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartition - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • rxSeekToBeginning

        public io.reactivex.rxjava3.core.Completable rxSeekToBeginning​(TopicPartition topicPartition)
        Seek to the first offset for each of the given partition.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartition - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • seekToBeginning

        public io.reactivex.rxjava3.core.Completable seekToBeginning​(Set<TopicPartition> topicPartitions)
        Seek to the first offset for each of the given partitions.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartitions - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • rxSeekToBeginning

        public io.reactivex.rxjava3.core.Completable rxSeekToBeginning​(Set<TopicPartition> topicPartitions)
        Seek to the first offset for each of the given partitions.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartitions - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • seekToEnd

        public io.reactivex.rxjava3.core.Completable seekToEnd​(TopicPartition topicPartition)
        Seek to the last offset for each of the given partition.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartition - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • rxSeekToEnd

        public io.reactivex.rxjava3.core.Completable rxSeekToEnd​(TopicPartition topicPartition)
        Seek to the last offset for each of the given partition.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartition - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • seekToEnd

        public io.reactivex.rxjava3.core.Completable seekToEnd​(Set<TopicPartition> topicPartitions)
        Seek to the last offset for each of the given partitions.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartitions - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • rxSeekToEnd

        public io.reactivex.rxjava3.core.Completable rxSeekToEnd​(Set<TopicPartition> topicPartitions)
        Seek to the last offset for each of the given partitions.

        Due to internal buffering of messages, the will continue to observe messages fetched with respect to the old offset until some time after the given completionHandler is called. In contrast, the once the given completionHandler is called the batchHandler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecords<K, V>>) will only see messages consistent with the new offset.

        Parameters:
        topicPartitions - topic partition for which seek
        Returns:
        current KafkaConsumer instance

      • commit

        public io.reactivex.rxjava3.core.Completable commit()
        Commit current offsets for all the subscribed list of topics and partition.
        Returns:

      • rxCommit

        public io.reactivex.rxjava3.core.Completable rxCommit()
        Commit current offsets for all the subscribed list of topics and partition.
        Returns:

      • committed

        public io.reactivex.rxjava3.core.Single<OffsetAndMetadata> committed​(TopicPartition topicPartition)
        Get the last committed offset for the given partition (whether the commit happened by this process or another).
        Parameters:
        topicPartition - topic partition for getting last committed offset
        Returns:

      • rxCommitted

        public io.reactivex.rxjava3.core.Single<OffsetAndMetadata> rxCommitted​(TopicPartition topicPartition)
        Get the last committed offset for the given partition (whether the commit happened by this process or another).
        Parameters:
        topicPartition - topic partition for getting last committed offset
        Returns:

      • partitionsFor

        public io.reactivex.rxjava3.core.Single<List<PartitionInfo>> partitionsFor​(String topic)
        Get metadata about the partitions for a given topic.
        Parameters:
        topic - topic partition for which getting partitions info
        Returns:
        current KafkaConsumer instance

      • rxPartitionsFor

        public io.reactivex.rxjava3.core.Single<List<PartitionInfo>> rxPartitionsFor​(String topic)
        Get metadata about the partitions for a given topic.
        Parameters:
        topic - topic partition for which getting partitions info
        Returns:
        current KafkaConsumer instance

      • batchHandler

        public KafkaConsumer<K,​V> batchHandler​(Handler<KafkaConsumerRecords<K,​V>> handler)
        Set the handler to be used when batches of messages are fetched from the Kafka server. Batch handlers need to take care not to block the event loop when dealing with large batches. It is better to process records individually using the #handler(Handler) record handler.
        Parameters:
        handler - handler called when batches of messages are fetched
        Returns:
        current KafkaConsumer instance

      • close

        public io.reactivex.rxjava3.core.Completable close()
        Close the consumer
        Returns:

      • rxClose

        public io.reactivex.rxjava3.core.Completable rxClose()
        Close the consumer
        Returns:

      • position

        public io.reactivex.rxjava3.core.Single<Long> position​(TopicPartition partition)
        Get the offset of the next record that will be fetched (if a record with that offset exists).
        Parameters:
        partition - The partition to get the position for
        Returns:

      • rxPosition

        public io.reactivex.rxjava3.core.Single<Long> rxPosition​(TopicPartition partition)
        Get the offset of the next record that will be fetched (if a record with that offset exists).
        Parameters:
        partition - The partition to get the position for
        Returns:

      • offsetsForTimes

        public io.reactivex.rxjava3.core.Single<OffsetAndTimestamp> offsetsForTimes​(TopicPartition topicPartition,
                                                                            Long timestamp)
        Look up the offset for the given partition by timestamp. Note: the result might be null in case for the given timestamp no offset can be found -- e.g., when the timestamp refers to the future
        Parameters:
        topicPartition - TopicPartition to query.
        timestamp - Timestamp to be used in the query.
        Returns:

      • rxOffsetsForTimes

        public io.reactivex.rxjava3.core.Single<OffsetAndTimestamp> rxOffsetsForTimes​(TopicPartition topicPartition,
                                                                              Long timestamp)
        Look up the offset for the given partition by timestamp. Note: the result might be null in case for the given timestamp no offset can be found -- e.g., when the timestamp refers to the future
        Parameters:
        topicPartition - TopicPartition to query.
        timestamp - Timestamp to be used in the query.
        Returns:

      • beginningOffsets

        public io.reactivex.rxjava3.core.Single<Long> beginningOffsets​(TopicPartition topicPartition)
        Get the first offset for the given partitions.
        Parameters:
        topicPartition - the partition to get the earliest offset.
        Returns:

      • rxBeginningOffsets

        public io.reactivex.rxjava3.core.Single<Long> rxBeginningOffsets​(TopicPartition topicPartition)
        Get the first offset for the given partitions.
        Parameters:
        topicPartition - the partition to get the earliest offset.
        Returns:

      • endOffsets

        public io.reactivex.rxjava3.core.Single<Long> endOffsets​(TopicPartition topicPartition)
        Get the last offset for the given partition. The last offset of a partition is the offset of the upcoming message, i.e. the offset of the last available message + 1.
        Parameters:
        topicPartition - the partition to get the end offset.
        Returns:

      • rxEndOffsets

        public io.reactivex.rxjava3.core.Single<Long> rxEndOffsets​(TopicPartition topicPartition)
        Get the last offset for the given partition. The last offset of a partition is the offset of the upcoming message, i.e. the offset of the last available message + 1.
        Parameters:
        topicPartition - the partition to get the end offset.
        Returns:

      • pollTimeout

        public KafkaConsumer<K,​V> pollTimeout​(Duration timeout)
        Sets the poll timeout for the underlying native Kafka Consumer. Defaults to 1000ms. Setting timeout to a lower value results in a more 'responsive' client, because it will block for a shorter period if no data is available in the assigned partition and therefore allows subsequent actions to be executed with a shorter delay. At the same time, the client will poll more frequently and thus will potentially create a higher load on the Kafka Broker.
        Parameters:
        timeout - The time, spent waiting in poll if data is not available in the buffer. If 0, returns immediately with any records that are available currently in the native Kafka consumer's buffer, else returns empty. Must not be negative.
        Returns:

      • poll

        public io.reactivex.rxjava3.core.Single<KafkaConsumerRecords<K,​V>> poll​(Duration timeout)
        Executes a poll for getting messages from Kafka.
        Parameters:
        timeout - The maximum time to block (must not be greater than Long milliseconds)
        Returns:

      • rxPoll

        public io.reactivex.rxjava3.core.Single<KafkaConsumerRecords<K,​V>> rxPoll​(Duration timeout)
        Executes a poll for getting messages from Kafka.
        Parameters:
        timeout - The maximum time to block (must not be greater than Long milliseconds)
        Returns: