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)

      • EventBus

        public EventBus​(Object 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

        public EventBus send​(String address,
                     Object message)
        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)
        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

        @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. 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:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • 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:
        the Message instance produced by the operation.

      • requestAndForget

        public <T> EventBus requestAndForget​(String address,
                                     Object message)
        Variant of request(String,Object) that ignores the result of the operation.

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

        Parameters:
        address - the address to send it to
        message - the message body, may be null
        Returns:
        the instance of EventBus to chain method calls.

      • request

        @CheckReturnValue
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:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • 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:
        the Message instance produced by the operation.

      • requestAndForget

        public <T> EventBus requestAndForget​(String address,
                                     Object message,
                                     io.vertx.core.eventbus.DeliveryOptions options)
        Variant of request(String,Object,DeliveryOptions) that ignores the result of the operation.

        This method subscribes on the result of request(String,Object,DeliveryOptions), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from request(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 body, may be null
        options - delivery options
        Returns:
        the instance of EventBus to chain method calls.

      • 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:

      • 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:

      • 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

      • codecSelector

        public EventBus codecSelector​(Function<Object,​String> selector)
        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)
        Parameters:
        interceptor - the interceptor
        Returns:

      • removeOutboundInterceptor

        public <T> EventBus removeOutboundInterceptor​(Consumer<DeliveryContext<T>> interceptor)
        Parameters:
        interceptor - the interceptor
        Returns:

      • addInboundInterceptor

        public <T> EventBus addInboundInterceptor​(Consumer<DeliveryContext<T>> interceptor)
        Parameters:
        interceptor - the interceptor
        Returns:

      • removeInboundInterceptor

        public <T> EventBus removeInboundInterceptor​(Consumer<DeliveryContext<T>> interceptor)
        Parameters:
        interceptor - the interceptor
        Returns:

      • clusterSerializableChecker

        public EventBus clusterSerializableChecker​(Function<String,​Boolean> classNamePredicate)
        Parameters:
        classNamePredicate - the predicate
        Returns:
        a reference to this, so the API can be used fluently

      • serializableChecker

        public EventBus serializableChecker​(Function<String,​Boolean> classNamePredicate)
        Parameters:
        classNamePredicate - the predicate
        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

      • newInstance

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