io.vertx.rxjava3.kafka.client.consumer

Class KafkaConsumer<K,V>

java.lang.Object

io.vertx.rxjava3.kafka.client.consumer.KafkaConsumer<K,V>

All Implemented Interfaces:

ReadStream<KafkaConsumerRecord<K,V>>, StreamBase

public class KafkaConsumer<K,V>
extends Object
implements ReadStream<KafkaConsumerRecord<K,V>>

Vert.x Kafka consumer.

You receive Kafka records by providing a handler(io.vertx.core.Handler<io.vertx.rxjava3.kafka.client.consumer.KafkaConsumerRecord<K, V>>). As messages arrive the handler will be called with the records.

The pause() and resume() provides global control over reading the records from the consumer.

The pause() and resume() provides finer grained control over reading records for specific Topic/Partition, these are Kafka's specific operations.

NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field and Description
static io.vertx.lang.rx.TypeArg<KafkaConsumer>	__TYPE_ARG
io.vertx.lang.rx.TypeArg<K>	__typeArg_0
io.vertx.lang.rx.TypeArg<V>	__typeArg_1

Constructor Summary

Constructors

Constructor and Description
KafkaConsumer(KafkaConsumer delegate)
KafkaConsumer(Object delegate, io.vertx.lang.rx.TypeArg<K> typeArg_0, io.vertx.lang.rx.TypeArg<V> typeArg_1)

Method Summary

