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.
+PipelinR has been battle-proven on production as a service layer for some serious FinTech apps. PipelinR has helped teams switch from giant service classes handling all use cases to small handlers, 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)
@@ -50,11 +50,10 @@ Java version required: 1.8+.
 
 ## Commands
 
-**Commands** is a request that can return a value. The `Ping` command below returns a string:
+**Commands** is a request that can return a value. The following `Ping` command returns a string:
 
 ```java
 class Ping implements Command<String> {
-
     public final String host;
 
     public Ping(String host) {
@@ -63,11 +62,10 @@ class Ping implements Command<String> {
 }
 ```
 
-If a command has nothing to return, you can use a built-in `Voidy` return type:
+If a command has nothing to return, use a built-in `Voidy` return type:
 
 ```java
 class Ping implements Command<Voidy> {
-
     public final String host;
 
     public Ping(String host) {
@@ -84,7 +82,6 @@ Create a handler by implementing `Command.Handler<C, R>` interface, where `C` is
 
 ```java
 class Pong implements Command.Handler<Ping, String> {
-
     @Override
     public String handle(Ping command) {
         return "Pong from " + command.host;
@@ -93,16 +90,13 @@ 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(
-        () -> Stream.of(new Pong())
-    );
+Pipeline pipeline = new Pipelinr().with(() -> Stream.of(new Pong()));
 ```
 
 Send a command for handling:
@@ -117,19 +111,26 @@ since v0.4, you can execute commands more naturally:
 new Ping("localhost").execute(pipeline);
 ```
 
-`Pipelinr` can receive an optional, **ordered list** of custom middlewares. Every command will go through the middlewares before being handled. Use middlewares when you want to add extra behavior to command handlers, such as validation, logging, transactions, or metrics:
+`Pipelinr` can receive an optional, **ordered list** of middlewares. Every command will go through the middlewares before being handled. Use middlewares to add extra behavior to command handlers, such as validation, logging, transactions, or metrics:
 
 ```java
-// command validation + middleware
-
-interface CommandValidator<C extends Command<R>, R> {
-    void validate(C command);
-
-    default boolean matches(C command) {
-        Generic<C> commandType = new Generic<C>(getClass()) { // since 0.10
-        };
+class LoggingMiddleware implements Command.Middleware {
+    @Override
+    public <R, C extends Command<R>> R invoke(C command, Next<R> next) {
+        // log command
+        R response = next.invoke();
+        // log response
+        return response;
+    }
+}
 
-        return commandType.resolve().isAssignableFrom(command.getClass());
+class TxMiddleware implements Command.Middleware {
+    @Override
+    public <R, C extends Command<R>> R invoke(C command, Next<R> next) {
+        // start tx
+        R response = next.invoke();
+        // end tx
+        return response;
     }
 }
 
@@ -146,58 +147,40 @@ class ValidationMiddleware implements Command.Middleware {
         return next.invoke();
     }
 }
-```
 
-```java
-// middleware that logs every command and the result it returns
-class LoggingMiddleware implements Command.Middleware {
-
-    @Override
-    public <R, C extends Command<R>> R invoke(C command, Next<R> next) {
-        // log command
-        R response = next.invoke();
-        // log response
-        return response;
-    }
-}
+interface CommandValidator<C extends Command<R>, R> {
+    void validate(C command);
 
-// middleware that wraps a command in a transaction
-class TxMiddleware implements Command.Middleware {
+    default boolean matches(C command) {
+        Generic<C> commandType = new Generic<C>(getClass()) { // since 0.10
+        };
 
-    @Override
-    public <R, C extends Command<R>> R invoke(C command, Next<R> next) {
-        // start tx
-        R response = next.invoke();
-        // end tx
-        return response;
+        return commandType.resolve().isAssignableFrom(command.getClass());
     }
 }
 ```
 
-In the following pipeline, every command and its response will be logged, it will be wrapped in a transaction, then validated:
+In the following pipeline, every command will be logged, wrapped in a transaction, and validated (in that order):
 
 ```java
 Pipeline pipeline = new Pipelinr()
     .with(() -> Stream.of(new Pong()))
     .with(() -> Stream.of(new LoggingMiddleware(), new TxMiddleware(), new ValidationMiddleware(...)));
 ```
 
-By default, command handlers are being resolved using generics. By overriding command handler's `matches` method, you can dynamically select a matching handler:
+By default, command handlers are resolved using generics. By overriding command handler's `matches` method, you can dynamically select a matching handler:
 
 ```java
 class LocalhostPong implements Command.Handler<Ping, String> {
-
     @Override
     public boolean matches(Ping command) {
         return command.host.equals("localhost");
     }
-
 }
 ```
 
 ```java
-class NonLocalhostPong implements Command.Handler<Ping, String> {
-
+class RemotePong implements Command.Handler<Ping, String> {
     @Override
     public boolean matches(Ping command) {
         return !command.host.equals("localhost");
@@ -212,23 +195,20 @@ Since version `0.5`, PipelinR supports Notifications, dispatched to multiple han
 For notifications, first create your notification message:
 
 ```java
-class Ping implements Notification {
-}
+class Ping implements Notification {}
 ```
 
 Next, create zero or more handlers for your notification:
 
 ```java
 public class Pong1 implements Notification.Handler<Ping> {
-
     @Override
     public void handle(Ping notification) {
       System.out.printn("Pong 1");
     }
 }
 
 public class Pong2 implements Notification.Handler<Ping> {
-
     @Override
     public void handle(Ping notification) {
       System.out.printn("Pong 2");
@@ -243,11 +223,9 @@ new Ping().send(pipeline);
 ```
 
 💡 Remember to provide notification handlers to PipelinR:
+
 ```java
-new Pipelinr()
-  .with(
-    () -> Stream.of(new Pong1(), new Pong2())
-  )
+new Pipelinr().with(() -> Stream.of(new Pong1(), new Pong2()))
 ```
 
 ### Notification middlewares
@@ -256,7 +234,6 @@ Notifications, like commands, support middlewares. Notification middlewares will
 
 ```java
 class Transactional implements Notification.Middleware {
-
     @Override
     public <N extends Notification> void invoke(N notification, Next next) {
         // start tx
@@ -269,19 +246,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,27 +270,25 @@ 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());
     }
 }
 ```
 
 Define a command:
 
 ```java
-class Wave implements Command<String> {
-}
+class Wave implements Command<String> {}
 ```
 
 Define a handler and annotate it with `@Component` annotation:
@@ -322,7 +300,6 @@ class WaveBack implements Command.Handler<Wave, String> {
 }
 ```
 
-
 Optionally, define `Order`-ed middlewares:
 
 ```java
@@ -342,8 +319,7 @@ class Transactional implements Command.Middleware {
 To use notifications, define a notification:
 
 ```java
-class Ping implements Notification {
-}
+class Ping implements Notification {}
 ```
 
 Define notification handlers and annotate them with `@Component` annotation:
@@ -407,13 +383,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)