anchor.diff:  
   
   Spring Framework 5 adds a new `spring-web-reactive` module that supports the same
  -`@Controller` and `@RestController` programming model as Spring MVC but executed
  -on a reactive and non-blocking foundation. The diagram below shows how Spring MVC
  -and Spring Web Reactive side by side:
  +`@Controller` programming model as Spring MVC but executed on a reactive,
  +non-blocking engine. The diagram below shows how Spring MVC and Spring Web
  +Reactive compare side by side:
   
   image::images/web-reactive-overview.png[width=720]
   
  -Spring Web Reactive makes use of the Servlet 3.1 non-blocking I/O API and runs on
  -Servlet 3.1 containers and also on other non-blocking runtimes such as Netty and Undertow.
  +Spring Web Reactive makes use of Servlet 3.1 non-blocking I/O and runs on
  +Servlet 3.1 containers. It also runs on non-Servlet runtimes such as Netty and Undertow.
   Each runtime is adapted to a set of shared, reactive `ServerHttpRequest` and
   `ServerHttpResponse` abstractions that expose the request and response body
   as `Flux<DataBuffer>` with full backpressure support on the read and the
   write side.
   
   The `spring-core` module provides reactive `Encoder` and `Decoder` contracts
  -that enable the serialization of a `Flux` of bytes to and from typed objects
  -along with some basic implementations.
  -
  -The `spring-web` modules adds JSON and XML implementations for use in reactive
  -web applications and also provides support for SSE streaming and zero-copy
  -file transfer.
  -
  -The `spring-web-reactive` module defines many of the same contracts as
  -Spring MVC such as `HandlerMapping` and `HandlerAdapter` among others.
  -These reactive counterparts have asynchronous and non-blocking semantics and
  -operate on the reactive HTTP request and response abstractions.
  +that enable the serialization of a `Flux` of bytes to and from typed objects.
  +The `spring-web` module adds JSON (Jackson) and XML (JAXB) implementations for use in
  +web applications as well as others for SSE streaming and zero-copy file transfer.
  +
  +The `spring-web-reactive` module contains the Spring Web Reactive framework that supports
  +the `@Controller` programming model. It re-defines many of the Spring MVC contracts
  +such as `HandlerMapping` and `HandlerAdapter` to be asynchronous and
  +non-blocking and to operate on the reactive HTTP request and response. For this reason
  +Spring MVC and Spring Web Reactive cannot share any code. However they do share
  +many of the same algorithms.
   
   The end result is a programming model identical to today's Spring MVC but
  -supporting reactive types and executing on a reactive, non-blocking foundation.
  -For example a controller method can declare any of the following as a method argument:
  -
  -* `@RequestBody Account account` -- the account is deserialized without
  -blocking before the controller method is invoked.
  -* `@RequestBody Mono<Account> account` -- the controller can use the `Mono`
  -type to declare the logic execute when the account is deserialized.
  -* `@RequestBody Single<Account> account` -- same but with RxJava
  -* `@RequestBody Flux<Account>` accounts` -- streaming scenario.
  -* `@RequestBody Observable<Account> accounts` -- streaming with RxJava.
  -
  -The same principle also applies on the side of return value handling.
  +with support for reactive types and executed in a reactive manner.
  +For example a controller method can declare the following as an
  +`@RequestBody` method argument:
  +
  +* `Account account` -- the account is deserialized without
  +blocking before the controller is invoked.
  +* `Mono<Account> account` -- the controller can use the `Mono`
  +to declare logic to be executed after the account is deserialized.
  +* `Single<Account> account` -- same as with `Mono` but using RxJava
  +* `Flux<Account> accounts` -- input streaming scenario.
  +* `Observable<Account> accounts` -- input streaming with RxJava.
  +
  +The above also applies to return value handling:
  +
  +* `Mono<Account>` -- serialize without blocking the given Account when the `Mono` completes.
  +* `Singe<Account>` -- same but using RxJava.
  +* `Flux<Account>` -- streaming scenario, possibly SSE depending on the requested content type.
  +* `Flux<SseEvent>` -- SSE streaming.
  +* `Observable<SseEvent>` -- same but using RxJava.
  +* `Mono<Void>` -- request handling completes when the `Mono` completes.
  +* `void` -- request handling completes when the method returns;
  +implies a synchronous, non-blocking controller method.
  +* `Account` -- serialize without blocking the given Account;
  +implies a synchronous, non-blocking controller method.
   
   
   [[web-reactive-client]]
  
positive.code: 
  Spring Framework 5 adds a new reactive `WebClient` in addition to the existing `RestTemplate`.
  
  Much like on the server side each supported HTTP client is adapted to a set of shared,
  reactive `ClientHttpRequest` and `ClientHttpResponse` abstractions that expose the request
  and response body as `Flux<DataBuffer>` with full backpressure support on the read and
  the write side. The `Encoder` and `Decoder` abstractions from `spring-core` also used on
  the client side for serialization of a `Flux` of bytes to and from typed objects.
  
  Below is an example:
  
  [source,java,indent=0]
  [subs="verbatim,quotes"]
  
negative.code: 
  In plain terms reactive programming is about non-blocking applications that are asynchronous
  and event-driven and require a small number of threads to scale. A key aspect of that
  definition is the concept of backpressure which is a mechanism to ensure producers
  don't overwhelm consumers. For example in a pipeline of reactive components that extends
  from the database to the HTTP socket when the HTTP client is slow the data
  repository slows down or stops until capacity frees up.
  
  From a programming model perspective reactive programming involves a major shift from imperative style logic
  to a declarative composition of async logic. It is comparable to using `CompletableFuture` in Java 8
  and composing follow-up actions via lambda expressions.
  
  For a more extended introduction to reactive programming check the excellent multi-part series
  https://spring.io/blog/2016/06/07/notes-on-reactive-programming-part-i-the-reactive-landscape["Notes on Reactive Programming"]
  by Dave Syer.
  
  