Package io.vertx.reactivex.core.eventbus

## Class EventBus

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

- All Implemented Interfaces:
    `io.vertx.lang.rx.RxDelegate`, `Measured`

      public class EventBus
      extends Object
      implements io.vertx.lang.rx.RxDelegate, 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 | Description
    --- | --- | ---
    `static io.vertx.lang.rx.TypeArg<EventBus>` | `__TYPE_ARG` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `EventBus​(EventBus delegate)` |
    `EventBus​(Object delegate)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | 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
    `EventBus` | `clusterSerializableChecker​(Function<String,​Boolean> classNamePredicate)` | Register a predicate to invoke when verifying if an object is forbidden to be encoded/decoded as `ClusterSerializable`.
    `EventBus` | `codecSelector​(Function<Object,​String> selector)` | Set selector to be invoked when the bus has not found any codec for a `Message` body.
    `<T> MessageConsumer<T>` | `consumer​(MessageConsumerOptions options)` | Create a message consumer against the specified options address.
    `<T> MessageConsumer<T>` | `consumer​(MessageConsumerOptions options, Handler<Message<T>> handler)` | Create a consumer and register it against the specified options address.
    `<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(io.vertx.core.eventbus.MessageConsumerOptions)` but the address won't be propagated across the cluster.
    `<T> MessageConsumer<T>` | `localConsumer​(String address, Handler<Message<T>> handler)` | Like `consumer(io.vertx.core.eventbus.MessageConsumerOptions)` 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 `publish(java.lang.String, java.lang.Object)` 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> Future<Message<T>>` | `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> Future<Message<T>>` | `request​(String address, Object message, DeliveryOptions options)` | Like `request(java.lang.String, java.lang.Object)` but specifying `options` that can be used to configure the delivery.
    `<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 `request(java.lang.String, java.lang.Object)` 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 `send(java.lang.String, java.lang.Object)` 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.
    `EventBus` | `serializableChecker​(Function<String,​Boolean> classNamePredicate)` | Register a predicate to invoke when verifying if an object is allowed to be encoded/decoded as `Serializable`.
    `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`

- - ### 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`
      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`

    - #### 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 `send(java.lang.String, java.lang.Object)` 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> Future<Message<T>> 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 future notified when any reply from the recipient is received

    - #### 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 future notified when any reply from the recipient is received

    - #### request

          public <T> Future<Message<T>> request​(String address,
                                                Object message,
                                                DeliveryOptions options)

      Like `request(java.lang.String, java.lang.Object)` 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 future notified when any reply from the recipient is received

    - #### rxRequest

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

      Like `request(java.lang.String, java.lang.Object)` 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 future notified when any reply from the recipient is received

    - #### 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 `publish(java.lang.String, java.lang.Object)` 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​(MessageConsumerOptions options)

      Create a message consumer against the specified options 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:
        `options` - the consumer options
      Returns:
        the event bus message consumer

    - #### consumer

          public <T> MessageConsumer<T> consumer​(MessageConsumerOptions options,
                                                 Handler<Message<T>> handler)

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

    - #### 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(io.vertx.core.eventbus.MessageConsumerOptions)` 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(io.vertx.core.eventbus.MessageConsumerOptions)` 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 `send(java.lang.String, java.lang.Object)` method when the stream `WriteStream.write(T)` 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 `publish(java.lang.String, java.lang.Object)` method when the stream `WriteStream.write(T)` 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

    - #### codecSelector

          public EventBus codecSelector​(Function<Object,​String> selector)

      Set selector to be invoked when the bus has not found any codec for a `Message` body.

      The selector must return the name of a codec which has been registered with either `registerCodec(io.vertx.core.eventbus.MessageCodec)` or `io.vertx.reactivex.core.eventbus.EventBus#registerDefaultCodec`.

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

    - #### 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

    - #### clusterSerializableChecker

          public EventBus clusterSerializableChecker​(Function<String,​Boolean> classNamePredicate)

      Register a predicate to invoke when verifying if an object is forbidden to be encoded/decoded as `ClusterSerializable`.

      This is only used when Vert.x is clustered.

      Parameters:
        `classNamePredicate` - the predicate
      Returns:
        a reference to this, so the API can be used fluently

    - #### serializableChecker

          public EventBus serializableChecker​(Function<String,​Boolean> classNamePredicate)

      Register a predicate to invoke when verifying if an object is allowed to be encoded/decoded as `Serializable`.

      This is only used when Vert.x is clustered.

      Parameters:
        `classNamePredicate` - the predicate
      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)