anchor.diff:  Spring Framework 5 embraces
   https://github.com/reactive-streams/reactive-streams-jvm#reactive-streams[Reactive Streams]
   as the contract for communicating backpressure across async components and
  -libraries. Reactive Streams is the result of an industry collaboration and is also
  -adopted in Java 9 as `java.util.concurrent.Flow`.
  -
  -For its own reactive support the Spring Framework relies on
  -https://projectreactor.io/[Reactor] which implements Reactive Streams and extends
  -the Reactive Streams `Publisher` contract with the `Flux` and `Mono` composable API
  -types that provide declarative operations on data sequence of `0..N` and `0..1`.
  -
  -The Spring Framework exposes `Flux` and `Mono` in many of its reactive APIs.
  -At the application level however as always Spring provides choice and fully supports
  -the use of RxJava. For more on reactive types check the blog post
  +libraries. Reactive Streams is a specification created through industry collaboration that
  +has also been adopted in Java 9 as `java.util.concurrent.Flow`.
  +
  +The Spring Framework uses https://projectreactor.io/[Reactor] internally for its own
  +reactive support. Reactor is a Reactive Streams implementation that further extends the
  +basic Reactive Streams `Publisher` contract with the `Flux` and `Mono` composable API
  +types to provide declarative operations on data sequences of `0..N` and `0..1`.
  +
  +The Spring Framework exposes `Flux` and `Mono` in many of its own reactive APIs.
  +At the application level however, as always, Spring provides choice and fully supports
  +the use of RxJava. For more on reactive types check the post
   https://spring.io/blog/2016/04/19/understanding-reactive-types["Understanding Reactive Types"]
   by Sebastien Deleuze.
   
   
   [[web-reactive-feature-overview]]
  -== Spring Reactive Web Overview
  +== Spring Web Reactive Overview
   
   
   [[web-reactive-module]]
  
positive.code: server.start();
  ----
  
  The `WebReactiveConfiguration` at (1) is the Web Reactive Java config from the `spring-web-reactive`
  and is similar in purpose to the MVC Java config from `spring-webmvc`. It provides the
  the web framework configuration required to get started leaving you only to
  declare your own `@Controller' beans.
  
  The `DispatcherHandler` at (2) is the equivalent of the `DispatcherServlet` in Spring MVC.
  
  The `HttpServer` at (3) is an abstraction from the
  https://github.com/spring-projects/spring-framework/tree/master/spring-web/src/test/java/org/springframework/http/server/reactive/bootstrap[test sources]
  of the `spring-web-reactive` module that's used for the framework's own integration tests.
  It comes with basic implementations of all supported runtimes.
  
  
  [[web-reactive-getting-started-M1]]
  === Extent of M1 Support
  
  For M1 the Spring Web Reactive module focuses on support for REST scenarios both
  client and server-side. Basic HTML rendering with Freemarker is also supported but
  limited to rendering, i.e. there is no support form submissions yet.
  
  On the client side for M1 the Reactor Netty HTTP client is supported.
  
negative.code: [[web-reactive-getting-started-boot]]
  === Spring Boot Starter
  
  The experimental Spring Boot Web Reactive starter available via http://start.spring.io
  is the quickest way to get started. It does all the work so you can start
  writing `@Controller` classes. By default it runs on Tomcat but the dependencies can
  be changed as usual with Spring Boot to switch to a different runtime.
  
  
  [[web-reactive-getting-started-manual]]
  