See: Description
| Interface | Description |
|---|---|
| FluxSink<T> |
Wrapper API around a downstream Subscriber for emitting any number of
next signals followed by zero or one onError/onComplete.
|
| MonoSink<T> |
Wrapper API around an actual downstream Subscriber
for emitting nothing, a single value or an error (mutually exclusive).
|
| SynchronousSink<T> |
Interface to generate signals to a bridged
Subscriber. |
| Class | Description |
|---|---|
| BlockingSink<E> |
A "hot" sequence source to decorate any
Subscriber or Processor. |
| ConnectableFlux<T> |
The abstract base class for connectable publishers that let subscribers pile up
before they connect to their data source.
|
| DirectProcessor<T> |
Dispatches onNext, onError and onComplete signals to zero-to-many Subscribers.
|
| EmitterProcessor<T> |
An implementation of a RingBuffer backed message-passing Processor implementing publish-subscribe with
synchronous (thread-stealing and happen-before interactions) drain loops.
|
| Flux<T> |
A Reactive Streams
Publisher with rx operators that emits 0 to N elements, and then completes
(successfully or with an error). |
| FluxProcessor<IN,OUT> |
A base processor that exposes
Flux API for Processor. |
| FluxSource<I,O> |
A connecting
Flux Publisher (right-to-left from a composition chain perspective) |
| GroupedFlux<K,V> |
Represents a sequence of events with an associated key.
|
| Hooks |
Allows for various lifecycle override
|
| Hooks.OperatorHook<T> |
Filtering and Handling options to apply on a given
Publisher |
| Mono<T> |
A Reactive Streams
Publisher with basic rx operators that completes successfully by emitting an element, or
with an error. |
| MonoProcessor<O> |
A
MonoProcessor is a Mono extension that implements stateful semantics. |
| MonoSource<I,O> | |
| Operators |
An helper to support "Operator" writing, handle noop subscriptions, validate request
size and
to cap concurrent additive operations to Long.MAX_VALUE,
which is generic to
Subscription.request(long) handling. |
| Operators.DeferredSubscription |
Base class for Subscribers that will receive their Subscriptions at any time yet
they need to be cancelled or requested at any time.
|
| Operators.MonoSubscriber<I,O> |
A Subscriber/Subscription barrier that holds a single value at most and properly gates asynchronous behaviors
resulting from concurrent request or cancel and onXXX signals.
|
| Operators.SubscriberAdapter<I,O> |
A
Subscriber with an asymetric typed wrapped subscriber. |
| ParallelFlux<T> |
Abstract base class for Parallel publishers that take an array of Subscribers.
|
| ReplayProcessor<T> |
Replays all or the last N items to Subscribers.
|
| Signal<T> |
A domain representation of a Reactive Stream signal.
|
| TopicProcessor<E> |
An implementation of a RingBuffer backed message-passing Processor implementing publish-subscribe with async event
loops.
|
| UnicastProcessor<T> |
A Processor implementation that takes a custom queue and allows
only a single subscriber.
|
| WorkQueueProcessor<E> |
An implementation of a RingBuffer backed message-passing Processor implementing work-queue distribution with
async event loops.
|
| Enum | Description |
|---|---|
| BlockingSink.Emission |
An acknowledgement signal returned by
BlockingSink.emit(E). |
| FluxSink.OverflowStrategy |
Enumeration for backpressure handling.
|
| SignalType |
Reactive Stream notification type
|
Flux, Mono composition
API and Processor implementations
Publisher with core reactive extensions.
Publisher with core reactive extensions.
Processor extending FluxProcessor are available:
EmitterProcessor,
ReplayProcessor,
UnicastProcessor and
DirectProcessorTopicProcessorWorkQueueProcessorFluxProcessor itself offers factories to build arbitrary Processor