Package io.vertx.mutiny.core.eventbus

Class EventBus

java.lang.Object
io.vertx.mutiny.core.eventbus.EventBus
All Implemented Interfaces:
MutinyDelegate, Measured
public class EventBus extends Object implements Measured, MutinyDelegate
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 Mutiny-ified interface.

Author:
Tim Fox
See Also:
  • EventBus

  • Field Details

  • Constructor Details

    • EventBus

      public EventBus(io.vertx.core.eventbus.EventBus delegate)
      Create a new instance of EventBus delegating to the given (non-null) instance of EventBus.

    • EventBus

      public EventBus(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.eventbus.EventBus getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface Measured
      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance

    • request

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<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.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      address - the address to send it to
      message - the message body, may be null
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • EventBus.request(String, Object)

    • requestAndAwait

      public <T> Message<T> requestAndAwait(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.

      Unlike the bare Vert.x variant, this method returns a Message<T>. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      address - the address to send it to
      message - the message body, may be null
      Returns:
      The operation result
      See Also:
      • EventBus.request(String, Object)

    • requestAndForget

      public <T> EventBus requestAndForget(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.

      Unlike the bare Vert.x variant, this method ignores the Message<T> result or any failure.

      Parameters:
      address - the address to send it to
      message - the message body, may be null
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • EventBus.request(String, Object)

    • request

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<Message<T>> request(String address, Object message, io.vertx.core.eventbus.DeliveryOptions options)
      Like request(String, Object) but specifying options that can be used to configure the delivery.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      address - the address to send it to
      message - the message body, may be null
      options - delivery options
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • EventBus.request(String, Object, DeliveryOptions)

    • requestAndAwait

      public <T> Message<T> requestAndAwait(String address, Object message, io.vertx.core.eventbus.DeliveryOptions options)
      Like request(String, Object) but specifying options that can be used to configure the delivery.

      Unlike the bare Vert.x variant, this method returns a Message<T>. This method awaits indefinitely for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

      Parameters:
      address - the address to send it to
      message - the message body, may be null
      options - delivery options
      Returns:
      The operation result
      See Also:
      • EventBus.request(String, Object, DeliveryOptions)

    • requestAndForget

      public <T> EventBus requestAndForget(String address, Object message, io.vertx.core.eventbus.DeliveryOptions options)
      Like request(String, Object) but specifying options that can be used to configure the delivery.

      Unlike the bare Vert.x variant, this method ignores the Message<T> result or any failure.

      Parameters:
      address - the address to send it to
      message - the message body, may be null
      options - delivery options
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • EventBus.request(String, Object, DeliveryOptions)

    • 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, io.vertx.core.eventbus.DeliveryOptions options)
      Like send(String, 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

    • 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, io.vertx.core.eventbus.DeliveryOptions options)
      Like publish(String, 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(io.vertx.core.eventbus.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) is called.

      Parameters:
      options - the consumer options
      Returns:
      the event bus message consumer

    • consumer

      public <T> MessageConsumer<T> consumer(io.vertx.core.eventbus.MessageConsumerOptions options, Consumer<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) 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, Consumer<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(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, Consumer<Message<T>> handler)
      Like #consumer(String, Handler) 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(String, Object) method when the stream WriteStream.write(Object) 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, io.vertx.core.eventbus.DeliveryOptions options)
      Like sender(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(String, Object) method when the stream WriteStream.write(Object) 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, io.vertx.core.eventbus.DeliveryOptions options)
      Like publisher(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

    • registerCodec

      public EventBus registerCodec(io.vertx.core.eventbus.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

    • 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(MessageCodec) or #registerDefaultCodec(Class, MessageCodec).

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

    • addOutboundInterceptor

      public <T> EventBus addOutboundInterceptor(Consumer<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(Consumer<DeliveryContext<T>> interceptor)
      Remove an interceptor that was added by #addOutboundInterceptor(Handler)
      Parameters:
      interceptor - the interceptor
      Returns:
      a reference to this, so the API can be used fluently

    • addInboundInterceptor

      public <T> EventBus addInboundInterceptor(Consumer<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(Consumer<DeliveryContext<T>> interceptor)
      Remove an interceptor that was added by #addInboundInterceptor(Handler)
      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

    • 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

    • newInstance

      public static EventBus newInstance(io.vertx.core.eventbus.EventBus delegate)
      Creates a new instance of the EventBus.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object