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).
|
Signal<T> |
A domain representation of a Reactive Stream signal.
|
Sinks.EmitFailureHandler |
A handler supporting the emit API (eg.
|
Sinks.Empty<T> |
A base interface for standalone
Sinks with complete-or-fail semantics. |
Sinks.Many<T> | |
Sinks.ManySpec |
Provides
Sinks.Many specs for sinks which can emit multiple elements |
Sinks.ManyWithUpstream<T> |
A
Sinks.Many which additionally allows being subscribed to an upstream Publisher ,
which is an advanced pattern requiring external synchronization. |
Sinks.ManyWithUpstreamUnsafeSpec | |
Sinks.MulticastReplaySpec |
Provides multicast with history/replay capacity : 1 sink, N
Subscriber |
Sinks.MulticastSpec |
Provides multicast : 1 sink, N
Subscriber |
Sinks.One<T> | |
Sinks.RootSpec | |
Sinks.UnicastSpec |
Provides unicast: 1 sink, 1
Subscriber |
SynchronousSink<T> |
Interface to produce synchronously "one signal" to an underlying
Subscriber . |
Timed<T> |
Class | Description |
---|---|
BaseSubscriber<T> |
A simple base class for a
Subscriber implementation that lets the user
perform a BaseSubscriber.request(long) and BaseSubscriber.cancel() on it directly. |
ConnectableFlux<T> |
The abstract base class for connectable publishers that let subscribers pile up
before they connect to their data source.
|
DirectProcessor<T> | Deprecated
To be removed in 3.5, prefer clear cut usage of
Sinks . |
EmitterProcessor<T> | Deprecated
To be removed in 3.5.
|
Flux<T> |
A Reactive Streams
Publisher with rx operators that emits 0 to N elements, and then completes
(successfully or with an error). |
FluxOperator<I,O> | |
FluxProcessor<IN,OUT> | Deprecated
Processors will be removed in 3.5.
|
GroupedFlux<K,V> |
Represents a sequence of events which has an associated key.
|
Hooks | |
Mono<T> |
A Reactive Streams
Publisher with basic rx operators that emits at most one item via the
onNext signal then terminates with an onComplete signal (successful Mono,
with or without value), or only emits a single onError signal (failed Mono). |
MonoOperator<I,O> | |
MonoProcessor<O> | Deprecated
Processors will be removed in 3.5.
|
Operators |
A 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 might also 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.
|
ParallelFlux<T> |
A ParallelFlux publishes to an array of Subscribers, in parallel 'rails' (or
'groups' ). |
ReplayProcessor<T> | Deprecated
To be removed in 3.5, prefer clear cut usage of
Sinks through
variations under Sinks.many().replay() . |
SinkOneSerialized<T> | |
Sinks | |
UnicastProcessor<T> | Deprecated
to be removed in 3.5, prefer clear cut usage of
Sinks through
variations under Sinks.many().unicast() . |
Enum | Description |
---|---|
BufferOverflowStrategy |
Strategies to deal with overflow of a buffer during
backpressure buffering . |
FluxSink.OverflowStrategy |
Enumeration for backpressure handling.
|
SignalType |
Reactive Stream signal types
|
Sinks.EmitResult |
Represents the immediate result of an emit attempt (eg.
|
Exception | Description |
---|---|
Sinks.EmissionException |
An exception representing a
failed Sinks.EmitResult . |
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
DirectProcessor
FluxProcessor
itself offers factories to build arbitrary Processor