EventBusImpl (Vertx Javadocs 4.0.3.GA API)

java.lang.Object
- io.vertx.core.eventbus.impl.EventBusImpl

All Implemented Interfaces:

EventBus, EventBusInternal, Measured, MetricsProvider

Direct Known Subclasses:

ClusteredEventBus
```
public class EventBusImpl
extends Object
implements EventBusInternal, MetricsProvider
```
A local event bus implementation

Author:

Tim Fox T

Field Summary

Fields
Modifier and Type	Field and Description
`protected CodecManager`	`codecManager`
`protected ConcurrentMap<String,ConcurrentCyclicSequence<HandlerHolder>>`	`handlerMap`
`protected EventBusMetrics`	`metrics`
`protected boolean`	`started`
`protected VertxInternal`	`vertx`

Constructor Summary

Constructors
Constructor and Description

EventBusImpl(VertxInternal vertx)

Constructors
Constructor and Description
`EventBusImpl(VertxInternal vertx)`

Method Summary

All 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
`protected <T> HandlerHolder<T>`	`addRegistration(String address, HandlerRegistration<T> registration, boolean replyHandler, boolean localOnly, Promise<Void> promise)`
`protected void`	`callCompletionHandlerAsync(Handler<AsyncResult<Void>> completionHandler)`
`protected void`	`checkStarted()`
`void`	`close(Promise<Void> promise)` Close the event bus and release any resources held.
`<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.
`protected <T> HandlerHolder<T>`	`createHandlerHolder(HandlerRegistration<T> registration, boolean replyHandler, boolean localOnly, ContextInternal context)`
`MessageImpl`	`createMessage(boolean send, String address, MultiMap headers, Object body, String codecName)`
`protected ReplyException`	`deliverMessageLocally(MessageImpl msg)`
`protected String`	`generateReplyAddress()`
`EventBusMetrics<?>`	`getMetrics()` Returns the metrics implementation.
`protected boolean`	`isMessageLocal(MessageImpl msg)`
`boolean`	`isMetricsEnabled()` Whether the metrics are enabled for this measured object
`<T> MessageConsumer<T>`	`localConsumer(String address)` Like `EventBus.consumer(String)` but the address won't be propagated across the cluster.
`<T> MessageConsumer<T>`	`localConsumer(String address, Handler<Message<T>> handler)` Like `EventBus.consumer(String, Handler)` but the address won't be propagated across the cluster.
`<T> OutboundDeliveryContext<T>`	`newSendContext(MessageImpl message, DeliveryOptions options, io.vertx.core.eventbus.impl.ReplyHandler<T> handler, Promise<Void> writePromise)`
`protected <T> void`	`onLocalRegistration(HandlerHolder<T> handlerHolder, Promise<Void> promise)`
`protected <T> void`	`onLocalUnregistration(HandlerHolder<T> handlerHolder, Promise<Void> promise)`
`EventBus`	`publish(String address, Object message)` Publish a message.
`EventBus`	`publish(String address, Object message, DeliveryOptions options)` Like `EventBus.publish(String, 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 `EventBus.publisher(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`	`registerDefaultCodec(Class<T> clazz, MessageCodec<T,?> codec)` Register a default message codec.
`<T> EventBus`	`removeInboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addInboundInterceptor(Handler)`
`<T> EventBus`	`removeOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)` Remove an interceptor that was added by `EventBus.addOutboundInterceptor(Handler)`
`protected <T> void`	`removeRegistration(HandlerHolder<T> handlerHolder, Promise<Void> promise)`
`<T> Future<Message<T>>`	`request(String address, Object message, DeliveryOptions options)` Like `EventBus.request(String, Object, DeliveryOptions, Handler)` but returns a `Future` of the asynchronous result
`EventBus`	`send(String address, Object message)` Sends a message.
`EventBus`	`send(String address, Object message, DeliveryOptions options)` Like `EventBus.send(String, 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 `EventBus.sender(String)` but specifying delivery options that will be used for configuring the delivery of the message.
`protected <T> void`	`sendOrPub(OutboundDeliveryContext<T> sendContext)`
`<T> void`	`sendOrPubInternal(MessageImpl message, DeliveryOptions options, io.vertx.core.eventbus.impl.ReplyHandler<T> handler, Promise<Void> writePromise)`
`<T> void`	`sendOrPubInternal(OutboundDeliveryContext<T> senderCtx)`
`protected <T> void`	`sendReply(MessageImpl replyMessage, DeliveryOptions options, io.vertx.core.eventbus.impl.ReplyHandler<T> replyHandler)`
`void`	`start(Promise<Void> promise)` Start the event bus.
`EventBus`	`unregisterCodec(String name)` Unregister a message codec.
`EventBus`	`unregisterDefaultCodec(Class clazz)` Unregister a default message codec.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.vertx.core.eventbus.EventBus
request, request, request

- Field Detail
  - vertx
```
protected final VertxInternal vertx
```
  - metrics
```
protected final EventBusMetrics metrics
```
  - handlerMap
```
protected final ConcurrentMap<String,ConcurrentCyclicSequence<HandlerHolder>> handlerMap
```
  - codecManager
```
protected final CodecManager codecManager
```
  - started
```
protected volatile boolean started
```
- Constructor Detail
  - EventBusImpl
```
public EventBusImpl(VertxInternal vertx)
```
- Method Detail
  - addOutboundInterceptor
```
public <T> EventBus addOutboundInterceptor(Handler<DeliveryContext<T>> interceptor)
```
    Description copied from interface: EventBus
    
    Add an interceptor that will be called whenever a message is sent from Vert.x
    
    Specified by:
    
    addOutboundInterceptor in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Add an interceptor that will be called whenever a message is received by Vert.x
    
    Specified by:
    
    addInboundInterceptor in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Remove an interceptor that was added by EventBus.addOutboundInterceptor(Handler)
    
    Specified by:
    
    removeOutboundInterceptor in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Remove an interceptor that was added by EventBus.addInboundInterceptor(Handler)
    
    Specified by:
    
    removeInboundInterceptor in interface EventBus
    
    Parameters:
    
    interceptor - the interceptor
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - start
```
public void start(Promise<Void> promise)
```
    Description copied from interface: EventBusInternal
    
    Start the event bus.
    
    Specified by:
    
    start in interface EventBusInternal
  - send
```
public EventBus send(String address,
                     Object message)
```
    Description copied from interface: EventBus
    
    Sends a message.
    The message will be delivered to at most one of the handlers registered to the address.
    
    Specified by:
    
    send in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Like EventBus.send(String, Object) but specifying options that can be used to configure the delivery.
    
    Specified by:
    
    send in interface EventBus
    
    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,
                                      DeliveryOptions options)
```
    Description copied from interface: EventBus
    
    Like EventBus.request(String, Object, DeliveryOptions, Handler) but returns a Future of the asynchronous result
    
    Specified by:
    
    request in interface EventBus
  - sender
```
public <T> MessageProducer<T> sender(String address)
```
    Description copied from interface: EventBus
    
    Create a message sender against the specified address.
    The returned sender will invoke the EventBus.send(String, Object) method when the stream WriteStream.write(Object) method is called with the sender address and the provided data.
    
    Specified by:
    
    sender in interface EventBus
    
    Parameters:
    
    address - the address to send it to
    
    Returns:
    
    The sender
  - sender
```
public <T> MessageProducer<T> sender(String address,
                                     DeliveryOptions options)
```
    Description copied from interface: EventBus
    
    Like EventBus.sender(String) but specifying delivery options that will be used for configuring the delivery of the message.
    
    Specified by:
    
    sender in interface EventBus
    
    Parameters:
    
    address - the address to send it to
    
    options - the delivery options
    
    Returns:
    
    The sender
  - publisher
```
public <T> MessageProducer<T> publisher(String address)
```
    Description copied from interface: EventBus
    
    Create a message publisher against the specified address.
    The returned publisher will invoke the EventBus.publish(String, Object) method when the stream WriteStream.write(Object) method is called with the publisher address and the provided data.
    
    Specified by:
    
    publisher in interface EventBus
    
    Parameters:
    
    address - The address to publish it to
    
    Returns:
    
    The publisher
  - publisher
```
public <T> MessageProducer<T> publisher(String address,
                                        DeliveryOptions options)
```
    Description copied from interface: EventBus
    
    Like EventBus.publisher(String) but specifying delivery options that will be used for configuring the delivery of the message.
    
    Specified by:
    
    publisher in interface EventBus
    
    Parameters:
    
    address - the address to publish it to
    
    options - the delivery options
    
    Returns:
    
    The publisher
  - publish
```
public EventBus publish(String address,
                        Object message)
```
    Description copied from interface: EventBus
    
    Publish a message.
    The message will be delivered to all handlers registered to the address.
    
    Specified by:
    
    publish in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Like EventBus.publish(String, Object) but specifying options that can be used to configure the delivery.
    
    Specified by:
    
    publish in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    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.
    
    Specified by:
    
    consumer in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Create a consumer and register it against the specified address.
    
    Specified by:
    
    consumer in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Like EventBus.consumer(String) but the address won't be propagated across the cluster.
    
    Specified by:
    
    localConsumer in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Like EventBus.consumer(String, Handler) but the address won't be propagated across the cluster.
    
    Specified by:
    
    localConsumer in interface EventBus
    
    Parameters:
    
    address - the address that will register it at
    
    handler - the handler that will process the received messages
    
    Returns:
    
    the event bus message consumer
  - registerCodec
```
public EventBus registerCodec(MessageCodec codec)
```
    Description copied from interface: EventBus
    
    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.
    
    Specified by:
    
    registerCodec in interface EventBus
    
    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)