Modifier and Type	Method and Description
Completable	assign(Set<TopicPartition> topicPartitions) Manually assign a list of partition to this consumer.
Completable	assign(TopicPartition topicPartition) Manually assign a partition to this consumer.
Single<Set<TopicPartition>>	assignment() Get the set of partitions currently assigned to this consumer.
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.
Single<Long>	beginningOffsets(TopicPartition topicPartition) Get the first offset for the given partitions.
Completable	close() Close the consumer
Completable	commit() Commit current offsets for all the subscribed list of topics and partition.
Single<OffsetAndMetadata>	committed(TopicPartition topicPartition) Get the last committed offset for the given partition (whether the commit happened by this process or another).
static <K,V> KafkaConsumer<K,V>	create(Vertx vertx, KafkaClientOptions options) Create a new KafkaConsumer instance
static <K,V> KafkaConsumer<K,V>	create(Vertx vertx, KafkaClientOptions options, Class<K> keyType, Class<V> valueType) Create a new KafkaConsumer instance
static <K,V> KafkaConsumer<K,V>	create(Vertx vertx, Map<String,String> config) Create a new KafkaConsumer instance
static <K,V> KafkaConsumer<K,V>	create(Vertx vertx, Map<String,String> config, Class<K> keyType, Class<V> valueType) Create a new KafkaConsumer instance
long	demand() Returns the current demand.
KafkaConsumer<K,V>	endHandler(Handler<Void> endHandler) Set an end handler.
Single<Long>	endOffsets(TopicPartition topicPartition) Get the last offset for the given partition.
boolean	equals(Object o)
KafkaConsumer<K,V>	exceptionHandler(Handler<Throwable> handler) Set an exception handler on the read stream.
KafkaConsumer<K,V>	fetch(long amount) Fetch the specified amount of elements.
KafkaConsumer	getDelegate()
KafkaConsumer<K,V>	handler(Handler<KafkaConsumerRecord<K,V>> handler) Set a data handler.
int	hashCode()
static <K,V> KafkaConsumer<K,V>	newInstance(KafkaConsumer arg)
static <K,V> KafkaConsumer<K,V>	newInstance(KafkaConsumer arg, io.vertx.lang.rx.TypeArg<K> __typeArg_K, io.vertx.lang.rx.TypeArg<V> __typeArg_V)
Single<OffsetAndTimestamp>	offsetsForTimes(TopicPartition topicPartition, Long timestamp) Look up the offset for the given partition by timestamp.
KafkaConsumer<K,V>	partitionsAssignedHandler(Handler<Set<TopicPartition>> handler) Set the handler called when topic partitions are assigned to the consumer
Single<List<PartitionInfo>>	partitionsFor(String topic) Get metadata about the partitions for a given topic.
KafkaConsumer<K,V>	partitionsRevokedHandler(Handler<Set<TopicPartition>> handler) Set the handler called when topic partitions are revoked to the consumer
KafkaConsumer<K,V>	pause() Pause the ReadStream, it sets the buffer in fetch mode and clears the actual demand.
Completable	pause(Set<TopicPartition> topicPartitions) Suspend fetching from the requested partitions.
Completable	pause(TopicPartition topicPartition) Suspend fetching from the requested partition.
Single<Set<TopicPartition>>	paused() Get the set of partitions that were previously paused by a call to pause(Set).
Pipe<KafkaConsumerRecord<K,V>>	pipe() Pause this stream and return a to transfer the elements of this stream to a destination .
Completable	pipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst) Pipe this ReadStream to the WriteStream.
Single<KafkaConsumerRecords<K,V>>	poll(java.time.Duration timeout) Executes a poll for getting messages from Kafka.
KafkaConsumer<K,V>	pollTimeout(java.time.Duration timeout) Sets the poll timeout for the underlying native Kafka Consumer.
Single<Long>	position(TopicPartition partition) Get the offset of the next record that will be fetched (if a record with that offset exists).
KafkaConsumer<K,V>	resume() Resume reading, and sets the buffer in flowing mode.
Completable	resume(Set<TopicPartition> topicPartitions) Resume specified partitions which have been paused with pause.
Completable	resume(TopicPartition topicPartition) Resume specified partition which have been paused with pause.
Completable	rxAssign(Set<TopicPartition> topicPartitions) Manually assign a list of partition to this consumer.
Completable	rxAssign(TopicPartition topicPartition) Manually assign a partition to this consumer.
Single<Set<TopicPartition>>	rxAssignment() Get the set of partitions currently assigned to this consumer.
Single<Long>	rxBeginningOffsets(TopicPartition topicPartition) Get the first offset for the given partitions.
Completable	rxClose() Close the consumer
Completable	rxCommit() Commit current offsets for all the subscribed list of topics and partition.
Single<OffsetAndMetadata>	rxCommitted(TopicPartition topicPartition) Get the last committed offset for the given partition (whether the commit happened by this process or another).
Single<Long>	rxEndOffsets(TopicPartition topicPartition) Get the last offset for the given partition.
Single<OffsetAndTimestamp>	rxOffsetsForTimes(TopicPartition topicPartition, Long timestamp) Look up the offset for the given partition by timestamp.
Single<List<PartitionInfo>>	rxPartitionsFor(String topic) Get metadata about the partitions for a given topic.
Completable	rxPause(Set<TopicPartition> topicPartitions) Suspend fetching from the requested partitions.
Completable	rxPause(TopicPartition topicPartition) Suspend fetching from the requested partition.
Single<Set<TopicPartition>>	rxPaused() Get the set of partitions that were previously paused by a call to pause(Set).
Completable	rxPipeTo(WriteStream<KafkaConsumerRecord<K,V>> dst) Pipe this ReadStream to the WriteStream.
Single<KafkaConsumerRecords<K,V>>	rxPoll(java.time.Duration timeout) Executes a poll for getting messages from Kafka.
Single<Long>	rxPosition(TopicPartition partition) Get the offset of the next record that will be fetched (if a record with that offset exists).
Completable	rxResume(Set<TopicPartition> topicPartitions) Resume specified partitions which have been paused with pause.
Completable	rxResume(TopicPartition topicPartition) Resume specified partition which have been paused with pause.
Completable	rxSeek(TopicPartition topicPartition, long offset) Overrides the fetch offsets that the consumer will use on the next poll.
Completable	rxSeekToBeginning(Set<TopicPartition> topicPartitions) Seek to the first offset for each of the given partitions.
Completable	rxSeekToBeginning(TopicPartition topicPartition) Seek to the first offset for each of the given partition.
Completable	rxSeekToEnd(Set<TopicPartition> topicPartitions) Seek to the last offset for each of the given partitions.
Completable	rxSeekToEnd(TopicPartition topicPartition) Seek to the last offset for each of the given partition.
Completable	rxSubscribe(Set<String> topics) Subscribe to the given list of topics to get dynamically assigned partitions.
Completable	rxSubscribe(String topic) Subscribe to the given topic to get dynamically assigned partitions.
Single<Set<String>>	rxSubscription() Get the current subscription.
Completable	rxUnsubscribe() Unsubscribe from topics currently subscribed with subscribe.
Completable	seek(TopicPartition topicPartition, long offset) Overrides the fetch offsets that the consumer will use on the next poll.
Completable	seekToBeginning(Set<TopicPartition> topicPartitions) Seek to the first offset for each of the given partitions.
Completable	seekToBeginning(TopicPartition topicPartition) Seek to the first offset for each of the given partition.
Completable	seekToEnd(Set<TopicPartition> topicPartitions) Seek to the last offset for each of the given partitions.
Completable	seekToEnd(TopicPartition topicPartition) Seek to the last offset for each of the given partition.
Completable	subscribe(Set<String> topics) Subscribe to the given list of topics to get dynamically assigned partitions.
Completable	subscribe(String topic) Subscribe to the given topic to get dynamically assigned partitions.
Single<Set<String>>	subscription() Get the current subscription.
Flowable<KafkaConsumerRecord<K,V>>	toFlowable()
Observable<KafkaConsumerRecord<K,V>>	toObservable()
String	toString()
Completable	unsubscribe() Unsubscribe from topics currently subscribed with subscribe.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.vertx.rxjava3.core.streams.ReadStream

