reactor.bus

Class EventBus

java.lang.Object

reactor.bus.EventBus

All Implemented Interfaces:

Bus<Event<?>>, reactor.fn.Consumer<Event<?>>

public class EventBus
extends java.lang.Object
implements Bus<Event<?>>, reactor.fn.Consumer<Event<?>>

A reactor is an event gateway that allows other components to register Event Consumers that can subsequently be notified of events. A consumer is typically registered with a Selector which, by matching on the notification key, governs which events the consumer will receive.

When a Reactor is notified of an Event, a task is dispatched using the reactor's Dispatcher which causes it to be executed on a thread based on the implementation of the Dispatcher being used.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	EventBus.ReplyToConsumer<E extends Event<?>,V>
static class	EventBus.ReplyToEvent<T>

Constructor Summary

Constructors

Constructor and Description
EventBus(reactor.core.Dispatcher dispatcher) Create a new Reactor that uses the given Dispatcher.
EventBus(reactor.core.Dispatcher dispatcher, Router router) Create a new Reactor that uses the given Dispatcher.
EventBus(reactor.core.Dispatcher dispatcher, Router router, reactor.fn.Consumer<java.lang.Throwable> dispatchErrorHandler, reactor.fn.Consumer<java.lang.Throwable> uncaughtErrorHandler)
EventBus(Registry<reactor.fn.Consumer<? extends Event<?>>> consumerRegistry, reactor.core.Dispatcher dispatcher, Router router, reactor.fn.Consumer<java.lang.Throwable> dispatchErrorHandler, reactor.fn.Consumer<java.lang.Throwable> uncaughtErrorHandler) Create a new Reactor that uses the given dispatacher and eventRouter.

Method Summary

Modifier and Type	Method and Description
void	accept(Event<?> event)
static EventBusSpec	config() Create a new EventBusSpec to configure a Reactor.
static EventBus	create() Create a new synchronous EventBus
static EventBus	create(reactor.core.Dispatcher dispatcher) Create a new EventBus using the given Dispatcher.
static EventBus	create(reactor.Environment env) Create a new EventBus using the given Environment.
static EventBus	create(reactor.Environment env, reactor.core.Dispatcher dispatcher) Create a new EventBus using the given Environment and Dispatcher.
static EventBus	create(reactor.Environment env, java.lang.String dispatcher) Create a new EventBus using the given Environment and dispatcher name.
Registry<reactor.fn.Consumer<? extends Event<?>>>	getConsumerRegistry() Get the Registry is use to maintain the Consumers currently listening for events on this Reactor.
reactor.core.Dispatcher	getDispatcher() Get the Dispatcher currently in use.
reactor.fn.Consumer<java.lang.Throwable>	getDispatchErrorHandler()
java.util.UUID	getId() Get the unique, time-used UUID of this Reactor.
Router	getRouter() Get the Router used to route events to Consumers.
reactor.fn.Consumer<java.lang.Throwable>	getUncaughtErrorHandler()
EventBus	notify(java.lang.Object key) Notify this component that the consumers registered with a Selector that matches the key should be triggered with a null input argument.
EventBus	notify(java.lang.Object key, Event<?> ev) Notify this component that an Event is ready to be processed.
EventBus	notify(java.lang.Object key, reactor.fn.Supplier<? extends Event<?>> supplier) Notify this component that the given Supplier can provide an event that's ready to be processed.
EventBus	notify(org.reactivestreams.Publisher<?> source, java.lang.Object key) Pass values accepted by this Stream into the given Bus, notifying with the given key.
<T> EventBus	notify(org.reactivestreams.Publisher<? extends T> source, reactor.fn.Function<? super T,?> keyMapper) Pass values accepted by this Stream into the given Bus, notifying with the given key.
org.reactivestreams.Publisher<? extends Event<?>>	on(Selector broadcastSelector) Attach a Publisher to the Bus with the specified Selector.
<T extends Event<?>> Registration<reactor.fn.Consumer<? extends Event<?>>>	on(Selector selector, reactor.fn.Consumer<T> consumer) Register a Consumer to be triggered when a notification matches the given Selector.
<T> reactor.fn.Consumer<Event<T>>	prepare(java.lang.Object key) Create an optimized path for publishing notifications to the given key.
<T extends Event<?>,V> Registration<reactor.fn.Consumer<? extends Event<?>>>	receive(Selector sel, reactor.fn.Function<T,V> fn) Assign a Function to receive an Event and produce a reply of the given type.
boolean	respondsToKey(java.lang.Object key) Are there any Registrations with Selectors that match the given key.
<T> void	schedule(reactor.fn.Consumer<T> consumer, T data) Schedule an arbitrary Consumer to be executed on the current Reactor Dispatcher, passing the given .
EventBus	send(java.lang.Object key, Event<?> ev) Notify this component of the given Event and register an internal Consumer that will take the output of a previously-registered Function and respond using the key set on the Event's replyTo property.
EventBus	send(java.lang.Object key, Event<?> ev, Bus replyTo) Notify this component of the given Event and register an internal Consumer that will take the output of a previously-registered Function and respond to the key set on the Event's replyTo property and will call the notify method on the given Bus.
EventBus	send(java.lang.Object key, reactor.fn.Supplier<? extends Event<?>> supplier) Notify this component that the given Supplier will provide an Event and register an internal Consumer that will take the output of a previously-registered Function and respond using the key set on the Event's replyTo property.
EventBus	send(java.lang.Object key, reactor.fn.Supplier<? extends Event<?>> supplier, Bus replyTo) Notify this component that the given Supplier will provide an Event and register an internal Consumer that will take the output of a previously-registered Function and respond to the key set on the Event's replyTo property and will call the notify method on the given Bus.
<T extends Event<?>> EventBus	sendAndReceive(java.lang.Object key, Event<?> event, reactor.fn.Consumer<T> reply) Register the given Consumer on an anonymous Selector and set the given event's replyTo property to the corresponding anonymous key, then register the consumer to receive replies from the Function assigned to handle the given key.
<T extends Event<?>> EventBus	sendAndReceive(java.lang.Object key, reactor.fn.Supplier<? extends Event<?>> supplier, reactor.fn.Consumer<T> reply) Register the given Consumer on an anonymous Selector and set the event's replyTo property to the corresponding anonymous key, then register the consumer to receive replies from the Function assigned to handle the given key.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

