public class ReplayingEventDispatcher extends Object implements EventDispatcher
Allows configuring the main FluxProcessor backend, its publishing Scheduler for thread affinity, the
ReplayProcessor for storage and a Predicate to determine which events should be stored for replay.
While under no subscribers, this event dispatcher will store all incoming events that match the given filter to its replay processor. Once the first subscriber has connected, the given stop trigger is subscribed and once it terminates or is cancelled, no further events will be stored for replay, until all existing subscribers have disconnected.
During the replay window, late subscribers benefit from all events that are pushed to this dispatcher, therefore enabling scenarios where very early events are not missed despite connecting late.
| Modifier and Type | Class and Description |
|---|---|
static class |
ReplayingEventDispatcher.Builder
A builder to create
EventDispatcher instances. |
DEFAULT_EVENT_SCHEDULER| Constructor and Description |
|---|
ReplayingEventDispatcher(FluxProcessor<Event,Event> eventProcessor,
FluxSink.OverflowStrategy overflowStrategy,
Scheduler eventScheduler,
ReplayProcessor<Event> replayEventProcessor,
FluxSink.OverflowStrategy replayEventOverflowStrategy,
Predicate<Event> replayEventFilter,
Scheduler timedTaskScheduler,
Publisher<?> stopReplayingTrigger)
Creates a new event dispatcher that is able to retain events to replay to multiple late subscribers, using the
given parameters.
|
| Modifier and Type | Method and Description |
|---|---|
static ReplayingEventDispatcher.Builder |
builder()
Return a new builder for
ReplayingEventDispatcher. |
static EventDispatcher |
create()
Return a new default
ReplayingEventDispatcher. |
<E extends Event> |
on(Class<E> eventClass)
|
void |
publish(Event event)
Publishes an
Event to the dispatcher. |
void |
shutdown()
Signal that this event dispatcher must terminate and release its resources.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitbuffering, replaying, replayingWithSize, replayingWithTimeout, withEarliestEvents, withLatestEventspublic ReplayingEventDispatcher(FluxProcessor<Event,Event> eventProcessor, FluxSink.OverflowStrategy overflowStrategy, Scheduler eventScheduler, ReplayProcessor<Event> replayEventProcessor, FluxSink.OverflowStrategy replayEventOverflowStrategy, Predicate<Event> replayEventFilter, Scheduler timedTaskScheduler, Publisher<?> stopReplayingTrigger)
eventProcessor - a processor used to bridge gateway events to the dispatcher connected subscribersoverflowStrategy - an overflow strategy, see FluxSink.OverflowStrategy for the available strategieseventScheduler - a Scheduler to ensure a certain thread model on each published signalreplayEventProcessor - a processor used to store events while no subscribers are connected and will be
forwarded to all late subscribersreplayEventOverflowStrategy - an overflow strategy while pushing events to the replay processorreplayEventFilter - a filter used to decide whether an Event should be published to the
replay processortimedTaskScheduler - a time-capable Scheduler used to detect whether all events have replayed to
a subscriberstopReplayingTrigger - a trigger Publisher that is subscribed upon the first subscriber connects
to this dispatcher. Upon completion, error or cancellation, the replaying window will be closed until all
subscribers have disconnectedpublic <E extends Event> Flux<E> on(Class<E> eventClass)
EventDispatcherFlux with elements of the given Event type.
Note: Errors occurring while processing events will terminate your sequence. See Reactive Streams Spec explaining this behavior.
A recommended pattern to use this method is wrapping your code that may throw exceptions within a flatMap block and use Mono.onErrorResume(Function), Flux.onErrorResume(Function) or
equivalent methods to maintain the sequence active:
client.getEventDispatcher().on(MessageCreateEvent.class)
.flatMap(event -> myCodeThatMightThrow(event)
.onErrorResume(error -> {
// log and then discard the error to keep the sequence alive
log.error("Failed to handle event!", error);
return Mono.empty();
}))
.subscribe();
For more alternatives to handling errors, please see Error Handling wiki page.
on in interface EventDispatcherE - the type of the event classeventClass - the event class to obtain events fromFlux with the requested eventspublic void publish(Event event)
EventDispatcherEvent to the dispatcher. Might throw an unchecked exception if the dispatcher can't
handle this event.publish in interface EventDispatcherevent - the Event to publishpublic void shutdown()
EventDispatchershutdown in interface EventDispatcherpublic static EventDispatcher create()
ReplayingEventDispatcher.public static ReplayingEventDispatcher.Builder builder()
ReplayingEventDispatcher.builder in interface EventDispatcher