Package io.vertx.mutiny.core.eventbus

Class 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 Mutiny-ified interface using Vert.x codegen.

    • Constructor Detail

      • EventBus

        public EventBus​(io.vertx.core.eventbus.EventBus delegate)

    • Method Detail

      • getDelegate

        public io.vertx.core.eventbus.EventBus getDelegate()
        Specified by:
        getDelegate in interface Measured

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • isMetricsEnabled

        public boolean isMetricsEnabled()
        Specified by:
        isMetricsEnabled in interface Measured
        Returns:
        true if metrics are enabled

      • send

        @Deprecated
public <T> io.smallrye.mutiny.Uni<Message<T>> send​(String address,
                                                   Object message)
        Deprecated.
        Like send(java.lang.String, java.lang.Object) but specifying a replyHandler that will be called if the recipient subsequently replies to the message.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        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

      • sendAndAwait

        @Deprecated
public <T> Message<T> sendAndAwait​(String address,
                                   Object message)
        Deprecated.
        Blocking variant of send(String,Object).

        This method waits 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, may be null
        Returns:
        a reference to this, so the API can be used fluently

      • send

        @Deprecated
public <T> io.smallrye.mutiny.Uni<Message<T>> send​(String address,
                                                   Object message,
                                                   io.vertx.core.eventbus.DeliveryOptions options)
        Deprecated.
        Like send(java.lang.String, java.lang.Object) but specifying a replyHandler that will be called if the recipient subsequently replies to the message.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        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

      • sendAndAwait

        @Deprecated
public <T> Message<T> sendAndAwait​(String address,
                                   Object message,
                                   io.vertx.core.eventbus.DeliveryOptions options)
        Deprecated.
        Blocking variant of send(String,Object,DeliveryOptions).

        This method waits 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, may be null
        options - delivery options
        Returns:
        a reference to this, so the API can be used fluently

      • request

        public <T> io.smallrye.mutiny.Uni<Message<T>> request​(String address,
                                                      Object message)
        Sends a message and 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. 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 reference to this, so the API can be used fluently

      • requestAndAwait

        public <T> Message<T> requestAndAwait​(String address,
                                      Object message)
        Blocking variant of request(String,Object).

        This method waits 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:
        a reference to this, so the API can be used fluently

      • request

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

        Unlike the bare Vert.x variant, this method returns a Uni. 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 reference to this, so the API can be used fluently

      • requestAndAwait

        public <T> Message<T> requestAndAwait​(String address,
                                      Object message,
                                      io.vertx.core.eventbus.DeliveryOptions options)
        Blocking variant of request(String,Object,DeliveryOptions).

        This method waits 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:
        a reference to this, so the API can be used fluently

      • publish

        public EventBus publish​(String address,
                        Object message)
        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)
        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)
        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)
        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)
        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)
        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)
        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)
        Parameters:
        address - the address to send it to
        options - the delivery options
        Returns:
        The sender

      • publisher

        public <T> MessageProducer<T> publisher​(String address)
        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)
        Parameters:
        address - the address to publish it to
        options - the delivery options
        Returns:
        The publisher

      • addOutboundInterceptor

        public <T> EventBus addOutboundInterceptor​(Consumer<DeliveryContext<T>> interceptor)
        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)
        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)
        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)
        Parameters:
        interceptor - the interceptor
        Returns:
        a reference to this, so the API can be used fluently

      • registerCodec

        public EventBus registerCodec​(io.vertx.core.eventbus.MessageCodec codec)
        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)
        Parameters:
        name - the name of the codec
        Returns:
        a reference to this, so the API can be used fluently

      • sendAndForget

        public EventBus sendAndForget​(String address,
                              Object message)
        Variant of send(String,Object) that ignores the result of the operation.

        This method subscribes on the result of send(String,Object), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from send(String,Object) but you don't need to compose it with other operations.

        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

      • sendAndForget

        public EventBus sendAndForget​(String address,
                              Object message,
                              io.vertx.core.eventbus.DeliveryOptions options)
        Variant of send(String,Object,DeliveryOptions) that ignores the result of the operation.

        This method subscribes on the result of send(String,Object,DeliveryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from send(String,Object,DeliveryOptions) but you don't need to compose it with other operations.

        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

      • newInstance

        public static EventBus newInstance​(io.vertx.core.eventbus.EventBus arg)