All Classes and Interfaces
Class
Description
A simple base class for a
Subscriber implementation that lets the user
perform a BaseSubscriber.request(long) and BaseSubscriber.cancel() on it directly.Strategies to deal with overflow of a buffer during
backpressure buffering.The abstract base class for connectable publishers that let subscribers pile up
before they connect to their data source.
A key/value store that is propagated between components such as operators via the
context protocol.
A read-only view of a collection of key/value pairs that is propagated between components
such as operators via the context protocol.
A
CoreSubscriber aware publisher.A
Context aware subscriber which has relaxed rules for §1.3 and §3.9
compared to the original Subscriber from Reactive Streams.A default implementation of a
SignalListener with all the handlers no-op.Deprecated.
Indicates that a task or resource can be cancelled/disposed.
A container of
Disposable that is itself Disposable.A
Disposable container that allows updating/replacing its inner Disposable
atomically and with respect of disposing the container itself.A support class that offers factory methods for implementations of the specialized
Disposable sub-interfaces (Disposable.Composite,
Disposable.Swap).Deprecated.
To be removed in 3.5.
Global Reactor Core Exception handling and utils to operate on.
A
Throwable that wraps the actual cause delivered via
Subscriber.onError(Throwable) in case of
Publishers that themselves emit items of type
Publisher.A Reactive Streams
Publisher with rx operators that emits 0 to N elements, and then completes
(successfully or with an error).Deprecated.
Processors will be removed in 3.5.
Wrapper API around a downstream Subscriber for emitting any number of
next signals followed by zero or one onError/onComplete.
Enumeration for backpressure handling.
A micro API for stream fusion, in particular marks producers that support a
Fuseable.QueueSubscription.A subscriber variant that can immediately tell if it consumed
the value or not, directly allowing a new value to be sent if
it didn't.
Support contract for queue-fusion based optimizations on subscriptions.
Marker interface indicating that the target can return a value or null,
otherwise fail immediately and thus a viable target for assembly-time
optimizations.
Base class for synchronous sources which have fixed size and can
emit their items in a pull fashion, thus avoiding the request-accounting
overhead in many cases.
Represents a sequence of events which has an associated key.
Signifies that the annotated functionality is currently in a developmental phase.
Convert a Java 9+ Flow.Publisher to/from a Reactive Streams
Publisher.Logger interface designed for internal Reactor usage.
Expose static methods to get a logger depending on the environment.
Deprecated.
prefer using the new reactor-core-micrometer module Micrometer entrypoint.
Deprecated.
Prefer using the reactor-core-micrometer module and configuring it using the Micrometer entrypoint.
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).Deprecated.
Processors will be removed in 3.5.
Wrapper API around an actual downstream Subscriber
for emitting nothing, a single value or an error (mutually exclusive).
A marker interface that is detected on
Threads while executing Reactor
blocking APIs, resulting in these calls throwing an exception.Deprecated.
Use
NonNull instead.Deprecated.
Use
NullMarked instead.Deprecated.
Use
Nullable instead.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.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.
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.
A ParallelFlux publishes to an array of Subscribers, in parallel 'rails' (or
'groups').Queue utilities and suppliers for 1-producer/1-consumer ready queues adapted for
various given capacities.
A
ContextAccessor to enable reading values from a Reactor
ContextView and writing values to Context.A repeat strategy that allows fine-grained control over repeating behavior in
Flux.repeatWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>, ? extends org.reactivestreams.Publisher<?>>) and
Mono.repeatWhen(java.util.function.Function<reactor.core.publisher.Flux<java.lang.Long>, ? extends org.reactivestreams.Publisher<?>>).State information associated with each repeat signal, used in repeat strategies.
Deprecated.
To be removed in 3.5, prefer clear cut usage of
Sinks through
variations under Sinks.many().replay().Base abstract class for a strategy to decide when to retry given a companion
Flux of Retry.RetrySignal,
for use with Flux.retryWhen(Retry) and Mono.retryWhen(Retry).State used in
Flux.retryWhen(Retry) and Mono.retryWhen(Retry),
providing the Throwable that caused the source to fail as well as counters keeping track of retries.A
Retry strategy based on exponential backoffs, with configurable features.A simple count-based
Retry strategy with configurable features.A Scannable component exposes state in a non strictly memory consistent way and
results should be understood as best-effort hint of the underlying state.
Base class for
Scannable attributes, which all can define a meaningful
default.An
Enum enumerating the different styles an operator can run : their Enum.ordinal() reflects the level of confidence
in their running modeProvides an abstract asynchronous boundary to operators.
A worker representing an asynchronous boundary that executes tasks.
Public factory hook to override Schedulers behavior globally
It is also
Disposable in case you don't want to restore the live SchedulersA domain representation of a Reactive Stream signal.
A factory for per-subscription
SignalListener, exposing the ability to generate common state at publisher level
from the source Publisher.Reactive Stream signal types
An exception representing a
failed Sinks.EmitResult.A handler supporting the emit API (eg.
Represents the immediate result of an emit attempt (eg.
A base interface for standalone
Sinks with complete-or-fail semantics.Provides
Sinks.Many specs for sinks which can emit multiple elementsA
Sinks.Many which additionally allows being subscribed to an upstream Publisher,
which is an advanced pattern requiring external synchronization.Provides multicast with history/replay capacity : 1 sink, N
SubscriberProvides multicast : 1 sink, N
SubscriberProvides unicast: 1 sink, 1
SubscriberInterface to produce synchronously "one signal" to an underlying
Subscriber.A tuple that holds two non-null values.
A tuple that holds three non-null values.
A tuple that holds four non-null values
A tuple that holds five non-null values
A tuple that holds six values
A tuple that holds seven non-null values
A tuple that holds eight values
A Tuples is an immutable
Collection of objects, each of which can be of an arbitrary type.Deprecated.
to be removed in 3.5, prefer clear cut usage of
Sinks through
variations under Sinks.many().unicast().
Sinks.