Package io.vertx.kafka.client.producer

## Interface KafkaWriteStream<K,​V>

- All Superinterfaces:
    `StreamBase`, `WriteStream<org.apache.kafka.clients.producer.ProducerRecord<K,​V>>`

      public interface KafkaWriteStream<K,​V>
      extends WriteStream<org.apache.kafka.clients.producer.ProducerRecord<K,​V>>

  A `WriteStream` for writing to Kafka `ProducerRecord`.

  The `WriteStream.write(Object)` provides global control over writing a record.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static int` | `DEFAULT_MAX_SIZE` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `Future<Void>` | `abortTransaction()` | Aborts the ongoing transaction.
    `Future<Void>` | `beginTransaction()` | Starts a new kafka transaction.
    `Future<Void>` | `close()` | Close the stream
    `Future<Void>` | `close​(long timeout)` | Close the stream
    `Future<Void>` | `commitTransaction()` | Commits the ongoing transaction.
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, KafkaClientOptions options)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, KafkaClientOptions options, Class<K> keyType, Class<V> valueType)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, KafkaClientOptions options, org.apache.kafka.common.serialization.Serializer<K> keySerializer, org.apache.kafka.common.serialization.Serializer<V> valueSerializer)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, Map<String,​Object> config)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, Map<String,​Object> config, Class<K> keyType, Class<V> valueType)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, Map<String,​Object> config, org.apache.kafka.common.serialization.Serializer<K> keySerializer, org.apache.kafka.common.serialization.Serializer<V> valueSerializer)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, Properties config)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, Properties config, Class<K> keyType, Class<V> valueType)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, Properties config, org.apache.kafka.common.serialization.Serializer<K> keySerializer, org.apache.kafka.common.serialization.Serializer<V> valueSerializer)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, org.apache.kafka.clients.producer.Producer<K,​V> producer)` | Create a new KafkaWriteStream instance
    `static <K,​V> KafkaWriteStream<K,​V>` | `create​(Vertx vertx, org.apache.kafka.clients.producer.Producer<K,​V> producer, KafkaClientOptions options)` | Create a new KafkaWriteStream instance.
    `KafkaWriteStream<K,​V>` | `drainHandler​(Handler<Void> handler)` | Set a drain handler on the stream.
    `KafkaWriteStream<K,​V>` | `exceptionHandler​(Handler<Throwable> handler)` | Set an exception handler on the write stream.
    `Future<Void>` | `flush()` | Invoking this method makes all buffered records immediately available to write
    `Future<Void>` | `initTransactions()` | Initializes the underlying kafka transactional producer.
    `Future<List<org.apache.kafka.common.PartitionInfo>>` | `partitionsFor​(String topic)` | Get the partition metadata for the give topic.
    `Future<org.apache.kafka.clients.producer.RecordMetadata>` | `send​(org.apache.kafka.clients.producer.ProducerRecord<K,​V> record)` | Asynchronously write a record to a topic
    `KafkaWriteStream<K,​V>` | `setWriteQueueMaxSize​(int i)` | Set the maximum size of the write queue to `maxSize`.
    `org.apache.kafka.clients.producer.Producer<K,​V>` | `unwrap()` |

    - ### Methods inherited from interface io.vertx.core.streams.WriteStream

      `end, end, write, writeQueueFull`