EventBus

public EventBus(@Nullable
                reactor.core.Dispatcher dispatcher)

Create a new Reactor that uses the given Dispatcher. The reactor will use a default Router that broadcast events to all of the registered consumers that match the notification key and does not perform any type conversion.

Parameters:

dispatcher - The Dispatcher to use. May be null in which case a new SynchronousDispatcher is used

EventBus

public EventBus(@Nullable
                reactor.core.Dispatcher dispatcher,
                @Nullable
                Router router)

Create a new Reactor that uses the given Dispatcher. The reactor will use a default CachingRegistry.

Parameters:

dispatcher - The Dispatcher to use. May be null in which case a new synchronous dispatcher is used.

router - The Router used to route events to Consumers. May be null in which case the default event router that broadcasts events to all of the registered consumers that match the notification key and does not perform any type conversion will be used.

EventBus

public EventBus(@Nullable
                reactor.core.Dispatcher dispatcher,
                @Nullable
                Router router,
                @Nullable
                reactor.fn.Consumer<java.lang.Throwable> dispatchErrorHandler,
                @Nullable
                reactor.fn.Consumer<java.lang.Throwable> uncaughtErrorHandler)

EventBus

public EventBus(@Nonnull
                Registry<reactor.fn.Consumer<? extends Event<?>>> consumerRegistry,
                @Nullable
                reactor.core.Dispatcher dispatcher,
                @Nullable
                Router router,
                @Nullable
                reactor.fn.Consumer<java.lang.Throwable> dispatchErrorHandler,
                @Nullable
                reactor.fn.Consumer<java.lang.Throwable> uncaughtErrorHandler)

Create a new Reactor that uses the given dispatacher and eventRouter.

Parameters:

dispatcher - The Dispatcher to use. May be null in which case a new synchronous dispatcher is used.

router - The Router used to route events to Consumers. May be null in which case the default event router that broadcasts events to all of the registered consumers that match the notification key and does not perform any type conversion will be used.

consumerRegistry - The Registry to be used to match Selector and dispatch to Consumer.