```
    Description copied from interface: EventBus
    
    Unregister a message codec.
    
    Specified by:
    
    unregisterCodec in interface EventBus
    
    Parameters:
    
    name - the name of the codec
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - registerDefaultCodec
```
public <T> EventBus registerDefaultCodec(Class<T> clazz,
                                         MessageCodec<T,?> codec)
```
    Description copied from interface: EventBus
    
    Register a default 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.
    Default message codecs will be used to serialise any messages of the specified type on the event bus without the codec having to be specified in the delivery options.
    
    Specified by:
    
    registerDefaultCodec in interface EventBus
    
    Parameters:
    
    clazz - the class for which to use this codec
    
    codec - the message codec to register
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - unregisterDefaultCodec
```
public EventBus unregisterDefaultCodec(Class clazz)
```
    Description copied from interface: EventBus
    
    Unregister a default message codec.
    
    Specified by:
    
    unregisterDefaultCodec in interface EventBus
    
    Parameters:
    
    clazz - the class for which the codec was registered
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - close
```
public void close(Promise<Void> promise)
```
    Description copied from interface: EventBusInternal
    
    Close the event bus and release any resources held.
    
    Specified by:
    
    close in interface EventBusInternal
  - isMetricsEnabled
```
public boolean isMetricsEnabled()
```
    Description copied from interface: Measured
    
    Whether the metrics are enabled for this measured object
    
    Specified by:
    
    isMetricsEnabled in interface Measured
    
    Returns:
    
    true if metrics are enabled
  - getMetrics
```
public EventBusMetrics<?> getMetrics()
```
    Description copied from interface: MetricsProvider
    
    Returns the metrics implementation.
    
    Specified by:
    
    getMetrics in interface MetricsProvider
    
    Returns:
    
    the metrics
  - createMessage
```
public MessageImpl createMessage(boolean send,
                                 String address,
                                 MultiMap headers,
                                 Object body,
                                 String codecName)
