Package reactor.core.publisher

Class Sinks

java.lang.Object

reactor.core.publisher.Sinks

public final class Sinks
extends Object

Sinks are constructs through which Reactive Streams signals can be programmatically pushed, with Flux or Mono semantics. These standalone sinks expose tryEmit methods that return an Sinks.EmitResult enum, allowing to atomically fail in case the attempted signal is inconsistent with the spec and/or the state of the sink.

This class exposes a collection of (Sinks.Many builders and Sinks.One factories. Unless constructed through the unsafe() spec, these sinks are thread safe in the sense that they will detect concurrent access and fail fast on one of the attempts. unsafe() sinks on the other hand are expected to be externally synchronized (typically by being called from within a Reactive Streams-compliant context, like a Subscriber or an operator, which means it is ok to remove the overhead of detecting concurrent access from the sink itself).

Author:

Simon Baslé, Stephane Maldini

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static final class	Sinks.EmissionException	An exception representing a failed Sinks.EmitResult.
static interface	Sinks.EmitFailureHandler	A handler supporting the emit API (eg.
static enum	Sinks.EmitResult	Represents the immediate result of an emit attempt (eg.
static interface	Sinks.Empty<T>	A base interface for standalone Sinks with complete-or-fail semantics.
static interface	Sinks.Many<T>	A base interface for standalone Sinks with Flux semantics.
static interface	Sinks.ManySpec	Provides Sinks.Many specs for sinks which can emit multiple elements
static interface	Sinks.ManyWithUpstream<T>	A Sinks.Many which additionally allows being subscribed to an upstream Publisher, which is an advanced pattern requiring external synchronization.
static interface	Sinks.ManyWithUpstreamUnsafeSpec	Instead of unsafe flavors of Sinks.Many, this spec provides Sinks.ManyWithUpstream implementations.
static interface	Sinks.MulticastReplaySpec	Provides multicast with history/replay capacity : 1 sink, N Subscriber
static interface	Sinks.MulticastSpec	Provides multicast : 1 sink, N Subscriber
static interface	Sinks.One<T>	A base interface for standalone Sinks with Mono semantics.
static interface	Sinks.RootSpec	Provides a choice of Sinks.One/Sinks.Empty factories and further specs for Sinks.Many.
static interface	Sinks.UnicastSpec	Provides unicast: 1 sink, 1 Subscriber

Method Summary

Modifier and Type	Method	Description
static <T> Sinks.Empty<T>	empty()	A Sinks.Empty which exclusively produces one terminal signal: error or complete.
static Sinks.ManySpec	many()	Help building Sinks.Many sinks that will broadcast multiple signals to one or more Subscriber.
static <T> Sinks.One<T>	one()	A Sinks.One that works like a conceptual promise: it can be completed with or without a value at any time, but only once.
static Sinks.RootSpec	unsafe()	Return a root spec for more advanced use cases such as building operators.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details

empty

public static <T> Sinks.Empty<T> empty()

A Sinks.Empty which exclusively produces one terminal signal: error or complete. It has the following characteristics:

• Multicast
• Backpressure : this sink does not need any demand since it can only signal error or completion
• Replaying: Replay the terminal signal (error or complete).

Use Sinks.Empty.asMono() to expose the Mono view of the sink to downstream consumers.

Returns:

a new Sinks.Empty

See Also:

• Sinks.RootSpec.empty()

one

public static <T> Sinks.One<T> one()

A Sinks.One that works like a conceptual promise: it can be completed with or without a value at any time, but only once. This completion is replayed to late subscribers. Calling Sinks.One.tryEmitValue(Object) (or Sinks.One.emitValue(Object, Sinks.EmitFailureHandler)) is enough and will implicitly produce a Subscriber.onComplete() signal as well.

Use Sinks.Empty.asMono() to expose the Mono view of the sink to downstream consumers.

Returns:

a new Sinks.One

See Also:

• Sinks.RootSpec.one()

many

public static Sinks.ManySpec many()

Help building Sinks.Many sinks that will broadcast multiple signals to one or more Subscriber.

Use Sinks.Many.asFlux() to expose the Flux view of the sink to the downstream consumers.

Returns:

Sinks.ManySpec

See Also:

• Sinks.RootSpec.many()

unsafe

public static Sinks.RootSpec unsafe()

Return a root spec for more advanced use cases such as building operators. Unsafe Sinks.Many, Sinks.One and Sinks.Empty are not serialized nor thread safe, which implies they MUST be externally synchronized so as to respect the Reactive Streams specification. This can typically be the case when the sinks are being called from within a Reactive Streams-compliant context, like a Subscriber or an operator. In turn, this allows the sinks to have less overhead, since they don't care to detect concurrent access anymore.

Returns:

Sinks.RootSpec