newInstance, newInstance

Methods inherited from interface io.vertx.rxjava3.core.streams.StreamBase

newInstance

Field Detail

__TYPE_ARG

public static final io.vertx.lang.rx.TypeArg<KafkaConsumer> __TYPE_ARG

__typeArg_0

public final io.vertx.lang.rx.TypeArg<K> __typeArg_0

__typeArg_1

public final io.vertx.lang.rx.TypeArg<V> __typeArg_1

Constructor Detail

KafkaConsumer

public KafkaConsumer(KafkaConsumer delegate)

KafkaConsumer

public KafkaConsumer(Object delegate,
                     io.vertx.lang.rx.TypeArg<K> typeArg_0,
                     io.vertx.lang.rx.TypeArg<V> typeArg_1)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

getDelegate

public KafkaConsumer getDelegate()

Specified by:

getDelegate in interface ReadStream<KafkaConsumerRecord<K,V>>

Specified by:

getDelegate in interface StreamBase

toObservable

public Observable<KafkaConsumerRecord<K,V>> toObservable()

Specified by:

toObservable in interface ReadStream<KafkaConsumerRecord<K,V>>

toFlowable

public Flowable<KafkaConsumerRecord<K,V>> toFlowable()

Specified by:

toFlowable in interface ReadStream<KafkaConsumerRecord<K,V>>

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<KafkaConsumerRecord<K,V>>

Returns:

a pipe

pipeTo

public 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<KafkaConsumerRecord<K,V>>

Parameters:

dst - the destination write stream

Returns:

rxPipeTo

public 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<KafkaConsumerRecord<K,V>>

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

exceptionHandler

public KafkaConsumer<K,V> exceptionHandler(Handler<Throwable> handler)

Description copied from interface: ReadStream

Set an exception handler on the read stream.

Specified by:

exceptionHandler in interface ReadStream<KafkaConsumerRecord<K,V>>

Specified by:

exceptionHandler in interface StreamBase

Parameters:

handler - the exception handler

Returns:

a reference to this, so the API can be used fluently

handler

public KafkaConsumer<K,V> handler(Handler<KafkaConsumerRecord<K,V>> handler)

Description copied from interface: ReadStream

Set a data handler. As data is read, the handler will be called with the data.

Specified by:

handler in interface ReadStream<KafkaConsumerRecord<K,V>>

Returns:

a reference to this, so the API can be used fluently

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<KafkaConsumerRecord<K,V>>

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<KafkaConsumerRecord<K,V>>

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<KafkaConsumerRecord<K,V>>

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<KafkaConsumerRecord<K,V>>

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 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 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 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 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 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 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 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 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 Single<Set<TopicPartition>> assignment()

Get the set of partitions currently assigned to this consumer.

Returns:

current KafkaConsumer instance

rxAssignment

public Single<Set<TopicPartition>> rxAssignment()

Get the set of partitions currently assigned to this consumer.

Returns:

current KafkaConsumer instance

unsubscribe

public Completable unsubscribe()

Unsubscribe from topics currently subscribed with subscribe.

Returns:

current KafkaConsumer instance

rxUnsubscribe

public Completable rxUnsubscribe()

Unsubscribe from topics currently subscribed with subscribe.

Returns:

current KafkaConsumer instance

subscription

public Single<Set<String>> subscription()

Get the current subscription.

Returns:

current KafkaConsumer instance

rxSubscription

public Single<Set<String>> rxSubscription()

Get the current subscription.

Returns:

current KafkaConsumer instance

pause

public 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 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 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 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 Single<Set<TopicPartition>> paused()

Get the set of partitions that were previously paused by a call to pause(Set).

Returns:

rxPaused

public Single<Set<TopicPartition>> rxPaused()

Get the set of partitions that were previously paused by a call to pause(Set).

Returns:

resume

public 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Completable commit()

Commit current offsets for all the subscribed list of topics and partition.

Returns:

rxCommit

public Completable rxCommit()

Commit current offsets for all the subscribed list of topics and partition.

Returns:

committed

public 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 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 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 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 Completable close()

Close the consumer

Returns:

rxClose

public Completable rxClose()

Close the consumer

Returns:

position

public 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 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 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 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 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 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 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 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(java.time.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 Single<KafkaConsumerRecords<K,V>> poll(java.time.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 Single<KafkaConsumerRecords<K,V>> rxPoll(java.time.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:

newInstance

public static <K,V> KafkaConsumer<K,V> newInstance(KafkaConsumer arg)

newInstance

public static <K,V> KafkaConsumer<K,V> newInstance(KafkaConsumer arg,
                                                   io.vertx.lang.rx.TypeArg<K> __typeArg_K,
                                                   io.vertx.lang.rx.TypeArg<V> __typeArg_V)