- - ### Field Detail

    - #### DEFAULT_MAX_SIZE

          static final int DEFAULT_MAX_SIZE

      See Also:
        Constant Field Values

  - ### Method Detail

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                Properties config)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `config` - Kafka producer configuration
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                Properties config,
                                                                Class<K> keyType,
                                                                Class<V> valueType)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `config` - Kafka producer configuration
        `keyType` - class type for the key serialization
        `valueType` - class type for the value serialization
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                Properties config,
                                                                org.apache.kafka.common.serialization.Serializer<K> keySerializer,
                                                                org.apache.kafka.common.serialization.Serializer<V> valueSerializer)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `config` - Kafka producer configuration
        `keySerializer` - key serializer
        `valueSerializer` - value serializer
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                Map<String,​Object> config)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `config` - Kafka producer configuration
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                Map<String,​Object> config,
                                                                Class<K> keyType,
                                                                Class<V> valueType)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `config` - Kafka producer configuration
        `keyType` - class type for the key serialization
        `valueType` - class type for the value serialization
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                Map<String,​Object> config,
                                                                org.apache.kafka.common.serialization.Serializer<K> keySerializer,
                                                                org.apache.kafka.common.serialization.Serializer<V> valueSerializer)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `config` - Kafka producer configuration
        `keySerializer` - key serializer
        `valueSerializer` - value serializer
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                KafkaClientOptions options)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `options` - Kafka producer options
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                KafkaClientOptions options,
                                                                Class<K> keyType,
                                                                Class<V> valueType)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `options` - Kafka producer options
        `keyType` - class type for the key serialization
        `valueType` - class type for the value serialization
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                KafkaClientOptions options,
                                                                org.apache.kafka.common.serialization.Serializer<K> keySerializer,
                                                                org.apache.kafka.common.serialization.Serializer<V> valueSerializer)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `options` - Kafka producer options
        `keySerializer` - key serializer
        `valueSerializer` - value serializer
      Returns:
        an instance of the KafkaWriteStream

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                org.apache.kafka.clients.producer.Producer<K,​V> producer)

      Create a new KafkaWriteStream instance
      Parameters:
        `vertx` - Vert.x instance to use
        `producer` - native Kafka producer instance

    - #### create

          static <K,​V> KafkaWriteStream<K,​V> create​(Vertx vertx,
                                                                org.apache.kafka.clients.producer.Producer<K,​V> producer,
                                                                KafkaClientOptions options)

      Create a new KafkaWriteStream instance.
      Parameters:
        `vertx` - Vert.x instance to use
        `producer` - native Kafka producer instance
        `options` - options used only for tracing settings

    - #### exceptionHandler

          KafkaWriteStream<K,​V> exceptionHandler​(Handler<Throwable> handler)

      Description copied from interface: `WriteStream`
      Set an exception handler on the write stream.
      Specified by:
        `exceptionHandler` in interface `StreamBase`
      Specified by:
        `exceptionHandler` in interface `WriteStream<K>`
      Parameters:
        `handler` - the exception handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### setWriteQueueMaxSize

          KafkaWriteStream<K,​V> setWriteQueueMaxSize​(int i)

      Description copied from interface: `WriteStream`
      Set the maximum size of the write queue to `maxSize`. You will still be able to write to the stream even if there is more than `maxSize` items in the write queue. This is used as an indicator by classes such as `Pipe` to provide flow control.

      The value is defined by the implementation of the stream, e.g in bytes for a `NetSocket`, etc...
      Specified by:
        `setWriteQueueMaxSize` in interface `WriteStream<K>`
      Parameters:
        `i` - the max size of the write stream
      Returns:
        a reference to this, so the API can be used fluently

    - #### drainHandler

          KafkaWriteStream<K,​V> drainHandler​(Handler<Void> handler)

      Description copied from interface: `WriteStream`
      Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write queue is ready to accept buffers again. See `Pipe` for an example of this being used.

      The stream implementation defines when the drain handler, for example it could be when the queue size has been reduced to `maxSize / 2`.

      Specified by:
        `drainHandler` in interface `WriteStream<K>`
      Parameters:
        `handler` - the handler
      Returns:
        a reference to this, so the API can be used fluently

    - #### initTransactions

          Future<Void> initTransactions()

      Initializes the underlying kafka transactional producer. See `KafkaProducer.initTransactions()` ()}
      Returns:
        a future notified with the result

    - #### beginTransaction

          Future<Void> beginTransaction()

      Starts a new kafka transaction. See `KafkaProducer.beginTransaction()`
      Returns:
        a future notified with the result

    - #### commitTransaction

          Future<Void> commitTransaction()

      Commits the ongoing transaction. See `KafkaProducer.commitTransaction()`
      Returns:
        a future notified with the result

    - #### abortTransaction

          Future<Void> abortTransaction()

      Aborts the ongoing transaction. See `KafkaProducer.abortTransaction()`
      Returns:
        a future notified with the result

    - #### send

          Future<org.apache.kafka.clients.producer.RecordMetadata> send​(org.apache.kafka.clients.producer.ProducerRecord<K,​V> record)

      Asynchronously write a record to a topic
      Parameters:
        `record` - record to write
      Returns:
        a `Future` completed with the record metadata

    - #### partitionsFor

          Future<List<org.apache.kafka.common.PartitionInfo>> partitionsFor​(String topic)

      Get the partition metadata for the give topic.
      Parameters:
        `topic` - topic partition for which getting partitions info
      Returns:
        a future notified with the result

    - #### flush

          Future<Void> flush()

      Invoking this method makes all buffered records immediately available to write
      Returns:
        a future notified with the result

    - #### close

          Future<Void> close()

      Close the stream

    - #### close

          Future<Void> close​(long timeout)

      Close the stream
      Parameters:
        `timeout` - timeout to wait for closing
      Returns:
        a future notified with the result

    - #### unwrap

          org.apache.kafka.clients.producer.Producer<K,​V> unwrap()

      Returns:
        the underlying producer