Method Detail

config

public static EventBusSpec config()

Create a new EventBusSpec to configure a Reactor.

Returns:

The Reactor spec

create

public static EventBus create()

Create a new synchronous EventBus

Returns:

A new EventBus

create

public static EventBus create(reactor.Environment env)

Create a new EventBus using the given Environment.

Parameters:

env - The Environment to use.

Returns:

A new EventBus

create

public static EventBus create(reactor.core.Dispatcher dispatcher)

Create a new EventBus using the given Dispatcher.

Parameters:

dispatcher - The name of the Dispatcher to use.

Returns:

A new EventBus

create

public static EventBus create(reactor.Environment env,
                              java.lang.String dispatcher)

Create a new EventBus using the given Environment and dispatcher name.

Parameters:

env - The Environment to use.

dispatcher - The name of the Dispatcher to use.

Returns:

A new EventBus

create

public static EventBus create(reactor.Environment env,
                              reactor.core.Dispatcher dispatcher)

Create a new EventBus using the given Environment and Dispatcher.

Parameters:

env - The Environment to use.

dispatcher - The Dispatcher to use.

Returns:

A new EventBus

getId

public java.util.UUID getId()

Get the unique, time-used UUID of this Reactor.

Returns:

The UUID of this Reactor.

getConsumerRegistry

public Registry<reactor.fn.Consumer<? extends Event<?>>> getConsumerRegistry()

Get the Registry is use to maintain the Consumers currently listening for events on this Reactor.

Returns:

The Registry in use.

getDispatcher

public reactor.core.Dispatcher getDispatcher()

Get the Dispatcher currently in use.

Returns:

The Dispatcher.

getRouter

public Router getRouter()

Get the Router used to route events to Consumers.

Returns:

The Router.

getDispatchErrorHandler

public reactor.fn.Consumer<java.lang.Throwable> getDispatchErrorHandler()

getUncaughtErrorHandler

public reactor.fn.Consumer<java.lang.Throwable> getUncaughtErrorHandler()

respondsToKey

public boolean respondsToKey(java.lang.Object key)

Description copied from interface: Bus

Are there any Registrations with Selectors that match the given key.

Specified by:

respondsToKey in interface Bus<Event<?>>

Parameters:

key - The key to be matched by Selectors

Returns:

true if there are any matching Registrations, false otherwise

on

public <T extends Event<?>> Registration<reactor.fn.Consumer<? extends Event<?>>> on(Selector selector,
                                                                                     reactor.fn.Consumer<T> consumer)

Description copied from interface: Bus

Register a Consumer to be triggered when a notification matches the given Selector.

Specified by:

on in interface Bus<Event<?>>

Parameters:

selector - The Selector to be used for matching

consumer - The Consumer to be triggered

Returns:

A Registration object that allows the caller to interact with the given mapping

on

public org.reactivestreams.Publisher<? extends Event<?>> on(Selector broadcastSelector)

Attach a Publisher to the Bus with the specified Selector.

Parameters:

broadcastSelector - the Selector/Object tuple to listen to

Returns:

a new Publisher

Since:

2.0

notify

public EventBus notify(java.lang.Object key,
                       Event<?> ev)

Description copied from interface: Bus

Notify this component that an Event is ready to be processed.

Specified by:

notify in interface Bus<Event<?>>

Parameters:

key - The key to be matched by Selectors

ev - The Event

Returns:

this

notify

public final EventBus notify(@Nonnull
                             org.reactivestreams.Publisher<?> source,
                             @Nonnull
                             java.lang.Object key)

Pass values accepted by this Stream into the given Bus, notifying with the given key.

Parameters:

key - the key to notify on

source - the Publisher to consume

Returns:

new Stream

Since:

1.1, 2.0

notify

public final <T> EventBus notify(@Nonnull
                                 org.reactivestreams.Publisher<? extends T> source,
                                 @Nonnull
                                 reactor.fn.Function<? super T,?> keyMapper)

Pass values accepted by this Stream into the given Bus, notifying with the given key.

Parameters:

source - the Publisher to consume

keyMapper - the key function mapping each incoming data to a key to notify on

Returns:

new Stream

Since:

2.0

receive