```
  - addRegistration
```
protected <T> HandlerHolder<T> addRegistration(String address,
                                               HandlerRegistration<T> registration,
                                               boolean replyHandler,
                                               boolean localOnly,
                                               Promise<Void> promise)
```
  - onLocalRegistration
```
protected <T> void onLocalRegistration(HandlerHolder<T> handlerHolder,
                                       Promise<Void> promise)
```
  - createHandlerHolder
```
protected <T> HandlerHolder<T> createHandlerHolder(HandlerRegistration<T> registration,
                                                   boolean replyHandler,
                                                   boolean localOnly,
                                                   ContextInternal context)
```
  - removeRegistration
```
protected <T> void removeRegistration(HandlerHolder<T> handlerHolder,
                                      Promise<Void> promise)
```
  - onLocalUnregistration
```
protected <T> void onLocalUnregistration(HandlerHolder<T> handlerHolder,
                                         Promise<Void> promise)
```
  - sendReply
```
protected <T> void sendReply(MessageImpl replyMessage,
                             DeliveryOptions options,
                             io.vertx.core.eventbus.impl.ReplyHandler<T> replyHandler)
```
  - sendOrPub
```
protected <T> void sendOrPub(OutboundDeliveryContext<T> sendContext)
```
  - callCompletionHandlerAsync
```
protected void callCompletionHandlerAsync(Handler<AsyncResult<Void>> completionHandler)
```
  - isMessageLocal
```
protected boolean isMessageLocal(MessageImpl msg)
```
  - deliverMessageLocally
```
protected ReplyException deliverMessageLocally(MessageImpl msg)
```
  - checkStarted
```
protected void checkStarted()
```
  - generateReplyAddress
```
protected String generateReplyAddress()
```
  - newSendContext
```
public <T> OutboundDeliveryContext<T> newSendContext(MessageImpl message,
                                                     DeliveryOptions options,
                                                     io.vertx.core.eventbus.impl.ReplyHandler<T> handler,
                                                     Promise<Void> writePromise)
```
  - sendOrPubInternal
```
public <T> void sendOrPubInternal(OutboundDeliveryContext<T> senderCtx)
```
  - sendOrPubInternal
```
public <T> void sendOrPubInternal(MessageImpl message,
                                  DeliveryOptions options,
                                  io.vertx.core.eventbus.impl.ReplyHandler<T> handler,
                                  Promise<Void> writePromise)
```

Class EventBusImpl

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.vertx.core.eventbus.EventBus

Field Detail

vertx

metrics

handlerMap

codecManager

started

Constructor Detail

EventBusImpl

Method Detail

addOutboundInterceptor

addInboundInterceptor

removeOutboundInterceptor

removeInboundInterceptor

start

send

send

request

sender

sender

publisher

publisher

publish

publish

consumer

consumer

localConsumer

localConsumer

registerCodec

unregisterCodec

registerDefaultCodec

unregisterDefaultCodec

close

isMetricsEnabled

getMetrics

createMessage

addRegistration

onLocalRegistration

createHandlerHolder

removeRegistration

onLocalUnregistration

sendReply

sendOrPub

callCompletionHandlerAsync

isMessageLocal

deliverMessageLocally

checkStarted

generateReplyAddress

newSendContext

sendOrPubInternal

sendOrPubInternal