README: update Spring example to support Spring 6.2+

Author: sizovs

README.md

@@ -5,14 +5,14 @@
 ![Maven Central Version](https://img.shields.io/maven-central/v/net.sizovs/pipelinr)
 [![libs.tech recommends](https://libs.tech/project/169682577/badge.svg)](https://libs.tech/project/169682577/pipelinr)
 
-
 > **PipelinR** is a lightweight command processing pipeline ❍ ⇢ ❍ ⇢ ❍ for your awesome Java app.
 
 PipelinR has been battle-proven on production as a service layer for some cool FinTech apps. PipelinR has helped teams switch from giant service classes handling all use cases to small handlers, each following the single responsibility principle. It's similar to a popular [MediatR](https://github.com/jbogard/MediatR) .NET library.
 
 ⚡ Tested and works with plain Java, Kotlin, Spring, and Jakarta EE.
 
 ## Table of contents
+
 - [How to use](#how-to-use)
 - [Commands](#commands)
 - [Handlers](#handlers)
@@ -93,11 +93,11 @@ class Pong implements Command.Handler<Ping, String> {
 ```
 
 ## Pipeline
+
 A **pipeline** mediates between commands and handlers. You send commands to the pipeline. When the pipeline receives a command, it sends the command through a sequence of middlewares and finally invokes the matching command handler. `Pipelinr` is a default implementation of `Pipeline` interface.
 
 To construct a `Pipeline`, create an instance of `Pipelinr` and provide a list of command handlers:
 
-
 ```java
 Pipeline pipeline = new Pipelinr()
     .with(
@@ -243,6 +243,7 @@ new Ping().send(pipeline);
 ```
 
 💡 Remember to provide notification handlers to PipelinR:
+
 ```java
 new Pipelinr()
   .with(
@@ -269,19 +270,22 @@ new Pipelinr().with(() -> Stream.of(new Transactional()))
 ```
 
 ### Notification handling strategies
+
 The default implementation loops through the notification handlers and awaits each one. This ensures each handler is run after one another.
 
 Depending on your use-case for sending notifications, you might need a different strategy for handling the notifications, such running handlers in parallel.
 
 PipelinR supports the following strategies:
-* `an.awesome.pipelinr.StopOnException` runs each notification handler after one another; returns when all handlers are finished or an exception has been thrown; in case of an exception, any handlers after that will not be run; **this is a default strategy**.
-* `an.awesome.pipelinr.ContinueOnException` runs each notification handler after one another; returns when all handlers are finished; in case of any exception(s), they will be captured in an AggregateException.
-* `an.awesome.pipelinr.Async` runs all notification handlers asynchronously; returns when all handlers are finished; in case of any exception(s), they will be captured in an AggregateException.
-* `an.awesome.pipelinr.ParallelNoWait` runs each notification handler in a thread pool; returns immediately and does not wait for any handlers to finish; cannot capture any exceptions.
-* `an.awesome.pipelinr.ParallelWhenAny` runs each notification handler in a thread pool; returns when any thread (handler) is finished; all exceptions that happened before returning are captured in an AggregateException.
-* `an.awesome.pipelinr.ParallelWhenAll` runs each notification handler in a thread pool; returns when all threads (handlers) are finished; in case of any exception(s), they are captured in an AggregateException.
+
+- `an.awesome.pipelinr.StopOnException` runs each notification handler after one another; returns when all handlers are finished or an exception has been thrown; in case of an exception, any handlers after that will not be run; **this is a default strategy**.
+- `an.awesome.pipelinr.ContinueOnException` runs each notification handler after one another; returns when all handlers are finished; in case of any exception(s), they will be captured in an AggregateException.
+- `an.awesome.pipelinr.Async` runs all notification handlers asynchronously; returns when all handlers are finished; in case of any exception(s), they will be captured in an AggregateException.
+- `an.awesome.pipelinr.ParallelNoWait` runs each notification handler in a thread pool; returns immediately and does not wait for any handlers to finish; cannot capture any exceptions.
+- `an.awesome.pipelinr.ParallelWhenAny` runs each notification handler in a thread pool; returns when any thread (handler) is finished; all exceptions that happened before returning are captured in an AggregateException.
+- `an.awesome.pipelinr.ParallelWhenAll` runs each notification handler in a thread pool; returns when all threads (handlers) are finished; in case of any exception(s), they are captured in an AggregateException.
 
 You can override default strategy via:
+
 ```java
 new Pipelinr().with(new ContinueOnException());
 ```
@@ -290,18 +294,18 @@ new Pipelinr().with(new ContinueOnException());
 
 PipelinR works well with Spring and Spring Boot.
 
-Start by configuring a `Pipeline`. Create an instance of `Pipelinr` and inject all command handlers and **ordered** middlewares via the constructor:
+Start by configuring a `Pipeline`. Create an instance of `Pipelinr` and inject all command handlers and **ordered** middlewares:
 
 ```java
 @Configuration
 class PipelinrConfiguration {
 
     @Bean
     Pipeline pipeline(ObjectProvider<Command.Handler> commandHandlers, ObjectProvider<Notification.Handler> notificationHandlers, ObjectProvider<Command.Middleware> middlewares) {
-        return new Pipelinr()
-          .with(commandHandlers::stream)
-          .with(notificationHandlers::stream)
-          .with(middlewares::orderedStream);
+      return new Pipelinr()
+        .with(() -> commandHandlers.stream())
+        .with(() -> notificationHandlers.stream())
+        .with(() -> middlewares.orderedStream());
     }
 }
 ```
@@ -322,7 +326,6 @@ class WaveBack implements Command.Handler<Wave, String> {
 }
 ```
 
-
 Optionally, define `Order`-ed middlewares:
 
 ```java
@@ -407,13 +410,14 @@ Sending `AsyncPing` to the pipeline returns `CompletableFuture`:
 CompletableFuture<String> okInFuture = new Ping().execute(pipeline);
 ```
 
-
 ## How to contribute
+
 Just fork the repo and send us a pull request.
 
 ## Alternatives
-- [MediatR](https://github.com/jbogard/MediatR) – Simple, unambitious mediator implementation in .NET
 
+- [MediatR](https://github.com/jbogard/MediatR) – Simple, unambitious mediator implementation in .NET
 
 ## Contributors
+
 - Eduards Sizovs: [Blog](https://sizovs.net) ⋅ [Twitter](https://twitter.com/eduardsi) ⋅ [GitHub](https://github.com/sizovs)