Package reactor.core.publisher

@NullMarked package reactor.core.publisher

Provide main Reactive APIs in Flux and Mono, as well as various helper classes, interfaces used in the composition API, variants of Flux and operator-building utilities.

Flux

A typed N-elements or zero sequence Publisher with core reactive extensions.

Mono

A typed one-element at most sequence Publisher with core reactive extensions.

Author:

Stephane Maldini

Related Packages

Package	Description
reactor.core	Core components of the framework supporting extensions to the Reactive Stream programming model.
reactor.core.observability
reactor.core.scheduler	Scheduler contract and static registry and factory methods in Schedulers.

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.
BufferOverflowStrategy	Strategies to deal with overflow of a buffer during backpressure buffering.
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>	A decorating Flux Publisher that exposes Flux API over an arbitrary Publisher.
FluxProcessor<IN,OUT>	Deprecated. Processors will be removed in 3.5.
FluxSink<T>	Wrapper API around a downstream Subscriber for emitting any number of next signals followed by zero or one onError/onComplete.
FluxSink.OverflowStrategy	Enumeration for backpressure handling.
GroupedFlux<K,V>	Represents a sequence of events which has an associated key.
Hooks	A set of overridable lifecycle hooks that can be used for cross-cutting added behavior on Flux/Mono operators.
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>	A decorating Mono Publisher that exposes Mono API over an arbitrary Publisher Useful to create operators which return a Mono.
MonoProcessor<O>	Deprecated. Processors will be removed in 3.5.
MonoSink<T>	Wrapper API around an actual downstream Subscriber for emitting nothing, a single value or an error (mutually exclusive).
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().
Signal<T>	A domain representation of a Reactive Stream signal.
SignalType	Reactive Stream signal types
SinkOneSerialized<T>
Sinks	Sinks are constructs through which Reactive Streams signals can be programmatically pushed, with Flux or Mono semantics.
Sinks.EmissionException	An exception representing a failed Sinks.EmitResult.
Sinks.EmitFailureHandler	A handler supporting the emit API (eg.
Sinks.EmitResult	Represents the immediate result of an emit attempt (eg.
Sinks.Empty<T>	A base interface for standalone Sinks with complete-or-fail semantics.
Sinks.Many<T>	A base interface for standalone Sinks with Flux semantics.
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	Instead of unsafe flavors of Sinks.Many, this spec provides Sinks.ManyWithUpstream implementations.
Sinks.MulticastReplaySpec	Provides multicast with history/replay capacity : 1 sink, N Subscriber
Sinks.MulticastSpec	Provides multicast : 1 sink, N Subscriber
Sinks.One<T>	A base interface for standalone Sinks with Mono semantics.
Sinks.RootSpec	Provides a choice of Sinks.One/Sinks.Empty factories and further specs for Sinks.Many.
Sinks.UnicastSpec	Provides unicast: 1 sink, 1 Subscriber
SynchronousSink<T>	Interface to produce synchronously "one signal" to an underlying Subscriber.
Timed<T>
UnicastProcessor<T>	Deprecated. to be removed in 3.5, prefer clear cut usage of Sinks through variations under Sinks.many().unicast().