Deprecated List (Reactor Core 3.0.7.RELEASE)

Deprecated Interfaces
Interface and Description
reactor.core.Cancellation use `Disposable`, will be removed in 3.1.0
reactor.core.Loopback This internal introspection interface has been removed in favor of centralized, attribute-based `Scannable`.
reactor.core.MultiProducer This internal introspection interface has been removed in favor of centralized, attribute-based `Scannable`.
reactor.core.MultiReceiver This internal introspection interface has been removed in favor of centralized, attribute-based `Scannable`.
reactor.core.Producer This internal introspection interface has been removed in favor of centralized, attribute-based `Scannable`.
reactor.core.Receiver This internal introspection interface has been removed in favor of centralized, attribute-based `Scannable`.
reactor.core.scheduler.TimedScheduler all methods of this interface have been moved to `Scheduler` and reactor-core implementations should now all be time-capable. Will be removed in 3.1.0.
reactor.core.scheduler.TimedScheduler.TimedWorker all methods of this interface have been moved to `Scheduler.Worker` and reactor-core implementations should now all be time-capable. Will be removed in 3.1.0.
reactor.core.Trackable This internal introspection interface has been removed in favor of centralized, attribute-based `Scannable`.

Deprecated Classes
Class and Description
reactor.core.publisher.BlockingSink Will be removed in 3.1.0. There is no general replacement for BlockingSink in 3.1 but its major user `FluxProcessor` now offers `FluxProcessor.sink()` that directly exposes `FluxSink`. In general the blocking publishing methods here can be directly addressed via the behavior of `FluxProcessor.sink()` in a safer way. There is also `FluxSink.onRequest(LongConsumer)` available to now proactively deal with backpressure even in the context of producing to an arbitrary processor.
reactor.core.publisher.Operators.SubscriberAdapter use `BaseSubscriber`

Deprecated Fields
Field and Description

reactor.core.Exceptions.CANCEL_STACKTRACE
Cancel stacktrace is always turned on given the exceptional frequency and the critical info it can provide

Deprecated Fields
Field and Description
reactor.core.Exceptions.CANCEL_STACKTRACE Cancel stacktrace is always turned on given the exceptional frequency and the critical info it can provide

