Polish and update reactive getting started reference

This commit updates the instructions on getting started with
Spring Web Reactive and also updates constructors and setters to
streamline the getting started procedure.

Issue: SPR-14640

Author: rstoyanchev

spring-web-reactive/src/main/java/org/springframework/web/reactive/DispatcherHandler.java

@@ -71,6 +71,14 @@ public class DispatcherHandler implements WebHandler, ApplicationContextAware {
 	private List<HandlerResultHandler> resultHandlers;
 
 
+	public DispatcherHandler() {
+	}
+
+	public DispatcherHandler(ApplicationContext applicationContext) {
+		initStrategies(applicationContext);
+	}
+
+
 	@Override
 	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 		initStrategies(applicationContext);

spring-web-reactive/src/test/java/org/springframework/web/reactive/DispatcherHandlerErrorTests.java

@@ -87,8 +87,7 @@ public void setUp() throws Exception {
 		appContext.register(TestConfig.class);
 		appContext.refresh();
 
-		this.dispatcherHandler = new DispatcherHandler();
-		this.dispatcherHandler.setApplicationContext(appContext);
+		this.dispatcherHandler = new DispatcherHandler(appContext);
 
 		this.request = new MockServerHttpRequest(HttpMethod.GET, new URI("/"));
 		MockServerHttpResponse response = new MockServerHttpResponse();

spring-web-reactive/src/test/java/org/springframework/web/reactive/result/SimpleUrlHandlerMappingIntegrationTests.java

@@ -61,10 +61,7 @@ protected HttpHandler createHttpHandler() {
 		wac.register(WebConfig.class);
 		wac.refresh();
 
-		DispatcherHandler dispatcherHandler = new DispatcherHandler();
-		dispatcherHandler.setApplicationContext(wac);
-
-		return WebHttpHandlerBuilder.webHandler(dispatcherHandler)
+		return WebHttpHandlerBuilder.webHandler(new DispatcherHandler(wac))
 				.exceptionHandlers(new ResponseStatusExceptionHandler())
 				.build();
 	}

spring-web-reactive/src/test/java/org/springframework/web/reactive/result/method/annotation/AbstractRequestMappingIntegrationTests.java

@@ -44,9 +44,9 @@ public abstract class AbstractRequestMappingIntegrationTests extends AbstractHtt
 	@Override
 	protected HttpHandler createHttpHandler() {
 		this.applicationContext = initApplicationContext();
-		DispatcherHandler handler = new DispatcherHandler();
-		handler.setApplicationContext(this.applicationContext);
-		return WebHttpHandlerBuilder.webHandler(handler).build();
+		return WebHttpHandlerBuilder
+				.webHandler(new DispatcherHandler(this.applicationContext))
+				.build();
 	}
 
 	protected abstract ApplicationContext initApplicationContext();

spring-web-reactive/src/test/java/org/springframework/web/reactive/result/method/annotation/SseIntegrationTests.java

@@ -65,10 +65,7 @@ protected HttpHandler createHttpHandler() {
 		this.wac.register(TestConfiguration.class);
 		this.wac.refresh();
 
-		DispatcherHandler webHandler = new DispatcherHandler();
-		webHandler.setApplicationContext(this.wac);
-
-		return WebHttpHandlerBuilder.webHandler(webHandler).build();
+		return WebHttpHandlerBuilder.webHandler(new DispatcherHandler(this.wac)).build();
 	}
 
 	@Test

spring-web/src/main/java/org/springframework/http/server/reactive/UndertowHttpHandlerAdapter.java

@@ -23,6 +23,7 @@
 import org.reactivestreams.Subscription;
 
 import org.springframework.core.io.buffer.DataBufferFactory;
+import org.springframework.core.io.buffer.DefaultDataBufferFactory;
 import org.springframework.util.Assert;
 
 /**
@@ -40,17 +41,20 @@ public class UndertowHttpHandlerAdapter implements io.undertow.server.HttpHandle
 
 	private final HttpHandler delegate;
 
-	private final DataBufferFactory dataBufferFactory;
+	private DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory(false);
 
 
-	public UndertowHttpHandlerAdapter(HttpHandler delegate, DataBufferFactory dataBufferFactory) {
+	public UndertowHttpHandlerAdapter(HttpHandler delegate) {
 		Assert.notNull(delegate, "'delegate' is required");
-		Assert.notNull(dataBufferFactory, "'dataBufferFactory' must not be null");
 		this.delegate = delegate;
-		this.dataBufferFactory = dataBufferFactory;
 	}
 
 
+	public void setDataBufferFactory(DataBufferFactory dataBufferFactory) {
+		Assert.notNull(dataBufferFactory, "'dataBufferFactory' must not be null");
+		this.dataBufferFactory = dataBufferFactory;
+	}
+
 	@Override
 	public void handleRequest(HttpServerExchange exchange) throws Exception {
 

spring-web/src/test/java/org/springframework/http/server/reactive/bootstrap/UndertowHttpServer.java

@@ -19,8 +19,6 @@
 import io.undertow.Undertow;
 import io.undertow.server.HttpHandler;
 
-import org.springframework.core.io.buffer.DataBufferFactory;
-import org.springframework.core.io.buffer.DefaultDataBufferFactory;
 import org.springframework.http.server.reactive.UndertowHttpHandlerAdapter;
 import org.springframework.util.Assert;
 
@@ -31,19 +29,13 @@ public class UndertowHttpServer extends HttpServerSupport implements HttpServer
 
 	private Undertow server;
 
-	private DataBufferFactory dataBufferFactory = new DefaultDataBufferFactory();
-
 	private boolean running;
 
-	public void setDataBufferFactory(DataBufferFactory dataBufferFactory) {
-		this.dataBufferFactory = dataBufferFactory;
-	}
 
 	@Override
 	public void afterPropertiesSet() throws Exception {
 		Assert.notNull(getHttpHandler());
-		HttpHandler handler =
-				new UndertowHttpHandlerAdapter(getHttpHandler(), dataBufferFactory);
+		HttpHandler handler = new UndertowHttpHandlerAdapter(getHttpHandler());
 		this.server = Undertow.builder().addHttpListener(getPort(), getHost())
 				.setHandler(handler).build();
 	}

src/asciidoc/web-reactive.adoc

@@ -153,47 +153,67 @@ Single<Account> response = webClient
 [[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
+The
+https://github.com/bclozel/spring-boot-web-reactive#spring-boot-web-reactive-starter[Spring Boot Web Reactive starter]
+available via http://start.spring.io
+is the fastest way to get started. It does all that's necessary 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]]
 === Manual Bootstrapping
 
-It is also easy to get started by writing a few lines of code:
+This section outlines the steps to get up and running without Spring Boot.
 
+For dependencies start with `spring-web-reactive` and `spring-context`.
+Then add `jackson-databind` and `io.netty:netty-buffer:4.1.3.Final`
+(temporarily see https://jira.spring.io/browse/SPR-14528[SPR-14528]) for JSON support.
+Lastly add the dependencies for one of the supported runtimes:
+
+* Tomcat -- `org.apache.tomcat.embed:tomcat-embed-core`
+* Jetty -- `org.eclipse.jetty:jetty-server` and `org.eclipse.jetty:jetty-servlet`
+* Reactor Netty -- `io.projectreactor.ipc:reactor-netty`
+* RxNetty -- `io.reactivex:rxnetty-common` and `io.reactivex:rxnetty-http`
+* Undertow -- `io.undertow:undertow-core`
+
+For the bootstrap code start with:
 [source,java,indent=0]
 [subs="verbatim,quotes"]
 ----
-AnnotationConfigApplicationContext context;
-context = new AnnotationConfigApplicationContext();
+AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
 context.register(WebReactiveConfiguration.class); 	// (1)
 context.refresh();
 
-DispatcherHandler handler = new DispatcherHandler();	// (2)
-handler.setApplicationContext(context);
-HttpHandler httpHandler = WebHttpHandlerBuilder.webHandler(handler).build();
-
-HttpServer server = new TomcatHttpServer();	// (3)
-server.setPort(8080);
-server.setHandler(httpHandler);
-server.afterPropertiesSet();
-server.start();
+DispatcherHandler dispatcherHandler = new DispatcherHandler(context);	// (2)
+HttpHandler httpHandler = WebHttpHandlerBuilder.webHandler(dispatcherHandler).build();
 ----
 
-The `WebReactiveConfiguration` at (1) is the Java config from `spring-web-reactive`
-and is similar in purpose to the MVC Java config from `spring-webmvc`. It provides 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 above loads default Spring Web Reactive config (1), then creates a
+`DispatcherHandler`, the main class driving request processing (2), and adapts
+it to `HttpHandler`, the lowest level Spring abstraction for reactive HTTP request handling.
+An `HttpHandler` can then be installed in each supported runtime:
 
-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 `spring-web-reactive` used for Spring Framework's own integration tests.
-The abstraction comes with basic implementations for each supported runtime.
+[source,java,indent=0]
+[subs="verbatim,quotes"]
+----
+// Tomcat and Jetty
+HttpServlet servlet = new ServletHttpHandlerAdapter(httpHandler);
+...
+
+// Reactor Netty
+HttpServer server = HttpServer.create(host, port)
+server.startAndAwait(new ServletHttpHandlerAdapter(httpHandler));
+
+// RxNetty
+HttpServer server = HttpServer.newServer(new InetSocketAddress(host, port))
+server.startAndAwait(new RxNettyHttpHandlerAdapter(httpHandler));
+
+// Undertow
+Undertow.builder().addHttpListener(port, host)
+	.setHandler(new UndertowHttpHandlerAdapter(httpHandler))
+	.build()
+----
 
 
 [[web-reactive-getting-started-M1]]