NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
Maven Central, #950 by repository stars
Non-Blocking Reactive Foundation for the JVM
Latest stable
3.8.8
Last release 1 months ago
23 Oct 2026
Ships fairly regularly
a new release about every 5 weeks
Nearly every release is documented
notes for 59 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
12 years old
205 releases · first in 2015
Drag across the ruler to compare, or tap a release to open it.
This is the 3rd release of Reactor 3.1, part of `BISMUTH-SR4` Release Train.
This is the 3rd release of Reactor 3.1, part of BISMUTH-SR4 Release Train.
This is a recommended update for all Reactor 3 users. It notably contains a new Flux operator called index to index as a Tuple<Long, T> or any arbitrary container each element from a sequence.
Flux#index operator (#934)Mono#single to enforce the presence of an element in a Mono<T> (#940)Mono#blockOptional to block and return an Optional (#918)Flux#fromStream(Supplier<Stream>) (#922)timeout operator (#925)Mono from a Supplier (#929)concatDelayError and concatMapDelayError with Mono.error (#936)Context simple example in reference guide (#921)Mono.repeatWhenEmpty (#919)cache(Duration) javadoc (#930)Context content in test (#950)Scheduler javadoc (#935)@baptistemesta, @naxhh
Your coding agent can read these notes before it upgrades. Set up the MCP server →
This is the 2nd release of Reactor 3.1, part of `BISMUTH-SR2` Release Train.
This is the 2nd release of Reactor 3.1, part of BISMUTH-SR2 Release Train.
This is a recommended update for all Reactor 3 users. It notably contains an important fix for a Flux#windowTimeout bug introduced in v3.1.0.
interval has been clarified, making it clearer that interval doesn't really support backpressure (#911)limitRequest operator will strictly cap the total request (without prefecthing, unlike limitRate) and limitRate now has a variant that takes a lowTide parameter that allow to customize the replenishing amount (#879, #894)Publisher with toFlux and toMono operations (#908)Flux#windowTimeout with <10ms timeouts could trigger race conditions and lose some windows/drop data to already closed windows. The operator has consequently been reworked (#912)dispose() (#880)Scannable scanning of PARENT and ACTUAL always returns a Scannable, even if the original unsafe scan didn't. In the later case, the UNAVAILABLE_SCAN instance is returned (#895)ParallelFlux (.parallel()) is now considered a THREAD_BARRIER for fusion purposes, allowing sensitive operators to skip fusion (#905)reactor-extra (#899)japicmp (#884)@0xflotus, @Buzzardo, @kadyana, @quaff, @sdeleuze
Mono#zip with an iterable: for consistency, swap the arguments (old "function, iterable" version is deprecated, see #619)
This is the first release of Reactor 3.1, part of Bismuth-RELEASE Release Train.
This version is a recommended update for all Reactor 3 users, and will be the one backing Spring Framework 5.0. A lot of API polishing has occurred between the last 3.0.x release and this one, so please read the release notes below carefully if you didn't progressively upgrade through the various MILESTONEs and RCs. (if you only care about what changed since RC1, please have a look at the RC2 release note)
The release notes below are written from the perspective of a migration from 3.0.x latest version and cover changes across all the 3.1.0 pre-releases.
Note that since pre-release v3.1.0.M2, the source code for the reactor-test artifact is part of the reactor-core github repository.
Reactor has been updated to pass the TCK of the new Reactive Streams specification 1.0.1.RC2. A new StrictSubscriber enforces RS rules more strictly when going out of the Reactor world and bridging to an external Publisher (#711)
The reactor-test artifact is now part of the io.projectreactor groupId (and reactor-core github repository)
Kotlin extensions for core and test are now part of the reactor-core repo and artifacts
behavioral changes
doAfterTerminate doesn't cause an onError signal if its callback fails (#270)sample will now include the last element in the source sequence if it terminates with an open sampling window (#724)Flux.cache(Duration) now expires the termination signal as well (#750)Flux/Mono method changes
ParallelFlux#subscribe(lambdas) lambda-based variants now return a Disposable (composite of all rails subscribers, #800)Flux#toIterable now takes an int for its batchSize argument (f3e13bf)Mono.doOnTerminate and doAfterTerminate now take a simple Runnable (aligning the API with Flux). The old doOnTerminate(BiConsumer<Throwable, T>) can be achieved with the added doOnSuccessOrError and old doAfterTerminate(BiConsumer<Throwable, T>) with doAfterSuccessOrError(BiConsumer<Throwable, T>). (#836 + 80a3210)Flux.firstEmitting is now called first and Flux.firstEmittingWith is now called or, aligning APIs with those of Mono (#849)Mono.empty(Publisher<?>) has been removed, prefer using the new Mono.when(p) (2e7fdf3)(Publisher, Function) as arguments (open boundary and closing selector) have been renamed to bufferWhen. This improves the situation where having multiple lambda-based signature can create ambiguity (even more so in languages like Kotlin) (#542)delay in Flux is removed in favor of Flux.delayElements (see #263)Mono#untilOther removed (use delayUntil(it -> other.take(1)) instead, see #558)then:
then that took a Supplier have been removed. Use defer if you really need to provide the continuation Mono lazily (#547)Flux.then(Publisher<Void>) has been removed in favor of thenEmptyMono.then(Function) is now Mono.flatMapMono zip vs when
zip is the operator dedicated to producing Tuples (or equivalent combinations) of the elements from multiple sources.
As a consequence, when and and variants that produced a Tuple have now been renamed zip and zipWith (#789 + 52f7f04)when and and still exist, as operators in the same family as then: they only care about completion signals,
discarding elements and returning a Mono<Void>.Mono#zip with an iterable: for consistency, swap the arguments (old "function, iterable" version is deprecated, see #619)zip(Iterable) and zip(Function, Iterable)in Flux has been removed (#338, #619):warning: Mono.then(Function) and Mono.flatMap(): how to migrate (#516):
Mono.flatMap with flatMapManyMono.then(Function) (which has been removed) with flatMap.flatMap was actually changing the return type to Flux and was thus missing the "Many" suffix we usually use. At the same time, then(Function) was transforming the source value (unlike any other form of then which usually just ignore the emissions and act on the onComplete). Thus it was actually more of a flatMap.error handling operators have been made more consistent between Mono and Flux (#533, #535, #531)
Flux: onErrorResumeWith -> onErrorResume, mapError -> onErrorMap, switchOnError -> replace with onErrorResume with a lambda that ignores the left hand side.Mono: otherwise -> onErrorResume, otherwiseReturn -> onErrorReturn, otherwiseIfEmpty -> switchIfEmpty, mapError -> onErrorMapwindow:
window operators that take a (Publisher, Function) as arguments (open boundary and closing selector) have been renamed to windowWhen. This improves the situation where having multiple lambda-based signature can create ambiguity (even more so in languages like Kotlin) (#542)Flux.window() has been removed in favor of window(Publisher), windowUntil and windowWhile(see #260)Flux.windowTimeOrSize: the timeout now starts right from subscription, resulting in potentially empty windows being emitted. It also restarts if the
timeout expires, so there could be several empty windows emitted eg. 3 for a timeout of 100ms if the Flux doesn't emit for 300ms.
The equivalent buffer version remains unchanged. (#484)windowUntil/windowWhile have Flux windows instead of GroupedFlux (#759)Cross operator changes based on prefix / parameter pattern:
Millis suffix have been removed, use their Duration based counterpartsxxx(boolean delayError): All operators that were taking a delayError boolean parameter instead of having a DelayError suffixed variant now use the suffix variant pattern (see #480)xxx(Function<Throwable, ?>): Operators dealing with a Predicate or Function of Throwable have been aligned to take a more generic <? super Throwable>subscribe methods in Flux that had a prefetch parameter have been removed (you can use limitRate to achieve the same effect)class changes
Signal is now an interface and MutableNextSignal has been removed (#779)Scannable interface (Loopback, MultiProducer, MultiReceiver, Producer, Receiver, Trackable, see #249, 20bd64df)Cancellation has been removed and replaced with Disposable (see #322, 844769d4)TimedScheduler has been removed, as well as the Scheduler#shutdown method (most schedulers are now fully time capable and you can use dispose(). The few Scheduler that are not time-capable will throw a RejectedExecutionException indicating so whenever one attempts to use schedulePeriodically on them. Note that most timed operators now use the parallel() Scheduler by default. (see #451, #322)OpenHashSet has been removed, as it was only used for Disposables: use Disposables.composite() (40fbd60)QueueSupplier has been renamed to Queues and is now purely about queue-related utils and static suppliers. It doesn't implement Supplier<Queue> itself anymore. (#733)Hooks
Hooks are now cumulative. Setting a hook will add it on top of the existing one(s). You can also name
some hooks, which allows to update a sub-hook or only partially reset a hook. (#687, #784)onEachOperator + onLastOperator, now Function<Publisher, Publisher>, new operator lift (#775)Context (#830)nullability
Tuple (#696)Processors have been reworked:
sink() method. For details and rationale, see #525.TopicProcessor, WorkQueueProcessor) now have a Builder instead of
factory methods. However, they keep a couple of significant factory methods (see #471, #616 and #628)Mono#subscribe() returns a Disposable. Use .toProcessor() to get the exact legacy behavior (see #566, #605 and #638)UnicastProcessor won't ignore the overflowStrategy if we can detect that a bounded queue is used. By default, an unbounded queue is used and the strategy is silently ignored. (#612)DirectProcessor and UnicastProcessor now call onErrorDropped and onNextDropped if calling after terminate. Exceptions.argumentIsNullException() has been removed (most of the time replaced by Objects.requireNonNull()). (7f6ff86)CancellationException (#792)Some changes have been made to the way writing custom operators works
Operators.SubscriberAdapter is not part of the public API anymore.Operators.addAndGet(AtomicLong, ...) has been removed in favor of the AtomicLongFieldUpdater alternative, itself renamed to addCap (#371)MonoSource and FluxSource are now package private, superseded by MonoOperator and FluxOperator (to deal with
new CoreSubscriber)Operators.onNextDropped default behaviour is to log the drop rather than throw a "fail with cancel" exception (#823)Context to a reactive sequence :sparkles: (Flux or Mono) is now possible. This is the major new feature in this milestone. (#117, #210, #337, #447, #704, #705, #723 and various other PRs)
Context can be created using factory methodsCoreSubscriber, a Reactor-specific Subscriber common to all Flux and Mono operators and needed to pass along the ContextFlux#subscribe(Subscriber) is now final, and one needs to instead implement subscribe(CoreSubscriber) in custom operators / Flux.subscriberContext(Function<Context, Context>).Mono#currentContext that can be used to emit the Context initialized downstream of it (or propagated inside eg. a flatMap)Context (b576f7f)Flux.error and Mono.error are now ScalarCallable and the error case can be fused when source is scalar (#716)Scannable classes via an Attr key. Attributes are quasi-enumerations exposing constants rather than enums. This allows splitting them into typed keys with meaningful global defaults so that scan doesn't need a Class to attempt a cast. Operator implementation is based on a Object scan, scanUnsafe.(see #606, #728)Mono#fromCallable/fromSupplier now map null result to empty Mono (#743)subscribeOn (#777)take(Duration) and takeUntilOther(Publisher) to Mono (#797)Disposables utility class ( #799, #804, #812)Mono.cache(Duration) (#683)distinctUntilChanged variant with a bipredicate to evaluate if there is a change (#608)onBackpressureBuffer variant with a TTL (#296)StepVerifier#verify() (#651)Mono.fromRunnable, the resulting Mono's generic type is better inferred (#686)checkpoint description is included inFlux/MonoSource#toString (#611)checkpoint(String) is now light by default, lowering the cost of using that operator (see #587)refCount now has a variant that waits for a grace period before unsubscribing from upstream (#569, #624, #627)Flux.then(Mono) operator to align with the Mono equivalent (#547)Mono.delayUntil to delay the emission of a Mono until after a companion Publisher generated from the source value completes. This acts on onComplete, unlike now removed untilOther. (#558, #568, #674)ParallelSubscriber now has a subscribe() method and all subscribe(...) methods are final like in Flux (#564)StepVerfier improvements:
Step#expectNext for up to 6 parameters (reactor/reactor-addons#106)expectNextSequence should fail when checking empty Flux (reactor/reactor-addons#98)MonoDelayElement (#749)Attr.LARGE_BUFFERED defaults back to null (as in "irrelevant") (#751)flattenIterable polling failures (#841)windowTimeout rejection double cancel (31ef92d)Subscription#request throws/errors (4d61440, decfa13)StepVerifier now ignores empty multivalue expectations, which could previously lead to bad assertions (#650)Flux#then and Mono#then would use arrays of incompatible types, resulting in an ArrayStoreException (#661)doOnNext callback would fail, when fused it wouldn't be caught by a doOnError (#664)filterWhen had a bug in tracking request and produced amount, resulting in under-requesting hangs (#689, #692)MonoProcessor could unnecessarily retain references to objects from its source. This is fixed by nulling out the source upon all terminations (#690)MonoProcessor#block() had a legacy inner timeout. It will now indefinitely wait for the actual completion. On the other hand, using a negative or 0 timeout in the Duration-based variant will now immediately time out. (#722)scan accumulation in a live reduction with a seed would always lag by one. It has been modified so that the seed is sent immediately, which allows the accumulator to run in lockstep with the upstream stage. (#609)Flux.create, setting an onDispose callback on the Sink after its onRequest method was called was ignored. The callback is now explicitly invoked if set after the sink was terminated. (#643)SingleScheduler.schedule (#578)Mono.untilOther would not return a new instance when chained with itself (#515)Operators#setOnce was cancelling the wrong subscriptionFlux and Mono javadoc has been made. It also now outputs UTF-8 html, and a few marble diagrams were added
(#545, #559, #528, #513, #544, #644, #469, #521, #698, 2cd83c2)(and all the intermediate milestones)
@akarnokd, @buzzardo, @Dmitriusan, @fabriziofortino, @garyrussell, @helmbold, @IlyaZinkovich, @jakekdodd, @jimhorng, @kamilszymanski, @lebannen, @making, @markotron, @olibye, @rajinisivaram, @sdeleuze, @schauder, @TomekJurkowski, @violetagg, @zgagnon
It contains backports of bug fixes and API deprecations from the 3.1.0 branch, the later allowing to lay an easier migration path ahead of time when p…
This is the 7th release of Reactor 3.0, part of Aluminium Release Train.
It contains backports of bug fixes and API deprecations from the 3.1.0 branch, the later allowing to lay an easier migration path ahead of time when possible. This is a recommended update for all Reactor 3 users.
Mono.flatMap becomes flatMapMany. In turn in 3.1.0 flatMap will change to the signature and behavior of current Mono.then(Function). This is semantically more correct as a flatMap traditionally returns the same type as the type it is called from (here Mono, not Flux). (#516)
then and use flatMapMany instead of flatMap. You will have to migrate from then to flatMap in 3.1.0.connect and connectSink should not be necessary anymore, Processors now have a common sink and serialize API (#525)Mono.otherwise and Flux.onErrorResumeWith aligned on onErrorResumemapError aligned to onErrorMapMono.otherwiseReturn aligned to onErrorReturnMono.otherwiseIfEmpty aligned to switchIfEmptyFlux.switchOnError(x) to be replaced with onErrorResume(ignore -> x)
(notice the introduction of the lambda, but it ignores the parameter)then and its variants that take a Supplier<Mono|Publisher> are deprecated (#547)
Publisher/Mono based) but with a Flux.defer or Mono.defer instead of the Supplier to lazily instantiate the publisher.buffer and window variants that take both a Publisher and Function to respectively define the opening and closing boundaries for the buffer/window are deprecated in favor of a new bufferWhen / windowWhen variant (#542)Mono.flatMapMany and Mono.flatMap (#516)onErrorMap (#535)Mono.onErrorReturn, Mono.switchIfEmtpy (#535)Flux.bufferWhen, Flux.windowWhen (#542)Operators#setOnce cancelling the wrong subscriptionDeferredSubscription#isCancelledsubscribe(Consumer, int)apiNote tag and UTF8 charsetDeprecated Flux and Mono xxxMillis(long, ...) signatures in favor of a unique xxx(Duration) alternative. (see #436)
This is the 6th release of Reactor 3.0, part of Aluminium-SR2 Release Train.
This is a recommended update for all Reactor 3 users.
3.1.0. Specifically we:
Flux and Mono xxxMillis(long, ...) signatures in favor of a unique xxx(Duration) alternative. (see #436)TimedScheduler into Scheduler for an easier execution contract (see #451).Operators.SubscriberAdapter which was encouraging inefficient encapsulation.Trackable, Loopback, Producer, Receiver, MultiReceiver and MultiProducer into a single Scannable contract for easier serviceability extension development. (see #249)FluxSink/MonoSink.setCancellation in favor of fluent and explicit onCancel and onDispose. It's important to distinguish the various reactor shutdown states:
FluxSink.serialize() since now Flux.create default to serialize (see #456), use of Flux.push can now be used alternatively for optimized single-producer push sources.xxxDelayError. In 3.1 we look forward giving subscribe-time option to override this behavior if the non suffixed operator alias is used. (see #480).Scheduler is now Schedulers.parallel, note that thread-name will now vary between the number of workers as in parallel-x instead of a single timed-n. (see https://github.com/reactor/reactor-core/commit/93a08ae483b7e1e20b325d820a4c0df6929d69fc)Avoiding deprecated API now as documented in javadoc will significantly reduce the burden of updating to 3.1. We track most of the deprecated APIs marked for deletion in 3.1 in #323.
onNext in Mono Subscribers such as operators or terminal subscribe/block calls. (see #442)Flux/Mono Duration + Scheduler aliases (see #436)FluxSink and MonoSink onCancel(Disposable) and onDispose(Disposable) (see #450, #444).Scannable to query reactor component stateful graphs (see #249).Flux.push for single producer, push-only alternative to Flux.create (see #456).Flux.create is now "serialized by default" and allows for multi producer push (see #456).FluxSink.onRequest(LongConsumer) to notify producer of downstream requests (see #456).Mono.whenDelayError(Iterable) (see #470)Mono.untilOther(Publisher) to coordinate on another Publisher (see #465)Flux/Mono filterWhen(Function<T, Publisher<Boolean>>> for async filtering (see #498)Flux.windowWhile replenishing issue (see #477)Flux.concatMap prefetch to unbounded when used with Integer.MAX_VALUE (see #476)Mono.fromRunnable fusion issue that resulted in no runnable invoked (see #455)Flux/Mono.publish(Function) ArrayOutOfBoundsException (see #438)Throwable.addSuppressed is now protected against circle reference in error handling (see #439)TopicProcessor silently failing on backlog size == 1 (see #445)Flux.flatMapIterable termination issue (see #453)BaseSubscriber.dispose to actually cancel upstream (see #461)@lhotari @madhead @RunninglVlan @bdavisx @nebhale
A warm welcome to @rajinisivaram as our new internal contributor. You might already have noticed her name as she is also working on the awesome https://github.com/reactor/reactor-kafka.
Finally a massive thank you to our resident reactive doctor @akarnokd and his support in various design issues, lately on the new filterWhenoperator.
A number of APIs and signatures have been _deprecated_ and are scheduled to be removed in 3.1.0. This should be made explicit in the associated API ja…
This is the 5th release of Reactor 3.0, part of Aluminium-SR1 Release Train.
This is a recommended update for all Reactor 3 users, with a lot of improvements and small bugfixes that have notably been made possible thanks to an ongoing effort to improve the test coverage beyond 80%.
3.1.0.
This should be made explicit in the associated API javadoc, but a list has been compiled in #323 too.window/buffer/windowMillis/bufferMillis were ambiguous (having close variations
of numerical parameters, int+long or long+long). The int+long ones (max size plus a timeout) have been
renamed with a Timeout keyword, like windowTimeoutMillis (#363) (alias and deprecate)RejectedDisposable was not intended to be public and has been made package-private (#362)Supplier<Queue> checks for null have been replaced with an error throw, as they are consider fatalOperators.addAndGet(AtomicLong) as not used internally, we encourage to use the other addAndGet variant or if required port this over your app/lib.
Exceptions.failWithCancel() is not a singleton exception anymore and Exceptions.CANCEL_STACKTRACE has been deprecated.Iterator<Object> with an unmodifiable iterator, a Tuple2 and a Tuple3
filled with nulls won't have the same hashcode anymore (base is the size), and Tuples toString format changed
(displays nulls, enclosed in square brackets)ExecutorServices in Schedulers, allowing users to change the internal implementation
for any core-provided Scheduler (#354)Mono and ParallelFlux now have doOnEach (#344)ParallelFlux now allow you to easily compose on each group's flux using composeGroup (#283)fromFuture with an additonal fromCompletionStage to support more future-like use cases (#357)Mono.delayElement and prepare renaming
of Flux.delay to Flux.delayElements (#263)windowUntil and windowWhile (#260)flatMap, decrease performance cost of activated assembly tracing, added Flux, Mono, ParallelFlux checkpoint(description?) operator to manually apply assembly tracingDisposable can now be checked for isDisposed() (#410)transform() to onAssembly scopeFuseable.QueueSubscription#isEmpty() is not expected to fail anymoreExceptions.propagate() instead of Exceptions.bubble()Schedulers.newElastic()Flux#onBackpressureBuffer()Flux.publish subscribers during batch of emission (#430)Mono.sequenceEquals not propagating subscribe signal + doing too much inner subscribe / too few inner cancel (#328, #329)Mono.whenDelayError was wrongly only using last 2 params out of 3 (#333)Tuples and Tuple2 fixes: fixed Tuples.fromArray for size 0 and 8, (#338)zipWith was failing with less than 8 sources (#338)MonoSink.success(null) now delegates to success() to ensure same semantics (#346)CachedTimedScheduler.now() correctly delegates to underlying scheduler (#351)Operators.addAndGet now return updated value (#372)Integer.MAX_VALUE) on groupBy triggers unbounded request (#385)Flux.skipUntil, Flux.handle, fix fusion request handling for SubscribeOnValue (8f67283, f2404eb, #342)
Flux.replay/cache fusion (#392)groupBy, window, buffer and switchMap to avoid overflow (#411)Flux & ParallelFlux reduce/collect generic issueQueueSupplier.unbounded(linkSize) !)collectMultimap (#396)ParallelFlux#getPrefetch accuracy of the returned valueFuseable.SynchronousSubscription does now expect a sync request mode and will return Fuseable.NONE if requested NONE.ArrayDeque operatorsFlux#getPrefetch(), monitor #397 for the complete migration in 3.1@kamilszymanski, @magnet, @mrorii, @sinwe, @dfeist and all folks who came discussing in our Gitter room, Spring team for continuous extensive collaboration and @akarnokd for his usual wisdom.
Cancellation is being deprecated and will be removed in 3.1.0. The new Disposable replaces it
This is the 4th release of Reactor 3.0, part of {ALUMINIUM-RELEASE} Release Train.
This is a recommended update for all Reactor 3 users.
Cancellation is being deprecated and will be removed in 3.1.0. The new Disposable replaces it (#322)
Scheduler now implements Disposable. We advise that if you have an implementation of Scheduler, you explicitly implement both shutdown() and dispose(), with the concrete code in dispose() and the shutdown() method calling dispose().Scheduler.WorkerBaseSubscriber has been added to allow to easily subscribe and play
with the request/cancel. It offers hooks, including a hookFinally that always
execute on sequence termination (#254, #279)bufferUntil and bufferWhile (#227)doFinally operator allows to perform a side effect on any type of
termination (onError, onComplete and cancel) (#251)WorkQueueProcessor, a best effort attempt at detecting the capacity
of the underlying Executor is made in order to prevent you from subscribing
too much (#199)doOnEach variant to Flux that takes a Consumer<Signal> (#264, #289)onBackpressureBuffer variant that takes a BufferOverflowStrategy,
allowing to decide what to do if the bounded buffer fills up: error, drop last
element, drop oldest element in buffer... (#281)Mono.and based on a Function<T, Mono<V>> now allows to easily
combine a value and the result of applying an asynchronous processing on it
into a Tuple2 (#300)Worker now has a isShutdown() method (#313)Disposable interface has been introduced, preparing to replace Cancellation. For now it extends Cancellation (#322)FluxHandle sink always use onOperatorError (#282)RejectedExecutionException in most processors (#275, #293, #298, #274, #299, #313, #319)
Subscription as a Collection in log() (instead using
a dedicated format), which would cause a NotImplementedException with some
loggers applying custom logic to Collections (#262)flatMapSequential dropping some elements when there are more than
prefetch source elements (workaround: use same number for prefetch and
maxConcurrency) (#301)Mono#doOnTerminate (#242)@dfeist, @wilkinsona, @akarnokd, @not-for-me
And thanks for raising issues/feedback: @dfeist, @balamaci, @srinivasvsk, @kdvolder, @gdrouet, @artembilan, @graememoss, @jurna
Since RxJava1Adapter was broken by latest rxjava1 maintenance releases, this might not be considered a hard breaking change.
This is the third release of Reactor 3.0. This is a recommended update for all Reactor 3 users.
RxJava1Adapter support has been dropped in favor of the official rxjava-reactive-stream. Since RxJava1Adapter was broken by latest rxjava1 maintenance releases, this might not be considered a hard breaking change.TestSubscriber from the sources, it has been removed from the public API (renamed AssertSubscriber and placed in test scope until it is removed definitely). Please use the StepVerifier class in the external project reactor-addons/reactor-tests 3.0.3.RELEASE instead.subscriber in Operators.MonoSubscriber has been renamed actual to be consistent with the other reactor-core operators. It should only be impacting for users that have implemented their own Mono operators.Flux#then(Publisher<Void>) has been deprecated, use the new name thenEmpty (will be removed in 3.1, see #238)Flux#subscribe overrides with a prefetch parameter have been deprecated in favor of chaining the new limitRate to other variants (#225)onNext and onComplete can still be called in wrong order, which impacts the doOnSuccess operator.
doOnNext rather than doOnSuccessmergeSequential and flatMapSequential operators (#178)
limitRate operator (#180)
setFactory, and are now a Supplier<Scheduler> (#218)subscribe variants with a Consumer<Subscription> callback (#196)Flux (fromStream, thenMany, zip) and Mono (when, and, or and thenMany) (#240, #237)PeekFuseableSubscriber#poll not using Operators.onOperatorError (#205)Subscription on consumer error (#212)Scheduler shutdown consistent handling with future.cancel(true/false)thenXXX APIs (#238, #198)/codequality/ideaj.u.Objects in Signal equals and toStringThanks to the following contributors that also participated to this release 👍 : @dfeist @poutsma @snicoll @akarnokd
Nothing published for this version
Full list of changes and fix : https://github.com/reactor/reactor-core/milestone/7?closed=1
Full list of changes and fix : https://github.com/reactor/reactor-core/milestone/7?closed=1
Nothing published for this version
Package restructure and name consistency fixes
Breaking from v2.5.0.M4
New exciting stuff, polishing, name changes, fixes, efficiency, clarifications: that's the result of an extended feedback and an active stream of impr
New exciting stuff, polishing, name changes, fixes, efficiency, clarifications: that's the result of an extended feedback and an active stream of improvements from Reactive Streams Commons. TBC:
Breaking from M3 :
Computations and Timer factories are now used through Schedulers
Computations#concurrent -> Schedulers#elasticComputations#parallel -> Schedulers#parallel or Schedulers#computation if pure non blocking tasksRemoved :
Introducing Scheduler/Worker contract from Reactive Streams Commons
Breaking from M2 :
SchedulerGroup is now Computations and io -> concurrent, async -> parallelpublishOn() is now subscribeOn()dispatchOn() is now publishOn()Cancellation instead of RunnableTimer API changesstartEmitter() is now connectEmitter()Additions :
Flux#concatMapIterable/flatMapIterableMono#when now properly completes when all input are complete.Mono#fromSupplier and Mono#whenDelayErrorFlux#collect(java.util.stream.Collector)View full release announce here : https://spring.io/blog/2016/03/11/reactor-core-2-5-becomes-a-unified-reactive-foundation-on-java-8
View full release announce here : https://spring.io/blog/2016/03/11/reactor-core-2-5-becomes-a-unified-reactive-foundation-on-java-8
Announce post : https://spring.io/blog/2016/02/16/reactor-2-5-a-second-generation-reactive-foundation-for-the-jvm
Announce post : https://spring.io/blog/2016/02/16/reactor-2-5-a-second-generation-reactive-foundation-for-the-jvm
First 2.5.x re-organized Reactor Core iteration
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
One column per quarter.