Deprecated Methods
Method and Description
reactor.core.publisher.Operators.addAndGet(AtomicLong, long) This util is neither used by Core nor consistent with the other `addAndGet` methods present which use `AtomicLongFieldUpdater`. In an effort to keep Operators API consistent, this util will not be supported anymore and users need to port over its body under their app code.
reactor.core.publisher.Flux.blockFirstMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.blockLastMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.blockMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.buffer(int, Duration) use `Flux.bufferTimeout(int, Duration)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.buffer(int, Duration, Supplier<C>) use `Flux.bufferTimeout(int, Duration, Supplier)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.buffer(Publisher<U>, Function<? super U, ? extends Publisher<V>>) will be removed in 3.1.0. Use `Flux.bufferWhen(Publisher, Function)` instead.
reactor.core.publisher.Flux.buffer(Publisher<U>, Function<? super U, ? extends Publisher<V>>, Supplier<C>) will be removed in 3.1.0. Use `Flux.bufferWhen(Publisher, Function, Supplier)` instead.
reactor.core.publisher.Flux.bufferMillis(int, long) use `Flux.bufferTimeout(int, Duration)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferMillis(int, long, TimedScheduler) use `Flux.bufferTimeout(int, Duration, Scheduler)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferMillis(int, long, TimedScheduler, Supplier<C>) use `Flux.bufferTimeout(int, Duration, Scheduler, Supplier)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferMillis(long, long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferMillis(long, long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferTimeoutMillis(int, long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferTimeoutMillis(int, long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.bufferTimeoutMillis(int, long, TimedScheduler, Supplier<C>) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.EmitterProcessor.connect()
reactor.core.publisher.ReplayProcessor.connect()
reactor.core.publisher.FluxProcessor.connect() Will be removed in 3.1.0. `Subscriber.onSubscribe(Subscription)` is not required by default anymore and brings no benefit given the private scope of the Subscription.
reactor.core.publisher.FluxProcessor.connectSink() Will be removed in 3.1.0, use `FluxProcessor.sink()`
reactor.core.publisher.FluxProcessor.connectSink(boolean) Will be removed in 3.1.0, use `FluxProcessor.sink()`
reactor.core.publisher.EmitterProcessor.create(int, int) concurrency in EmitterProcessor will be removed in 3.1.0
reactor.core.publisher.EmitterProcessor.create(int, int, boolean) concurrency in EmitterProcessor will be removed in 3.1.0
reactor.core.publisher.ReplayProcessor.createSizeAndTimeoutMillis(int, long, TimedScheduler) use `ReplayProcessor.createSizeAndTimeout(int, Duration, Scheduler)`
reactor.core.publisher.ReplayProcessor.createTimeoutMillis(long, TimedScheduler) use `ReplayProcessor.createTimeout(Duration, Scheduler)`
reactor.core.publisher.Flux.delay(Duration) will be replaced by `Flux.delayElements(Duration)` in 3.1.0
reactor.core.publisher.Mono.delayElementMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.delayElementMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.delayElementsMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.delayElementsMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.delayMillis(long) will be replaced by `Flux.delayElements(Duration)` in 3.1.0
reactor.core.publisher.Mono.delayMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.delayMillis(long, TimedScheduler) will be replaced by `Flux.delayElements(Duration, Scheduler)` in 3.1.0
reactor.core.publisher.Mono.delayMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.delaySubscriptionMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.delaySubscriptionMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.delaySubscriptionMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.delaySubscriptionMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.FluxProcessor.downstreams()
reactor.core.publisher.Flux.elapsed(TimedScheduler) use `Flux.elapsed(Scheduler)`
reactor.core.publisher.Mono.elapsed(TimedScheduler) use `Mono.elapsed(Scheduler)`
reactor.core.publisher.Mono.flatMap(Function<? super T, ? extends Publisher<? extends R>>) will change signature and behavior in 3.1 to reflect current `Mono.then(Function)`. flatMap will be renamed `Mono.flatMapMany(Function)`, so use that instead.
reactor.core.publisher.Mono.flatMap(Function<? super T, ? extends Publisher<? extends R>>, Function<Throwable, ? extends Publisher<? extends R>>, Supplier<? extends Publisher<? extends R>>) will change signature and behavior in 3.1 to reflect current `Mono.then(Function)`. flatMap will be renamed `Mono.flatMapMany(Function, Function, Supplier)`, so use that instead.
reactor.core.publisher.Flux.flatMap(Function<? super T, ? extends Publisher<? extends V>>, boolean, int, int) use `Flux.flatMap(Function, int, int)` or `Flux.flatMapDelayError(Function, int, int)` instead, will be removed in 3.1.0.
reactor.core.publisher.Flux.flatMapSequential(Function<? super T, ? extends Publisher<? extends R>>, boolean, int, int) use `Flux.flatMapSequential(Function, int, int)` or `Flux.flatMapSequentialDelayError(Function, int, int)` instead, will be removed in 3.1.0.
reactor.core.publisher.ReplayProcessor.getBufferSize()
reactor.core.publisher.FluxProcessor.getCapacity()
reactor.core.publisher.Flux.intervalMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.intervalMillis(long, long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.intervalMillis(long, long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.intervalMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.ParallelFlux.isOrdered() This accessor was initially exposed to introspect the internal ordering scenario for parallel rails. In effect reactor 3.0 and 3.1 only offer non ordered merge at the end and therefore this should always returns false;
reactor.core.publisher.EmitterProcessor.isStarted()
reactor.core.publisher.ReplayProcessor.isStarted()
reactor.core.publisher.UnicastProcessor.isStarted()
reactor.core.publisher.FluxProcessor.isStarted() Will be removed in 3.1.0. Processor are stateful and started by default which means you can onNext them directly
reactor.core.publisher.BaseSubscriber.isTerminated() use `BaseSubscriber.isDisposed()`
reactor.core.publisher.Flux.mapError(Class<E>, Function<? super E, ? extends Throwable>) use `Flux.onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.mapError(Class<E>, Function<? super E, ? extends Throwable>) use `Mono.onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.mapError(Function<? super Throwable, ? extends Throwable>) use `Flux.onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.mapError(Function<Throwable, ? extends Throwable>) use `Mono.onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.mapError(Predicate<? super Throwable>, Function<? super Throwable, ? extends Throwable>) use `Flux.onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.mapError(Predicate<? super Throwable>, Function<? super Throwable, ? extends Throwable>) use `Mono.onErrorMap(java.util.function.Function<? super java.lang.Throwable, ? extends java.lang.Throwable>)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.merge(int, boolean, Publisher<? extends I>...) use `Flux.merge(int, Publisher[])` or `Flux.mergeDelayError(int, Publisher[])` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.mergeSequential(int, boolean, Publisher<? extends I>...) use `Flux.mergeSequential(int, Publisher[])` or `Flux.mergeSequentialDelayError(int, Publisher[])` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.mergeSequential(Iterable<? extends Publisher<? extends I>>, boolean, int, int) use `Flux.mergeSequential(Iterable, int, int)` or `Flux.mergeSequentialDelayError(Iterable, int, int)` instead, will be removed in 3.1.0.
reactor.core.publisher.Flux.mergeSequential(Publisher<? extends Publisher<? extends T>>, boolean, int, int) use `Flux.mergeSequential(Publisher, int, int)` or `Flux.mergeSequentialDelayError(Publisher, int, int)` instead, will be removed in 3.1.0.
reactor.core.scheduler.Schedulers.newTimer(String) in 3.0.6 and from 3.1 onwards, all Scheduler support time. `Schedulers.newSingle(String)` is a direct equivalent if required.
reactor.core.scheduler.Schedulers.newTimer(String, boolean) in 3.0.6 and from 3.1 onwards, all Scheduler support time. `Schedulers.newSingle(String, boolean)` is a direct equivalent if required.
reactor.core.scheduler.Schedulers.newTimer(ThreadFactory) in 3.0.6 and from 3.1 onwards, all Scheduler support time. `Schedulers.newSingle(ThreadFactory)` is a direct equivalent if required.
reactor.core.scheduler.TimedScheduler.TimedWorker.now(TimeUnit) will be removed with the class in 3.1.0, where it is expected that only Scheduler.now is used.
reactor.core.publisher.Flux.onErrorResumeWith(Class<E>, Function<? super E, ? extends Publisher<? extends T>>) use `Flux.onErrorResume(Class, Function)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.onErrorResumeWith(Function<? super Throwable, ? extends Publisher<? extends T>>) use `Flux.onErrorResume(Function)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.onErrorResumeWith(Predicate<? super Throwable>, Function<? super Throwable, ? extends Publisher<? extends T>>) use `Flux.onErrorResume(Predicate, Function)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.otherwise(Class<E>, Function<? super E, ? extends Mono<? extends T>>) Use `Mono.onErrorResume(Class, Function)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.otherwise(Function<? super Throwable, ? extends Mono<? extends T>>) Use `Mono.onErrorResume(Function)`} instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.otherwise(Predicate<? super Throwable>, Function<? super Throwable, ? extends Mono<? extends T>>) Use `Mono.onErrorResume(Predicate, Function)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.otherwiseIfEmpty(Mono<? extends T>) Use `Mono.switchIfEmpty(reactor.core.publisher.Mono<? extends T>)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.otherwiseReturn(Class<E>, T) use `Mono.onErrorReturn(Class, Object)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.otherwiseReturn(Predicate<? super Throwable>, T) use `Mono.onErrorReturn(Predicate, Object)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Mono.otherwiseReturn(T) use `Mono.onErrorReturn(Object)` instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.replayMillis(int, long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.replayMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.sampleFirstMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.sampleMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.FluxSink.serialize() Use `Flux.create(java.util.function.Consumer)` or `Flux.create(java.util.function.Consumer, FluxSink.OverflowStrategy)` to create a serialized `FluxSink`.
reactor.core.publisher.MonoSink.setCancellation(Cancellation) Use `MonoSink.onDispose(Disposable)` for resources to be disposed on any terminate signal or `MonoSink.onCancel(Disposable)` for resources to be disposed on cancel.
reactor.core.publisher.FluxSink.setCancellation(Cancellation) use `FluxSink.onDispose(Disposable)` for resources to be disposed on any cancel signal or `FluxSink.onCancel(Disposable)` for resources to be disposed on cancel.
reactor.core.scheduler.Scheduler.shutdown() move the implementation to `Scheduler.dispose()` and call dispose from shutdown. Will be removed in 3.1.0
reactor.core.scheduler.Scheduler.Worker.shutdown() move the implementation to `Scheduler.Worker.dispose()` and call dispose from shutdown. Will be removed in 3.1.0
reactor.core.publisher.Flux.skipMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.skipMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, Consumer<? super Subscription>, int) prefer using `limitRate(prefetch).subscribe(...)` to `subscribe(..., prefetch)`
reactor.core.publisher.Flux.subscribe(Consumer<? super T>, Consumer<? super Throwable>, Runnable, int) prefer using `limitRate(prefetch).subscribe(...)` to `subscribe(..., prefetch)`
reactor.core.publisher.Flux.subscribe(Consumer<? super T>, int) use limitRate + subscribe(Consumer)
reactor.core.publisher.Flux.subscribe(int) use `Flux.limitRate(int)`
reactor.core.publisher.Flux.switchOnError(Class<E>, Publisher<? extends T>) use `Flux.onErrorResume(java.util.function.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>)` with a `t -> fallback` lambda instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.switchOnError(Predicate<? super Throwable>, Publisher<? extends T>) use `Flux.onErrorResume(java.util.function.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>)` with a `t -> fallback` lambda instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.switchOnError(Publisher<? extends T>) use `Flux.onErrorResume(java.util.function.Function<? super java.lang.Throwable, ? extends org.reactivestreams.Publisher<? extends T>>)` with a `t -> fallback` lambda instead. Will be removed in 3.1.0.
reactor.core.publisher.Flux.takeMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.takeMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.then(Publisher<Void>) use `Flux.thenEmpty(Publisher)` instead, this alias will be removed in 3.1.0
reactor.core.publisher.Mono.then(Supplier<? extends Mono<V>>) removed in 3.1, use `Mono.then(Mono)` with `Mono.defer(java.util.function.Supplier<? extends reactor.core.publisher.Mono<? extends T>>)`. The competing overload was causing confusion and the generic was not symmetric with `Mono.then(Mono)`.
reactor.core.publisher.Flux.then(Supplier<? extends Publisher<Void>>) removed in 3.1, use `Flux.thenEmpty(Publisher)` with `Flux.defer(java.util.function.Supplier<? extends org.reactivestreams.Publisher<T>>)`. The competing overload was causing confusion and the generic was not symmetric with `Mono.then(Mono)`.
reactor.core.publisher.Flux.thenMany(Supplier<? extends Publisher<V>>) removed in 3.1, use `Flux.thenMany(Publisher)` with `Flux.defer(java.util.function.Supplier<? extends org.reactivestreams.Publisher<T>>)`. The competing overload was called unnecessary by extended feedback and aligns with removing of Supplier of Publisher aliases elsewhere.
reactor.core.publisher.Mono.thenMany(Supplier<? extends Publisher<V>>) removed in 3.1, use `Mono.thenMany(Publisher)` with `Mono.defer(java.util.function.Supplier<? extends reactor.core.publisher.Mono<? extends T>>)`. The competing overload was called unnecessary by extended feedback and aligns with removing of Supplier of Publisher aliases elsewhere.
reactor.util.concurrent.WaitStrategy.throwAlert() duplicate to `WaitStrategy.alert()`
reactor.core.publisher.Flux.timeoutMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.timeoutMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.timeoutMillis(long, Mono<? extends T>) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.timeoutMillis(long, Mono<? extends T>, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.timeoutMillis(long, Publisher<? extends T>) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.timeoutMillis(long, Publisher<? extends T>, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.timeoutMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Mono.timeoutMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.scheduler.Schedulers.timer() in 3.0.6 and from 3.1 onwards, all Scheduler support time. `Schedulers.single()` is a direct equivalent if required.
reactor.core.publisher.Flux.timestamp(TimedScheduler) use `Flux.timestamp(Scheduler)`
reactor.core.publisher.Mono.timestamp(TimedScheduler) use `Mono.timestamp(Scheduler)`
reactor.core.publisher.EmitterProcessor.upstream()
reactor.core.publisher.Flux.window() will be removed in 3.1.0. Prefer using other variants, like `Flux.window(Publisher)`,
reactor.core.publisher.Flux.window(int, Duration) use `Flux.windowTimeout(int, Duration)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.window(Publisher<U>, Function<? super U, ? extends Publisher<V>>) will be removed in 3.1.0. Use `Flux.windowWhen(Publisher, Function)` instead.
reactor.core.publisher.Flux.windowMillis(int, long) use `Flux.windowTimeout(int, Duration)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.windowMillis(int, long, TimedScheduler) use `Flux.windowTimeout(int, Duration, Scheduler)` instead, will be removed in 3.1.0
reactor.core.publisher.Flux.windowMillis(long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.windowMillis(long, long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.windowMillis(long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.windowTimeoutMillis(int, long) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.windowTimeoutMillis(int, long, TimedScheduler) use the `Duration` based variants instead, will be removed in 3.1.0
reactor.core.publisher.Flux.zip(Iterable<? extends Publisher<?>>) prefer using `Flux.zip(Iterable, Function)`, will be removed in 3.1.0

Deprecated API

Contents