ReplayProcessor (reactor-3)

java.lang.Object
- reactor.core.publisher.Flux<OUT>
- - reactor.core.publisher.FluxProcessor<T,T>
  - - reactor.core.publisher.ReplayProcessor<T>

类型参数:

T - the value type

所有已实现的接口:

org.reactivestreams.Processor<T,T>, org.reactivestreams.Publisher<T>, org.reactivestreams.Subscriber<T>, CorePublisher<T>, CoreSubscriber<T>, Disposable, Fuseable, Scannable

已过时。
To be removed in 3.5, prefer clear cut usage of Sinks through variations under Sinks.many().replay().
```
@Deprecated
public final class ReplayProcessor<T>
extends FluxProcessor<T,T>
implements Fuseable
```
Replays all or the last N items to Subscribers.

嵌套类概要
- 从接口继承的嵌套类/接口 reactor.core.Fuseable
  Fuseable.ConditionalSubscriber<T>, Fuseable.QueueSubscription<T>, Fuseable.ScalarCallable<T>, Fuseable.SynchronousSubscription<T>
- 从接口继承的嵌套类/接口 reactor.core.Scannable
  Scannable.Attr<T>
- 从接口继承的嵌套类/接口 reactor.core.Disposable
  Disposable.Composite, Disposable.Swap

字段概要
- 从接口继承的字段 reactor.core.Fuseable
  ANY, ASYNC, NONE, SYNC, THREAD_BARRIER
- 从接口继承的字段 reactor.core.Scannable
  OPERATOR_NAME_UNRELATED_WORDS_PATTERN

方法概要

