io.vertx.reactivex.core.eventbus

## Class EventBus

- java.lang.Object
- - io.vertx.reactivex.core.eventbus.EventBus

- All Implemented Interfaces:
    Measured

      public class EventBus
      extends Object
      implements Measured

  A Vert.x event-bus is a light-weight distributed messaging system which allows different parts of your application, or different applications and services to communicate with each in a loosely coupled way.

  An event-bus supports publish-subscribe messaging, point-to-point messaging and request-response messaging.

  Message delivery is best-effort and messages can be lost if failure of all or part of the event bus occurs.

  Please refer to the documentation for more information on the event bus.

  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<EventBus>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `EventBus(EventBus delegate)`
    `EventBus(Object delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `<T> EventBus` | `addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is received by Vert.x
    `<T> EventBus` | `addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Add an interceptor that will be called whenever a message is sent from Vert.x
    `<T> MessageConsumer<T>` | `consumer(String address)` Create a message consumer against the specified address.
    `<T> MessageConsumer<T>` | `consumer(String address, Handler<Message<T>> handler)` Create a consumer and register it against the specified address.
    `boolean` | `equals(Object o)`
    `EventBus` | `getDelegate()`
    `int` | `hashCode()`
    `boolean` | `isMetricsEnabled()` Whether the metrics are enabled for this measured object
    `<T> MessageConsumer<T>` | `localConsumer(String address)` Like `consumer(java.lang.String)` but the address won't be propagated across the cluster.
    `<T> MessageConsumer<T>` | `localConsumer(String address, Handler<Message<T>> handler)` Like `consumer(java.lang.String)` but the address won't be propagated across the cluster.
    `static EventBus` | `newInstance(EventBus arg)`
    `EventBus` | `publish(String address, Object message)` Publish a message.
    `EventBus` | `publish(String address, Object message, DeliveryOptions options)` Like but specifying `options` that can be used to configure the delivery.
    `<T> MessageProducer<T>` | `publisher(String address)` Create a message publisher against the specified address.
    `<T> MessageProducer<T>` | `publisher(String address, DeliveryOptions options)` Like `publisher(java.lang.String)` but specifying delivery options that will be used for configuring the delivery of the message.
    `EventBus` | `registerCodec(MessageCodec codec)` Register a message codec.
    `<T> EventBus` | `removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `addInboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
    `<T> EventBus` | `removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `addOutboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
    `<T> EventBus` | `request(String address, Object message)` Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> EventBus` | `request(String address, Object message, DeliveryOptions options)` Like but specifying `options` that can be used to configure the delivery.
    `<T> EventBus` | `request(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler)` Like but specifying `options` that can be used to configure the delivery.
    `<T> EventBus` | `request(String address, Object message, Handler<AsyncResult<Message<T>>> replyHandler)` Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> Single<Message<T>>` | `rxRequest(String address, Object message)` Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.
    `<T> Single<Message<T>>` | `rxRequest(String address, Object message, DeliveryOptions options)` Like but specifying `options` that can be used to configure the delivery.
    `EventBus` | `send(String address, Object message)` Sends a message.
    `EventBus` | `send(String address, Object message, DeliveryOptions options)` Like but specifying `options` that can be used to configure the delivery.
    `<T> MessageProducer<T>` | `sender(String address)` Create a message sender against the specified address.
    `<T> MessageProducer<T>` | `sender(String address, DeliveryOptions options)` Like `sender(java.lang.String)` but specifying delivery options that will be used for configuring the delivery of the message.
    `String` | `toString()`
    `EventBus` | `unregisterCodec(String name)` Unregister a message codec.

    - ### Methods inherited from class java.lang.Object

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

    - ### Methods inherited from interface io.vertx.reactivex.core.metrics.Measured

      `newInstance`

- - ### Field Detail

    - #### __TYPE_ARG

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

  - ### Constructor Detail

    - #### EventBus

          public EventBus(EventBus delegate)

    - #### EventBus

          public EventBus(Object delegate)

  - ### 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 EventBus getDelegate()

      Specified by:
        `getDelegate` in interface `Measured`

    - #### isMetricsEnabled

          public boolean isMetricsEnabled()

      Whether the metrics are enabled for this measured object
      Specified by:
        `isMetricsEnabled` in interface `Measured`
      Returns:
        `true` if metrics are enabled

    - #### send

          public EventBus send(String address,
                               Object message)

      Sends a message.

      The message will be delivered to at most one of the handlers registered to the address.

      Parameters:
        `address` - the address to send it to
        `message` - the message, may be `null`
      Returns:
        a reference to this, so the API can be used fluently

    - #### send

          public EventBus send(String address,
                               Object message,
                               DeliveryOptions options)

      Like but specifying `options` that can be used to configure the delivery.
      Parameters:
        `address` - the address to send it to
        `message` - the message, may be `null`
        `options` - delivery options
      Returns:
        a reference to this, so the API can be used fluently

    - #### request

          public <T> EventBus request(String address,
                                      Object message,
                                      Handler<AsyncResult<Message<T>>> replyHandler)

      Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.

      The message will be delivered to at most one of the handlers registered to the address.

      Parameters:
        `address` - the address to send it to
        `message` - the message body, may be `null`
        `replyHandler` - reply handler will be called when any reply from the recipient is received
      Returns:
        a reference to this, so the API can be used fluently

    - #### request

          public <T> EventBus request(String address,
                                      Object message)

      Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.

      The message will be delivered to at most one of the handlers registered to the address.

      Parameters:
        `address` - the address to send it to
        `message` - the message body, may be `null`
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxRequest

          public <T> Single<Message<T>> rxRequest(String address,
                                                  Object message)

      Sends a message and specify a `replyHandler` that will be called if the recipient subsequently replies to the message.

      The message will be delivered to at most one of the handlers registered to the address.

      Parameters:
        `address` - the address to send it to
        `message` - the message body, may be `null`
      Returns:
        a reference to this, so the API can be used fluently

    - #### request

          public <T> EventBus request(String address,
                                      Object message,
                                      DeliveryOptions options,
                                      Handler<AsyncResult<Message<T>>> replyHandler)

      Like but specifying `options` that can be used to configure the delivery.
      Parameters:
        `address` - the address to send it to
        `message` - the message body, may be `null`
        `options` - delivery options
        `replyHandler` - reply handler will be called when any reply from the recipient is received
      Returns:
        a reference to this, so the API can be used fluently

    - #### request

          public <T> EventBus request(String address,
                                      Object message,
                                      DeliveryOptions options)

      Like but specifying `options` that can be used to configure the delivery.
      Parameters:
        `address` - the address to send it to
        `message` - the message body, may be `null`
        `options` - delivery options
      Returns:
        a reference to this, so the API can be used fluently

    - #### rxRequest

          public <T> Single<Message<T>> rxRequest(String address,
                                                  Object message,
                                                  DeliveryOptions options)

      Like but specifying `options` that can be used to configure the delivery.
      Parameters:
        `address` - the address to send it to
        `message` - the message body, may be `null`
        `options` - delivery options
      Returns:
        a reference to this, so the API can be used fluently

    - #### publish

          public EventBus publish(String address,
                                  Object message)

      Publish a message.

      The message will be delivered to all handlers registered to the address.

      Parameters:
        `address` - the address to publish it to
        `message` - the message, may be `null`
      Returns:
        a reference to this, so the API can be used fluently

    - #### publish

          public EventBus publish(String address,
                                  Object message,
                                  DeliveryOptions options)

      Like but specifying `options` that can be used to configure the delivery.
      Parameters:
        `address` - the address to publish it to
        `message` - the message, may be `null`
        `options` - the delivery options
      Returns:
        a reference to this, so the API can be used fluently

    - #### consumer

          public <T> MessageConsumer<T> consumer(String address)

      Create a message consumer against the specified address.

      The returned consumer is not yet registered at the address, registration will be effective when `MessageConsumer.handler(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.Message<T>>)` is called.

      Parameters:
        `address` - the address that it will register it at
      Returns:
        the event bus message consumer

    - #### consumer

          public <T> MessageConsumer<T> consumer(String address,
                                                 Handler<Message<T>> handler)

      Create a consumer and register it against the specified address.
      Parameters:
        `address` - the address that will register it at
        `handler` - the handler that will process the received messages
      Returns:
        the event bus message consumer

    - #### localConsumer

          public <T> MessageConsumer<T> localConsumer(String address)

      Like `consumer(java.lang.String)` but the address won't be propagated across the cluster.
      Parameters:
        `address` - the address to register it at
      Returns:
        the event bus message consumer

    - #### localConsumer

          public <T> MessageConsumer<T> localConsumer(String address,
                                                      Handler<Message<T>> handler)

      Like `consumer(java.lang.String)` but the address won't be propagated across the cluster.
      Parameters:
        `address` - the address that will register it at
        `handler` - the handler that will process the received messages
      Returns:
        the event bus message consumer

    - #### sender

          public <T> MessageProducer<T> sender(String address)

      Create a message sender against the specified address.

      The returned sender will invoke the method when the stream `WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` method is called with the sender address and the provided data.

      Parameters:
        `address` - the address to send it to
      Returns:
        The sender

    - #### sender

          public <T> MessageProducer<T> sender(String address,
                                               DeliveryOptions options)

      Like `sender(java.lang.String)` but specifying delivery options that will be used for configuring the delivery of the message.
      Parameters:
        `address` - the address to send it to
        `options` - the delivery options
      Returns:
        The sender

    - #### publisher

          public <T> MessageProducer<T> publisher(String address)

      Create a message publisher against the specified address.

      The returned publisher will invoke the method when the stream `WriteStream.write(T, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>)` method is called with the publisher address and the provided data.

      Parameters:
        `address` - The address to publish it to
      Returns:
        The publisher

    - #### publisher

          public <T> MessageProducer<T> publisher(String address,
                                                  DeliveryOptions options)

      Like `publisher(java.lang.String)` but specifying delivery options that will be used for configuring the delivery of the message.
      Parameters:
        `address` - the address to publish it to
        `options` - the delivery options
      Returns:
        The publisher

    - #### addOutboundInterceptor

          public <T> EventBus addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)

      Add an interceptor that will be called whenever a message is sent from Vert.x
      Parameters:
        `interceptor` - the interceptor
      Returns:
        a reference to this, so the API can be used fluently

    - #### removeOutboundInterceptor

          public <T> EventBus removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)

      Remove an interceptor that was added by `addOutboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
      Parameters:
        `interceptor` - the interceptor
      Returns:
        a reference to this, so the API can be used fluently

    - #### addInboundInterceptor

          public <T> EventBus addInboundInterceptor(Handler<DeliveryContext<T>> interceptor)

      Add an interceptor that will be called whenever a message is received by Vert.x
      Parameters:
        `interceptor` - the interceptor
      Returns:
        a reference to this, so the API can be used fluently

    - #### removeInboundInterceptor

          public <T> EventBus removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)

      Remove an interceptor that was added by `addInboundInterceptor(io.vertx.core.Handler<io.vertx.reactivex.core.eventbus.DeliveryContext<T>>)`
      Parameters:
        `interceptor` - the interceptor
      Returns:
        a reference to this, so the API can be used fluently

    - #### registerCodec

          public EventBus registerCodec(MessageCodec codec)

      Register a message codec.

      You can register a message codec if you want to send any non standard message across the event bus. E.g. you might want to send POJOs directly across the event bus.

      To use a message codec for a send, you should specify it in the delivery options.

      Parameters:
        `codec` - the message codec to register
      Returns:
        a reference to this, so the API can be used fluently

    - #### unregisterCodec

          public EventBus unregisterCodec(String name)

      Unregister a message codec.

      Parameters:
        `name` - the name of the codec
      Returns:
        a reference to this, so the API can be used fluently

    - #### newInstance

          public static EventBus newInstance(EventBus arg)

Copyright © 2021 Eclipse. All rights reserved.