public <T extends Event<?>,V> Registration<reactor.fn.Consumer<? extends Event<?>>> receive(Selector sel,
                                                                                            reactor.fn.Function<T,V> fn)

Assign a Function to receive an Event and produce a reply of the given type.

Parameters:

sel - The Selector to be used for matching

fn - The transformative Function to call to receive an Event

Returns:

A Registration object that allows the caller to interact with the given mapping

notify

public EventBus notify(java.lang.Object key,
                       reactor.fn.Supplier<? extends Event<?>> supplier)

Notify this component that the given Supplier can provide an event that's ready to be processed.

Parameters:

key - The key to be matched by Selectors

supplier - The Supplier that will provide the actual Event

Returns:

this

notify

public EventBus notify(java.lang.Object key)

Notify this component that the consumers registered with a Selector that matches the key should be triggered with a null input argument.

Parameters:

key - The key to be matched by Selectors

Returns:

this

send

public EventBus send(java.lang.Object key,
                     Event<?> ev)

Notify this component of the given Event and register an internal Consumer that will take the output of a previously-registered Function and respond using the key set on the Event's replyTo property.

Parameters:

key - The key to be matched by Selectors

ev - The Event

Returns:

this

send

public EventBus send(java.lang.Object key,
                     reactor.fn.Supplier<? extends Event<?>> supplier)

Notify this component that the given Supplier will provide an Event and register an internal Consumer that will take the output of a previously-registered Function and respond using the key set on the Event's replyTo property.

Parameters:

key - The key to be matched by Selectors

supplier - The Supplier that will provide the actual Event instance

Returns:

this

send

public EventBus send(java.lang.Object key,
                     Event<?> ev,
                     Bus replyTo)

Notify this component of the given Event and register an internal Consumer that will take the output of a previously-registered Function and respond to the key set on the Event's replyTo property and will call the notify method on the given Bus.

Parameters:

key - The key to be matched by Selectors

ev - The Event

replyTo - The Bus on which to invoke the notify method

Returns:

this

send

public EventBus send(java.lang.Object key,
                     reactor.fn.Supplier<? extends Event<?>> supplier,
                     Bus replyTo)

Notify this component that the given Supplier will provide an Event and register an internal Consumer that will take the output of a previously-registered Function and respond to the key set on the Event's replyTo property and will call the notify method on the given Bus.

Parameters:

key - The key to be matched by Selectors

supplier - The Supplier that will provide the actual Event instance

replyTo - The Bus on which to invoke the notify method

Returns:

this

sendAndReceive

public <T extends Event<?>> EventBus sendAndReceive(java.lang.Object key,
                                                    Event<?> event,
                                                    reactor.fn.Consumer<T> reply)

Register the given Consumer on an anonymous Selector and set the given event's replyTo property to the corresponding anonymous key, then register the consumer to receive replies from the Function assigned to handle the given key.

Parameters:

key - The key to be matched by Selectors

event - The event to notify.

reply - The consumer to register as a reply handler.

Returns:

this

sendAndReceive

public <T extends Event<?>> EventBus sendAndReceive(java.lang.Object key,
                                                    reactor.fn.Supplier<? extends Event<?>> supplier,
                                                    reactor.fn.Consumer<T> reply)

Register the given Consumer on an anonymous Selector and set the event's replyTo property to the corresponding anonymous key, then register the consumer to receive replies from the Function assigned to handle the given key.

Parameters:

key - The key to be matched by Selectors

supplier - The supplier to supply the event.

reply - The consumer to register as a reply handler.

Returns:

this

prepare

public <T> reactor.fn.Consumer<Event<T>> prepare(java.lang.Object key)

Create an optimized path for publishing notifications to the given key.

Parameters:

key - The key to be matched by Selectors

Returns:

a Consumer to invoke with the Events to publish

schedule

public <T> void schedule(reactor.fn.Consumer<T> consumer,
                         T data)

Schedule an arbitrary Consumer to be executed on the current Reactor Dispatcher, passing the given .

Type Parameters:

T - The type of the data.

Parameters:

consumer - The Consumer to invoke.

data - The data to pass to the consumer.

accept

public void accept(Event<?> event)

Specified by:

accept in interface reactor.fn.Consumer<Event<?>>