所有方法静态方法实例方法具体方法默认方法已过时的方法
限定符和类型	方法和说明
`Flux<T>`	`asFlux()` 已过时。 Return a `Flux` view of this sink.
`static <T> ReplayProcessor<T>`	`cacheLast()` 已过时。 use `Sinks.many().replay().latest()` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <T> ReplayProcessor<T>`	`cacheLastOrDefault(T value)` 已过时。 use `Sinks.many().replay().latestOrDefault(value)` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <E> ReplayProcessor<E>`	`create()` 已过时。 use `Sinks.many().replay().all()` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <E> ReplayProcessor<E>`	`create(int historySize)` 已过时。 use `Sinks.many().replay().limit(historySize)` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <E> ReplayProcessor<E>`	`create(int historySize, boolean unbounded)` 已过时。 use `Sinks.many().replay().limit(historySize)` for bounded cases (`unbounded == false`) or `Sinks.many().replay().all(bufferSize)` otherwise (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <T> ReplayProcessor<T>`	`createSizeAndTimeout(int size, java.time.Duration maxAge)` 已过时。 use `Sinks.many().replay().limit(size, maxAge)` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <T> ReplayProcessor<T>`	`createSizeAndTimeout(int size, java.time.Duration maxAge, Scheduler scheduler)` 已过时。 use `Sinks.many().replay().limit(size, maxAge, scheduler)` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <T> ReplayProcessor<T>`	`createTimeout(java.time.Duration maxAge)` 已过时。 use `Sinks.many().replay().limit(maxAge)` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`static <T> ReplayProcessor<T>`	`createTimeout(java.time.Duration maxAge, Scheduler scheduler)` 已过时。 use `Sinks.many().replay().limit(maxAge, scheduler)` (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
`Context`	`currentContext()` 已过时。 Request a `Context` from dependent components which can include downstream operators during subscribing or a terminal `Subscriber`.
`int`	`currentSubscriberCount()` 已过时。 Get how many `Subscribers` are currently subscribed to the sink.
`long`	`downstreamCount()` 已过时。 Return the number of active `Subscriber` or -1 if untracked.
`default void`	`emitComplete(Sinks.EmitFailureHandler failureHandler)` A simplified attempt at completing via the `Sinks.Many.tryEmitComplete()` API, generating an `onComplete` signal.
`default void`	`emitError(java.lang.Throwable error, Sinks.EmitFailureHandler failureHandler)` A simplified attempt at failing the sequence via the `Sinks.Many.tryEmitError(Throwable)` API, generating an `onError` signal.
`default void`	`emitNext(T value, Sinks.EmitFailureHandler failureHandler)` A simplified attempt at emitting a non-null element via the `Sinks.Many.tryEmitNext(Object)` API, generating an `onNext` signal.
`java.lang.Throwable`	`getError()` 已过时。 Current error if any, default to null
`int`	`getPrefetch()` 已过时。 The prefetch configuration of the `Flux`
`java.util.stream.Stream<? extends Scannable>`	`inners()` 已过时。 Return a `Stream` of referenced inners (flatmap, multicast etc)
`boolean`	`isTerminated()` 已过时。 Has this upstream finished or "completed" / "failed" ?
`void`	`onComplete()` 已过时。
`void`	`onError(java.lang.Throwable throwable)` 已过时。
`void`	`onNext(T t)` 已过时。
`void`	`onSubscribe(org.reactivestreams.Subscription s)` 已过时。 Implementors should initialize any state used by `Subscriber.onNext(Object)` before calling `Subscription.request(long)`.
`java.lang.Object`	`scanUnsafe(Scannable.Attr key)` 已过时。 This method is used internally by components to define their key-value mappings in a single place.
`void`	`subscribe(CoreSubscriber<? super T> actual)` 已过时。 An internal `Publisher.subscribe(Subscriber)` that will bypass `Hooks.onLastOperator(Function)` pointcut.
`Sinks.EmitResult`	`tryEmitComplete()` 已过时。 Try to terminate the sequence successfully, generating an `onComplete` signal.
`Sinks.EmitResult`	`tryEmitError(java.lang.Throwable t)` 已过时。 Try to fail the sequence, generating an `onError` signal.
`Sinks.EmitResult`	`tryEmitNext(T t)` 已过时。 Try emitting a non-null element, generating an `onNext` signal.

从类继承的方法 reactor.core.publisher.FluxProcessor
dispose, getBufferSize, hasCompleted, hasDownstreams, hasError, isSerialized, serialize, sink, sink, switchOnNext, wrap

从类继承的方法 reactor.core.publisher.Flux
all, any, as, blockFirst, blockFirst, blockLast, blockLast, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, buffer, bufferTimeout, bufferTimeout, bufferTimeout, bufferTimeout, bufferUntil, bufferUntil, bufferUntilChanged, bufferUntilChanged, bufferUntilChanged, bufferWhen, bufferWhen, bufferWhile, cache, cache, cache, cache, cache, cache, cancelOn, cast, checkpoint, checkpoint, checkpoint, collect, collect, collectList, collectMap, collectMap, collectMap, collectMultimap, collectMultimap, collectMultimap, collectSortedList, collectSortedList, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, combineLatest, concat, concat, concat, concat, concatDelayError, concatDelayError, concatDelayError, concatDelayError, concatMap, concatMap, concatMapDelayError, concatMapDelayError, concatMapDelayError, concatMapIterable, concatMapIterable, concatWith, concatWithValues, contextCapture, contextWrite, contextWrite, count, create, create, defaultIfEmpty, defer, deferContextual, delayElements, delayElements, delaySequence, delaySequence, delaySubscription, delaySubscription, delaySubscription, delayUntil, dematerialize, distinct, distinct, distinct, distinct, distinctUntilChanged, distinctUntilChanged, distinctUntilChanged, doAfterTerminate, doFinally, doFirst, doOnCancel, doOnComplete, doOnDiscard, doOnEach, doOnError, doOnError, doOnError, doOnNext, doOnRequest, doOnSubscribe, doOnTerminate, elapsed, elapsed, elementAt, elementAt, empty, error, error, error, expand, expand, expandDeep, expandDeep, filter, filterWhen, filterWhen, first, first, firstWithSignal, firstWithSignal, firstWithValue, firstWithValue, flatMap, flatMap, flatMap, flatMap, flatMapDelayError, flatMapIterable, flatMapIterable, flatMapSequential, flatMapSequential, flatMapSequential, flatMapSequentialDelayError, from, fromArray, fromIterable, fromStream, fromStream, generate, generate, generate, groupBy, groupBy, groupBy, groupBy, groupJoin, handle, hasElement, hasElements, hide, ignoreElements, index, index, interval, interval, interval, interval, join, just, just, last, last, limitRate, limitRate, limitRequest, log, log, log, log, log, log, map, mapNotNull, materialize, merge, merge, merge, merge, merge, merge, mergeComparing, mergeComparing, mergeComparing, mergeComparingDelayError, mergeComparingWith, mergeDelayError, mergeOrdered, mergeOrdered, mergeOrdered, mergeOrderedWith, mergePriority, mergePriority, mergePriority, mergePriorityDelayError, mergeSequential, mergeSequential, mergeSequential, mergeSequential, mergeSequential, mergeSequential, mergeSequentialDelayError, mergeSequentialDelayError, mergeSequentialDelayError, mergeWith, metrics, name, never, next, ofType, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureBuffer, onBackpressureDrop, onBackpressureDrop, onBackpressureError, onBackpressureLatest, onErrorComplete, onErrorComplete, onErrorComplete, onErrorContinue, onErrorContinue, onErrorContinue, onErrorMap, onErrorMap, onErrorMap, onErrorResume, onErrorResume, onErrorResume, onErrorReturn, onErrorReturn, onErrorReturn, onErrorStop, onTerminateDetach, or, parallel, parallel, parallel, publish, publish, publish, publish, publishNext, publishOn, publishOn, publishOn, push, push, range, reduce, reduce, reduceWith, repeat, repeat, repeat, repeat, repeatWhen, replay, replay, replay, replay, replay, replay, retry, retry, retryWhen, sample, sample, sampleFirst, sampleFirst, sampleTimeout, sampleTimeout, scan, scan, scanWith, share, shareNext, single, single, singleOrEmpty, skip, skip, skip, skipLast, skipUntil, skipUntilOther, skipWhile, sort, sort, startWith, startWith, startWith, subscribe, subscribe, subscribe, subscribe, subscribe, subscribe, subscribe, subscribeOn, subscribeOn, subscribeWith, switchIfEmpty, switchMap, switchMap, switchOnFirst, switchOnFirst, switchOnNext, switchOnNext, tag, take, take, take, take, takeLast, takeUntil, takeUntilOther, takeWhile, tap, tap, tap, then, then, thenEmpty, thenMany, timed, timed, timeout, timeout, timeout, timeout, timeout, timeout, timeout, timestamp, timestamp, toIterable, toIterable, toIterable, toStream, toStream, toString, transform, transformDeferred, transformDeferredContextual, using, using, usingWhen, usingWhen, window, window, window, window, window, window, window, windowTimeout, windowTimeout, windowTimeout, windowTimeout, windowUntil, windowUntil, windowUntil, windowUntilChanged, windowUntilChanged, windowUntilChanged, windowWhen, windowWhile, windowWhile, withLatestFrom, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zip, zipWith, zipWith, zipWith, zipWith, zipWithIterable, zipWithIterable

从类继承的方法 java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

从接口继承的方法 reactor.core.Fuseable
fusionModeName, fusionModeName

从接口继承的方法 reactor.core.Scannable
actuals, from, isScanAvailable, name, parents, scan, scanOrDefault, stepName, steps, tags, tagsDeduplicated

从接口继承的方法 org.reactivestreams.Publisher
subscribe

从接口继承的方法 reactor.core.Disposable
isDisposed

- 方法详细资料
  - cacheLast
```
@Deprecated
public static <T> ReplayProcessor<T> cacheLast()
```
    已过时。 use Sinks.many().replay().latest() (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Create a ReplayProcessor that caches the last element it has pushed, replaying it to late subscribers. This is a buffer-based ReplayProcessor with a history size of 1.
    
    类型参数:
    
    T - the type of the pushed elements
    
    返回:
    
    a new ReplayProcessor that replays its last pushed element to each new Subscriber
  - cacheLastOrDefault
```
@Deprecated
public static <T> ReplayProcessor<T> cacheLastOrDefault(@Nullable
                                                                     T value)
```
    已过时。 use Sinks.many().replay().latestOrDefault(value) (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Create a ReplayProcessor that caches the last element it has pushed, replaying it to late subscribers. If a Subscriber comes in before any value has been pushed, then the defaultValue is emitted instead. This is a buffer-based ReplayProcessor with a history size of 1.
    
    类型参数:
    
    T - the type of the pushed elements
    
    参数:
    
    value - a default value to start the sequence with in case nothing has been cached yet.
    
    返回:
    
    a new ReplayProcessor that replays its last pushed element to each new Subscriber, or a default one if nothing was pushed yet
  - create
```
@Deprecated
public static <E> ReplayProcessor<E> create()
```
    已过时。 use Sinks.many().replay().all() (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Create a new ReplayProcessor that replays an unbounded number of elements, using a default internal Queue.
    
    类型参数:
    
    E - the type of the pushed elements
    
    返回:
    
    a new ReplayProcessor that replays the whole history to each new Subscriber.
  - create
```
@Deprecated
public static <E> ReplayProcessor<E> create(int historySize)
```
    已过时。 use Sinks.many().replay().limit(historySize) (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Create a new ReplayProcessor that replays up to historySize elements.
    
    类型参数:
    
    E - the type of the pushed elements
    
    参数:
    
    historySize - the backlog size, ie. maximum items retained for replay.
    
    返回:
    
    a new ReplayProcessor that replays a limited history to each new Subscriber.
  - create
```
@Deprecated
public static <E> ReplayProcessor<E> create(int historySize,
                                                         boolean unbounded)
```
    已过时。 use Sinks.many().replay().limit(historySize) for bounded cases (unbounded == false) or Sinks.many().replay().all(bufferSize) otherwise (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Create a new ReplayProcessor that either replay all the elements or a limited amount of elements depending on the unbounded parameter.
    
    类型参数:
    
    E - the type of the pushed elements
    
    参数:
    
    historySize - maximum items retained if bounded, or initial link size if unbounded
    
    unbounded - true if "unlimited" data store must be supplied
    
    返回:
    
    a new ReplayProcessor that replays the whole history to each new Subscriber if configured as unbounded, a limited history otherwise.
  - createTimeout
```
@Deprecated
public static <T> ReplayProcessor<T> createTimeout(java.time.Duration maxAge)
```
    已过时。 use Sinks.many().replay().limit(maxAge) (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Creates a time-bounded replay processor.
    In this setting, the ReplayProcessor internally tags each observed item with a timestamp value supplied by the Schedulers.parallel() and keeps only those whose age is less than the supplied time value converted to milliseconds. For example, an item arrives at T=0 and the max age is set to 5; at T>=5 this first item is then evicted by any subsequent item or termination signal, leaving the buffer empty.
    Once the processor is terminated, subscribers subscribing to it will receive items that remained in the buffer after the terminal signal, regardless of their age.
    If an subscriber subscribes while the ReplayProcessor is active, it will observe only those items from within the buffer that have an age less than the specified time, and each item observed thereafter, even if the buffer evicts items due to the time constraint in the mean time. In other words, once an subscriber subscribes, it observes items without gaps in the sequence except for any outdated items at the beginning of the sequence.
    
    类型参数:
    
    T - the type of items observed and emitted by the Processor
    
    参数:
    
    maxAge - the maximum age of the contained items
    
    返回:
    
    a new ReplayProcessor that replays elements based on their age.
  - createTimeout
```
@Deprecated
public static <T> ReplayProcessor<T> createTimeout(java.time.Duration maxAge,
                                                                Scheduler scheduler)
```
    已过时。 use Sinks.many().replay().limit(maxAge, scheduler) (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Creates a time-bounded replay processor.
    In this setting, the ReplayProcessor internally tags each observed item with a timestamp value supplied by the Scheduler and keeps only those whose age is less than the supplied time value converted to milliseconds. For example, an item arrives at T=0 and the max age is set to 5; at T>=5 this first item is then evicted by any subsequent item or termination signal, leaving the buffer empty.
    Once the processor is terminated, subscribers subscribing to it will receive items that remained in the buffer after the terminal signal, regardless of their age.
    If an subscriber subscribes while the ReplayProcessor is active, it will observe only those items from within the buffer that have an age less than the specified time, and each item observed thereafter, even if the buffer evicts items due to the time constraint in the mean time. In other words, once an subscriber subscribes, it observes items without gaps in the sequence except for any outdated items at the beginning of the sequence.
    
    类型参数:
    
    T - the type of items observed and emitted by the Processor
    
    参数:
    
    maxAge - the maximum age of the contained items
    
    返回:
    
    a new ReplayProcessor that replays elements based on their age.
  - createSizeAndTimeout
```
@Deprecated
public static <T> ReplayProcessor<T> createSizeAndTimeout(int size,
                                                                       java.time.Duration maxAge)
```
    已过时。 use Sinks.many().replay().limit(size, maxAge) (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Creates a time- and size-bounded replay processor.
    In this setting, the ReplayProcessor internally tags each received item with a timestamp value supplied by the Schedulers.parallel() and holds at most size items in its internal buffer. It evicts items from the start of the buffer if their age becomes less-than or equal to the supplied age in milliseconds or the buffer reaches its size limit.
    When subscribers subscribe to a terminated ReplayProcessor, they observe the items that remained in the buffer after the terminal signal, regardless of their age, but at most size items.
    If an subscriber subscribes while the ReplayProcessor is active, it will observe only those items from within the buffer that have age less than the specified time and each subsequent item, even if the buffer evicts items due to the time constraint in the mean time. In other words, once an subscriber subscribes, it observes items without gaps in the sequence except for the outdated items at the beginning of the sequence.
    
    类型参数:
    
    T - the type of items observed and emitted by the Processor
    
    参数:
    
    maxAge - the maximum age of the contained items
    
    size - the maximum number of buffered items
    
    返回:
    
    a new ReplayProcessor that replay up to size elements, but will evict them from its history based on their age.
  - createSizeAndTimeout
```
@Deprecated
public static <T> ReplayProcessor<T> createSizeAndTimeout(int size,
                                                                       java.time.Duration maxAge,
                                                                       Scheduler scheduler)
```
    已过时。 use Sinks.many().replay().limit(size, maxAge, scheduler) (or the unsafe variant if you're sure about external synchronization). To be removed in 3.5.
    
    Creates a time- and size-bounded replay processor.
    In this setting, the ReplayProcessor internally tags each received item with a timestamp value supplied by the Scheduler and holds at most size items in its internal buffer. It evicts items from the start of the buffer if their age becomes less-than or equal to the supplied age in milliseconds or the buffer reaches its size limit.
    When subscribers subscribe to a terminated ReplayProcessor, they observe the items that remained in the buffer after the terminal signal, regardless of their age, but at most size items.
    If an subscriber subscribes while the ReplayProcessor is active, it will observe only those items from within the buffer that have age less than the specified time and each subsequent item, even if the buffer evicts items due to the time constraint in the mean time. In other words, once an subscriber subscribes, it observes items without gaps in the sequence except for the outdated items at the beginning of the sequence.
    
    类型参数:
    
    T - the type of items observed and emitted by the Processor
    
    参数:
    
    maxAge - the maximum age of the contained items in milliseconds
    
    size - the maximum number of buffered items
    
    scheduler - the Scheduler that provides the current time
    
    返回:
    
    a new ReplayProcessor that replay up to size elements, but will evict them from its history based on their age.
  - subscribe
```
public void subscribe(CoreSubscriber<? super T> actual)
```
    已过时。
    
    从类复制的说明: Flux
    
    An internal Publisher.subscribe(Subscriber) that will bypass Hooks.onLastOperator(Function) pointcut.
    In addition to behave as expected by Publisher.subscribe(Subscriber) in a controlled manner, it supports direct subscribe-time Context passing.
    
    指定者:
    
    subscribe 在接口中 CorePublisher<T>
    
    指定者:
    
    subscribe 在类中 Flux<T>
    
    参数:
    
    actual - the Subscriber interested into the published sequence
    
    另请参阅:
    
    Flux.subscribe(Subscriber)
  - getError
```
@Nullable
public java.lang.Throwable getError()
```
    已过时。
    
    从类复制的说明: FluxProcessor
    
    Current error if any, default to null
    
    覆盖:
    
    getError 在类中 FluxProcessor<T,T>
    
    返回:
    
    Current error if any, default to null
  - scanUnsafe
```
@Nullable
public java.lang.Object scanUnsafe(Scannable.Attr key)
```
    已过时。
    
    从接口复制的说明: Scannable
    
    This method is used internally by components to define their key-value mappings in a single place. Although it is ignoring the generic type of the Scannable.Attr key, implementors should take care to return values of the correct type, and return null if no specific value is available.
    For public consumption of attributes, prefer using Scannable.scan(Attr), which will return a typed value and fall back to the key's default if the component didn't define any mapping.
    
    指定者:
    
    scanUnsafe 在接口中 Scannable
    
    覆盖:
    
    scanUnsafe 在类中 FluxProcessor<T,T>
    
    参数:
    
    key - a Scannable.Attr to resolve for the component.
    
    返回:
    
    the value associated to the key for that specific component, or null if none.
  - inners
```
public java.util.stream.Stream<? extends Scannable> inners()
```
    已过时。
    
    从接口复制的说明: Scannable
    
    Return a Stream of referenced inners (flatmap, multicast etc)
    
    指定者:
    
    inners 在接口中 Scannable
    
    覆盖:
    
    inners 在类中 FluxProcessor<T,T>
    
    返回:
    
    a Stream of referenced inners (flatmap, multicast etc)
  - downstreamCount
```
public long downstreamCount()
```
    已过时。
    
    从类复制的说明: FluxProcessor
    
    Return the number of active Subscriber or -1 if untracked.
    
    覆盖:
    
    downstreamCount 在类中 FluxProcessor<T,T>
    
    返回:
    
    the number of active Subscriber or -1 if untracked
  - isTerminated
```
public boolean isTerminated()
```
    已过时。
    
    从类复制的说明: FluxProcessor
    
    Has this upstream finished or "completed" / "failed" ?
    
    覆盖:
    
    isTerminated 在类中 FluxProcessor<T,T>
    
    返回:
    
    has this upstream finished or "completed" / "failed" ?
  - onSubscribe
```
public void onSubscribe(org.reactivestreams.Subscription s)
```
    已过时。
    
    从接口复制的说明: CoreSubscriber
    
    Implementors should initialize any state used by Subscriber.onNext(Object) before calling Subscription.request(long). Should further onNext related state modification occur, thread-safety will be required.
    Note that an invalid request <= 0 will not produce an onError and will simply be ignored or reported through a debug-enabled Logger.
    
    指定者:
    
    onSubscribe 在接口中 org.reactivestreams.Subscriber<T>
    
    指定者:
    
    onSubscribe 在接口中 CoreSubscriber<T>
  - currentContext
```
public Context currentContext()
```
    已过时。
    
    从接口复制的说明: CoreSubscriber
    
    Request a Context from dependent components which can include downstream operators during subscribing or a terminal Subscriber.
    
    指定者:
    
    currentContext 在接口中 CoreSubscriber<T>
    
    覆盖:
    
    currentContext 在类中 FluxProcessor<T,T>
    
    返回:
    
    a resolved context or Context.empty()
  - getPrefetch
```
public int getPrefetch()
```
    已过时。
    
    从类复制的说明: Flux
    
    The prefetch configuration of the Flux
    
    覆盖:
    
    getPrefetch 在类中 Flux<T>
    
    返回:
    
    the prefetch configuration of the Flux, -1 if unspecified
  - onComplete
```
public void onComplete()
```
    已过时。
    
    指定者:
    
    onComplete 在接口中 org.reactivestreams.Subscriber<T>
  - tryEmitComplete
```
public Sinks.EmitResult tryEmitComplete()
```
    已过时。
    
    从接口复制的说明: Sinks.Many
    
    Try to terminate the sequence successfully, generating an onComplete signal. The result of the attempt is represented as an Sinks.EmitResult, which possibly indicates error cases.
    See the list of failure Sinks.EmitResult in #emitComplete(EmitFailureHandler) javadoc for an example of how each of these can be dealt with, to decide if the emit API would be a good enough fit instead.
    
    返回:
    
    an Sinks.EmitResult, which should be checked to distinguish different possible failures
    
    另请参阅:
    
    Subscriber.onComplete()
  - onError
```
public void onError(java.lang.Throwable throwable)
```
    已过时。
    
    指定者:
    
    onError 在接口中 org.reactivestreams.Subscriber<T>
  - tryEmitError
```
public Sinks.EmitResult tryEmitError(java.lang.Throwable t)
```
    已过时。
    
    从接口复制的说明: Sinks.Many
    
    Try to fail the sequence, generating an onError signal. The result of the attempt is represented as an Sinks.EmitResult, which possibly indicates error cases.
    See the list of failure Sinks.EmitResult in #emitError(Throwable, EmitFailureHandler) javadoc for an example of how each of these can be dealt with, to decide if the emit API would be a good enough fit instead.
    
    参数:
    
    t - the exception to signal, not null
    
    返回:
    
    an Sinks.EmitResult, which should be checked to distinguish different possible failures
    
    另请参阅:
    
    Subscriber.onError(Throwable)
  - onNext
```
public void onNext(T t)
```
    已过时。
    
    指定者:
    
    onNext 在接口中 org.reactivestreams.Subscriber<T>
  - tryEmitNext
```
public Sinks.EmitResult tryEmitNext(T t)
```
    已过时。
    
    从接口复制的说明: Sinks.Many
    
    Try emitting a non-null element, generating an onNext signal. The result of the attempt is represented as an Sinks.EmitResult, which possibly indicates error cases.
    See the list of failure Sinks.EmitResult in #emitNext(Object, EmitFailureHandler) javadoc for an example of how each of these can be dealt with, to decide if the emit API would be a good enough fit instead.
    Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, ...).
    
    参数:
    
    t - the value to emit, not null
    
    返回:
    
    an Sinks.EmitResult, which should be checked to distinguish different possible failures
    
    另请参阅:
    
    Subscriber.onNext(Object)
  - currentSubscriberCount
```
public int currentSubscriberCount()
```
    已过时。
    
    从接口复制的说明: Sinks.Many
    
    Get how many Subscribers are currently subscribed to the sink.
    This is a best effort peek at the sink state, and a subsequent attempt at emitting to the sink might still return Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER where relevant. (generally in Sinks.Many.tryEmitNext(Object)). Request (and lack thereof) isn't taken into account, all registered subscribers are counted.
    
    返回:
    
    the number of subscribers at the time of invocation
  - asFlux
```
public Flux<T> asFlux()
```
    已过时。
    
    从接口复制的说明: Sinks.Many
    
    Return a Flux view of this sink. Every call returns the same instance.
    
    返回:
    
    the Flux view associated to this Sinks.Many
  - emitNext
```
public void emitNext(T value,
                     Sinks.EmitFailureHandler failureHandler)
```
    从接口复制的说明: Sinks.Many
    A simplified attempt at emitting a non-null element via the Sinks.Many.tryEmitNext(Object) API, generating an onNext signal. If the result of the attempt is not a success, implementations SHOULD retry the Sinks.Many.tryEmitNext(Object) call IF the provided Sinks.EmitFailureHandler returns true. Otherwise, failures are dealt with in a predefined way that might depend on the actual sink implementation (see below for the vanilla reactor-core behavior).
    Generally, Sinks.Many.tryEmitNext(Object) is preferable since it allows a custom handling of error cases, although this implies checking the returned Sinks.EmitResult and correctly acting on it. This API is intended as a good default for convenience.
    When the Sinks.EmitResult is not a success, vanilla reactor-core operators have the following behavior:
    - Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER: no particular handling. should ideally discard the value but at that point there's no Subscriber from which to get a contextual discard handler.
    - Sinks.EmitResult.FAIL_OVERFLOW: discard the value (Operators.onDiscard(Object, Context)) then call Sinks.Many.emitError(Throwable, Sinks.EmitFailureHandler) with a Exceptions.failWithOverflow(String) exception.
    - Sinks.EmitResult.FAIL_CANCELLED: discard the value (Operators.onDiscard(Object, Context)).
    - Sinks.EmitResult.FAIL_TERMINATED: drop the value (Operators.onNextDropped(Object, Context)).
    - Sinks.EmitResult.FAIL_NON_SERIALIZED: throw an Sinks.EmissionException mentioning RS spec rule 1.3. Note that Sinks.unsafe() never trigger this result. It would be possible for an Sinks.EmitFailureHandler to busy-loop and optimistically wait for the contention to disappear to avoid this case for safe sinks...
    Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, a Sinks.EmitResult.FAIL_NON_SERIALIZED as described above, ...).
    指定者:
    
    emitNext 在接口中 Sinks.Many<T>
    
    参数:
    
    value - the value to emit, not null
    
    failureHandler - the failure handler that allows retrying failed Sinks.EmitResult.
    
    另请参阅:
    
    Sinks.Many.tryEmitNext(Object), Subscriber.onNext(Object)
  - emitComplete
```
public void emitComplete(Sinks.EmitFailureHandler failureHandler)
```
    从接口复制的说明: Sinks.Many
    A simplified attempt at completing via the Sinks.Many.tryEmitComplete() API, generating an onComplete signal. If the result of the attempt is not a success, implementations SHOULD retry the Sinks.Many.tryEmitComplete() call IF the provided Sinks.EmitFailureHandler returns true. Otherwise, failures are dealt with in a predefined way that might depend on the actual sink implementation (see below for the vanilla reactor-core behavior).
    Generally, Sinks.Many.tryEmitComplete() is preferable since it allows a custom handling of error cases, although this implies checking the returned Sinks.EmitResult and correctly acting on it. This API is intended as a good default for convenience.
    When the Sinks.EmitResult is not a success, vanilla reactor-core operators have the following behavior:
    - Sinks.EmitResult.FAIL_OVERFLOW: irrelevant as onComplete is not driven by backpressure.
    - Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER: the completion can be ignored since nobody is listening. Note that most vanilla reactor sinks never trigger this result for onComplete, replaying the terminal signal to later subscribers instead (to the exception of Sinks.UnicastSpec.onBackpressureError()).
    - Sinks.EmitResult.FAIL_CANCELLED: the completion can be ignored since nobody is interested.
    - Sinks.EmitResult.FAIL_TERMINATED: the extra completion is basically ignored since there was a previous termination signal, but there is nothing interesting to log.
    - Sinks.EmitResult.FAIL_NON_SERIALIZED: throw an Sinks.EmissionException mentioning RS spec rule 1.3. Note that Sinks.unsafe() never trigger this result. It would be possible for an Sinks.EmitFailureHandler to busy-loop and optimistically wait for the contention to disappear to avoid this case in safe sinks...
    Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, a Sinks.EmitResult.FAIL_NON_SERIALIZED as described above, ...).
    指定者:
    
    emitComplete 在接口中 Sinks.Many<T>
    
    参数:
    
    failureHandler - the failure handler that allows retrying failed Sinks.EmitResult.
    
    另请参阅:
    
    Sinks.Many.tryEmitComplete(), Subscriber.onComplete()
  - emitError
```
public void emitError(java.lang.Throwable error,
                      Sinks.EmitFailureHandler failureHandler)
```
    从接口复制的说明: Sinks.Many
    A simplified attempt at failing the sequence via the Sinks.Many.tryEmitError(Throwable) API, generating an onError signal. If the result of the attempt is not a success, implementations SHOULD retry the Sinks.Many.tryEmitError(Throwable) call IF the provided Sinks.EmitFailureHandler returns true. Otherwise, failures are dealt with in a predefined way that might depend on the actual sink implementation (see below for the vanilla reactor-core behavior).
    Generally, Sinks.Many.tryEmitError(Throwable) is preferable since it allows a custom handling of error cases, although this implies checking the returned Sinks.EmitResult and correctly acting on it. This API is intended as a good default for convenience.
    When the Sinks.EmitResult is not a success, vanilla reactor-core operators have the following behavior:
    - Sinks.EmitResult.FAIL_OVERFLOW: irrelevant as onError is not driven by backpressure.
    - Sinks.EmitResult.FAIL_ZERO_SUBSCRIBER: the error is ignored since nobody is listening. Note that most vanilla reactor sinks never trigger this result for onError, replaying the terminal signal to later subscribers instead (to the exception of Sinks.UnicastSpec.onBackpressureError()).
    - Sinks.EmitResult.FAIL_CANCELLED: the error can be ignored since nobody is interested.
    - Sinks.EmitResult.FAIL_TERMINATED: the error unexpectedly follows another terminal signal, so it is dropped via Operators.onErrorDropped(Throwable, Context).
    - Sinks.EmitResult.FAIL_NON_SERIALIZED: throw an Sinks.EmissionException mentioning RS spec rule 1.3. Note that Sinks.unsafe() never trigger this result. It would be possible for an Sinks.EmitFailureHandler to busy-loop and optimistically wait for the contention to disappear to avoid this case in safe sinks...
    Might throw an unchecked exception as a last resort (eg. in case of a fatal error downstream which cannot be propagated to any asynchronous handler, a bubbling exception, a Sinks.EmitResult.FAIL_NON_SERIALIZED as described above, ...).
    指定者:
    
    emitError 在接口中 Sinks.Many<T>
    
    参数:
    
    error - the exception to signal, not null
    
    failureHandler - the failure handler that allows retrying failed Sinks.EmitResult.
    
    另请参阅:
    
    Sinks.Many.tryEmitError(Throwable), Subscriber.onError(Throwable)

类 ReplayProcessor<T>

嵌套类概要

从接口继承的嵌套类/接口 reactor.core.Fuseable

从接口继承的嵌套类/接口 reactor.core.Scannable

从接口继承的嵌套类/接口 reactor.core.Disposable

字段概要

从接口继承的字段 reactor.core.Fuseable

从接口继承的字段 reactor.core.Scannable

方法概要

从类继承的方法 reactor.core.publisher.FluxProcessor

从类继承的方法 reactor.core.publisher.Flux

从类继承的方法 java.lang.Object

从接口继承的方法 reactor.core.Fuseable

从接口继承的方法 reactor.core.Scannable

从接口继承的方法 org.reactivestreams.Publisher

从接口继承的方法 reactor.core.Disposable

方法详细资料

cacheLast

cacheLastOrDefault

create

create

create

createTimeout

createTimeout

createSizeAndTimeout

createSizeAndTimeout

subscribe

getError

scanUnsafe

inners

downstreamCount

isTerminated

onSubscribe

currentContext

getPrefetch

onComplete

tryEmitComplete

onError

tryEmitError

onNext

tryEmitNext

currentSubscriberCount

asFlux

emitNext

emitComplete

emitError