Reactive setup refinements

Author: jhoeller

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

@@ -54,6 +54,7 @@
  *
  * @author Rossen Stoyanchev
  * @author Sebastien Deleuze
+ * @author Juergen Hoeller
  * @since 5.0
  */
 public class DispatcherHandler implements WebHandler, ApplicationContextAware {
@@ -159,6 +160,7 @@ private HandlerResultHandler getResultHandler(HandlerResult handlerResult) {
 	 * a {@link org.springframework.web.server.adapter.WebHttpHandlerBuilder}.
 	 * @param applicationContext the application context to find the handler beans in
 	 * @see #DispatcherHandler(ApplicationContext)
+	 * @see org.springframework.web.server.adapter.WebHttpHandlerBuilder#webHandler
 	 */
 	public static WebHandler toWebHandler(ApplicationContext applicationContext) {
 		return new DispatcherHandler(applicationContext);
@@ -167,10 +169,14 @@ public static WebHandler toWebHandler(ApplicationContext applicationContext) {
 	/**
 	 * Expose a dispatcher-based {@link HttpHandler} for the given application context,
 	 * typically for direct registration with an engine adapter such as
-	 * {@link org.springframework.http.server.reactive.ReactorHttpHandlerAdapter}.
+	 * {@link org.springframework.http.server.reactive.ServletHttpHandlerAdapter}.
 	 * @param applicationContext the application context to find the handler beans in
 	 * @see #DispatcherHandler(ApplicationContext)
 	 * @see HttpWebHandlerAdapter
+	 * @see org.springframework.http.server.reactive.ServletHttpHandlerAdapter
+	 * @see org.springframework.http.server.reactive.ReactorHttpHandlerAdapter
+	 * @see org.springframework.http.server.reactive.RxNettyHttpHandlerAdapter
+	 * @see org.springframework.http.server.reactive.UndertowHttpHandlerAdapter
 	 */
 	public static HttpHandler toHttpHandler(ApplicationContext applicationContext) {
 		return new HttpWebHandlerAdapter(new DispatcherHandler(applicationContext));

spring-web-reactive/src/main/java/org/springframework/web/reactive/function/DefaultRequest.java

@@ -44,12 +44,14 @@ class DefaultRequest implements Request {
 
 	private final StrategiesSupplier strategies;
 
+
 	DefaultRequest(ServerWebExchange exchange, StrategiesSupplier strategies) {
 		this.exchange = exchange;
 		this.strategies = strategies;
 		this.headers = new DefaultHeaders();
 	}
 
+
 	@Override
 	public HttpMethod method() {
 		return request().getMethod();
@@ -96,10 +98,8 @@ ServerWebExchange exchange() {
 	}
 
 
-
 	private class DefaultHeaders implements Headers {
 
-
 		private HttpHeaders delegate() {
 			return request().getHeaders();
 		}
@@ -116,7 +116,8 @@ public List<Charset> acceptCharset() {
 
 		@Override
 		public OptionalLong contentLength() {
-			return toOptionalLong(delegate().getContentLength());
+			long value = delegate().getContentLength();
+			return (value != -1 ? OptionalLong.of(value) : OptionalLong.empty());
 		}
 
 		@Override
@@ -137,18 +138,13 @@ public List<HttpRange> range() {
 		@Override
 		public List<String> header(String headerName) {
 			List<String> headerValues = delegate().get(headerName);
-			return headerValues != null ? headerValues : Collections.emptyList();
+			return (headerValues != null ? headerValues : Collections.emptyList());
 		}
 
 		@Override
 		public HttpHeaders asHttpHeaders() {
 			return HttpHeaders.readOnlyHttpHeaders(delegate());
 		}
-
-		private OptionalLong toOptionalLong(long value) {
-			return value != -1 ? OptionalLong.of(value) : OptionalLong.empty();
-		}
-
 	}
 
 }

spring-web-reactive/src/main/java/org/springframework/web/reactive/function/RouterFunctions.java

@@ -44,12 +44,9 @@
  *
  * @author Arjen Poutsma
  * @since 5.0
- *
  */
 public abstract class RouterFunctions {
 
-	private static final HandlerFunction<Void> NOT_FOUND_HANDLER = request -> Response.notFound().build();
-
 	/**
 	 * Name of the {@link ServerWebExchange} attribute that contains the {@link Request}.
 	 */
@@ -59,15 +56,19 @@ public abstract class RouterFunctions {
 	 * Name of the {@link ServerWebExchange} attribute that contains the URI
 	 * templates map, mapping variable names to values.
 	 */
-	public static final String URI_TEMPLATE_VARIABLES_ATTRIBUTE = RouterFunctions.class.getName() + ".uriTemplateVariables";
+	public static final String URI_TEMPLATE_VARIABLES_ATTRIBUTE =
+			RouterFunctions.class.getName() + ".uriTemplateVariables";
+
+	private static final HandlerFunction<Void> NOT_FOUND_HANDLER = request -> Response.notFound().build();
+
 
 	/**
 	 * Route to the given handler function if the given request predicate applies.
-	 *
-	 * @param predicate       the predicate to test
+	 * @param predicate the predicate to test
 	 * @param handlerFunction the handler function to route to
-	 * @param <T>             the type of the handler function
-	 * @return a routing function that routes to {@code handlerFunction} if {@code predicate} evaluates to {@code true}
+	 * @param <T> the type of the handler function
+	 * @return a routing function that routes to {@code handlerFunction} if
+	 * {@code predicate} evaluates to {@code true}
 	 * @see RequestPredicates
 	 */
 	public static <T> RouterFunction<T> route(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
@@ -79,11 +80,11 @@ public static <T> RouterFunction<T> route(RequestPredicate predicate, HandlerFun
 
 	/**
 	 * Route to the given routing function if the given request predicate applies.
-	 *
-	 * @param predicate       the predicate to test
+	 * @param predicate the predicate to test
 	 * @param routerFunction the routing function to route to
-	 * @param <T>             the type of the handler function
-	 * @return a routing function that routes to {@code routerFunction} if {@code predicate} evaluates to {@code true}
+	 * @param <T> the type of the handler function
+	 * @return a routing function that routes to {@code routerFunction} if
+	 * {@code predicate} evaluates to {@code true}
 	 * @see RequestPredicates
 	 */
 	public static <T> RouterFunction<T> subroute(RequestPredicate predicate, RouterFunction<T> routerFunction) {
@@ -102,9 +103,8 @@ public static <T> RouterFunction<T> subroute(RequestPredicate predicate, RouterF
 	}
 
 	/**
-	 * Converts the given {@linkplain RouterFunction routing function} into a {@link HttpHandler}.
+	 * Convert the given {@linkplain RouterFunction routing function} into a {@link HttpHandler}.
 	 * This conversion uses {@linkplain StrategiesSupplier#builder() default strategies}.
-	 *
 	 * <p>The returned {@code HttpHandler} can be adapted to run in
 	 * <ul>
 	 * <li>Servlet 3.1+ using the
@@ -116,18 +116,16 @@ public static <T> RouterFunction<T> subroute(RequestPredicate predicate, RouterF
 	 * <li>Undertow using the
 	 * {@link org.springframework.http.server.reactive.UndertowHttpHandlerAdapter}.</li>
 	 * </ul>
-	 *
 	 * @param routerFunction the routing function to convert
 	 * @return an http handler that handles HTTP request using the given routing function
 	 */
 	public static HttpHandler toHttpHandler(RouterFunction<?> routerFunction) {
-		return toHttpHandler(routerFunction, defaultStrategies());
+		return toHttpHandler(routerFunction, StrategiesSupplier.withDefaults());
 	}
 
 	/**
-	 * Converts the given {@linkplain RouterFunction routing function} into a {@link HttpHandler},
+	 * Convert the given {@linkplain RouterFunction routing function} into a {@link HttpHandler},
 	 * using the given strategies.
-	 *
 	 * <p>The returned {@code HttpHandler} can be adapted to run in
 	 * <ul>
 	 * <li>Servlet 3.1+ using the
@@ -139,70 +137,60 @@ public static HttpHandler toHttpHandler(RouterFunction<?> routerFunction) {
 	 * <li>Undertow using the
 	 * {@link org.springframework.http.server.reactive.UndertowHttpHandlerAdapter}.</li>
 	 * </ul>
-	 *
 	 * @param routerFunction the routing function to convert
-	 * @param strategies   the strategies to use
+	 * @param strategies the strategies to use
 	 * @return an http handler that handles HTTP request using the given routing function
 	 */
 	public static HttpHandler toHttpHandler(RouterFunction<?> routerFunction, StrategiesSupplier strategies) {
-		Assert.notNull(routerFunction, "'routerFunction' must not be null");
-		Assert.notNull(strategies, "'strategies' must not be null");
+		Assert.notNull(routerFunction, "RouterFunction must not be null");
+		Assert.notNull(strategies, "StrategiesSupplier must not be null");
 
 		return new HttpWebHandlerAdapter(exchange -> {
 			Request request = new DefaultRequest(exchange, strategies);
 			addAttributes(exchange, request);
-
 			HandlerFunction<?> handlerFunction = routerFunction.route(request).orElse(notFound());
 			Response<?> response = handlerFunction.handle(request);
 			return response.writeTo(exchange, strategies);
 		});
 	}
 
 	/**
-	 * Converts the given {@code RouterFunction} into a {@code HandlerMapping}.
+	 * Convert the given {@code RouterFunction} into a {@code HandlerMapping}.
 	 * This conversion uses {@linkplain StrategiesSupplier#builder() default strategies}.
-	 *
 	 * <p>The returned {@code HandlerMapping} can be run in a
 	 * {@link org.springframework.web.reactive.DispatcherHandler}.
-	 *
 	 * @param routerFunction the routing function to convert
 	 * @return an handler mapping that maps HTTP request to a handler using the given routing function
 	 * @see org.springframework.web.reactive.function.support.HandlerFunctionAdapter
 	 * @see org.springframework.web.reactive.function.support.ResponseResultHandler
 	 */
 	public static HandlerMapping toHandlerMapping(RouterFunction<?> routerFunction) {
-		return toHandlerMapping(routerFunction, defaultStrategies());
+		return toHandlerMapping(routerFunction, StrategiesSupplier.withDefaults());
 	}
 
 	/**
-	 * Converts the given {@linkplain RouterFunction routing function} into a {@link HandlerMapping},
+	 * Convert the given {@linkplain RouterFunction routing function} into a {@link HandlerMapping},
 	 * using the given strategies.
-	 *
 	 * <p>The returned {@code HandlerMapping} can be run in a
 	 * {@link org.springframework.web.reactive.DispatcherHandler}.
-	 *
 	 * @param routerFunction the routing function to convert
-	 * @param strategies   the strategies to use
+	 * @param strategies the strategies to use
 	 * @return an handler mapping that maps HTTP request to a handler using the given routing function
 	 * @see org.springframework.web.reactive.function.support.HandlerFunctionAdapter
 	 * @see org.springframework.web.reactive.function.support.ResponseResultHandler
 	 */
 	public static HandlerMapping toHandlerMapping(RouterFunction<?> routerFunction, StrategiesSupplier strategies) {
-		Assert.notNull(routerFunction, "'routerFunction' must not be null");
-		Assert.notNull(strategies, "'strategies' must not be null");
+		Assert.notNull(routerFunction, "RouterFunction must not be null");
+		Assert.notNull(strategies, "StrategiesSupplier must not be null");
 
 		return exchange -> {
 			Request request = new DefaultRequest(exchange, strategies);
 			addAttributes(exchange, request);
-
 			Optional<? extends HandlerFunction<?>> route = routerFunction.route(request);
 			return Mono.justOrEmpty(route);
 		};
 	}
 
-	private static StrategiesSupplier defaultStrategies() {
-		return StrategiesSupplier.builder().build();
-	}
 
 	private static void addAttributes(ServerWebExchange exchange, Request request) {
 		Map<String, Object> attributes = exchange.getAttributes();
@@ -218,4 +206,5 @@ private static <T> HandlerFunction<T> notFound() {
 	static <T> HandlerFunction<T> cast(HandlerFunction<?> handlerFunction) {
 		return (HandlerFunction<T>) handlerFunction;
 	}
+
 }

spring-web-reactive/src/main/java/org/springframework/web/reactive/function/StrategiesSupplier.java

@@ -33,6 +33,7 @@
  * {@link #of(Supplier, Supplier, Supplier)}.
  *
  * @author Arjen Poutsma
+ * @author Juergen Hoeller
  * @since 5.0
  * @see RouterFunctions#toHttpHandler(RouterFunction, StrategiesSupplier)
  * @see RouterFunctions#toHandlerMapping(RouterFunction, StrategiesSupplier)
@@ -62,12 +63,35 @@ public interface StrategiesSupplier {
 	 */
 	Supplier<Stream<ViewResolver>> viewResolvers();
 
+
 	// Static methods
 
 	/**
-	 * Return a new {@code StrategiesSupplier} described by the given supplier functions. All
-	 * provided supplier function parameters can be {@code null} to indicate an empty stream is to
-	 * be returned.
+	 * Return a new {@code StrategiesSupplier} with default initialization.
+	 * @return the new {@code StrategiesSupplier}
+	 */
+	static StrategiesSupplier withDefaults() {
+		return builder().build();
+	}
+
+	/**
+	 * Return a new {@code StrategiesSupplier} based on the given
+	 * {@linkplain ApplicationContext application context}.
+	 * The returned supplier will search for all {@link HttpMessageReader}, {@link HttpMessageWriter},
+	 * and {@link ViewResolver} instances in the given application context and return them for
+	 * {@link #messageReaders()}, {@link #messageWriters()}, and {@link #viewResolvers()}
+	 * respectively.
+	 * @param applicationContext the application context to base the strategies on
+	 * @return the new {@code StrategiesSupplier}
+	 */
+	static StrategiesSupplier of(ApplicationContext applicationContext) {
+		return builder(applicationContext).build();
+	}
+
+	/**
+	 * Return a new {@code StrategiesSupplier} described by the given supplier functions.
+	 * All provided supplier function parameters can be {@code null} to indicate an empty
+	 * stream is to be returned.
 	 * @param messageReaders the supplier function for {@link HttpMessageReader} instances (can be {@code null})
 	 * @param messageWriters the supplier function for {@link HttpMessageWriter} instances (can be {@code null})
 	 * @param viewResolvers the supplier function for {@link ViewResolver} instances (can be {@code null})
@@ -82,34 +106,25 @@ static StrategiesSupplier of(Supplier<Stream<HttpMessageReader<?>>> messageReade
 			public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
 				return checkForNull(messageReaders);
 			}
-
 			@Override
 			public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
 				return checkForNull(messageWriters);
 			}
-
 			@Override
 			public Supplier<Stream<ViewResolver>> viewResolvers() {
 				return checkForNull(viewResolvers);
 			}
-
 			private <T> Supplier<Stream<T>> checkForNull(Supplier<Stream<T>> supplier) {
 				return supplier != null ? supplier : Stream::empty;
 			}
 		};
 	}
 
 
-	/**
-	 * Return a mutable, empty builder for a {@code StrategiesSupplier}.
-	 * @return the builder
-	 */
-	static Builder empty() {
-		return new DefaultStrategiesSupplierBuilder();
-	}
+	// Builder methods
 
 	/**
-	 * Return a mutable builder for a {@code StrategiesSupplier} with a default initialization.
+	 * Return a mutable builder for a {@code StrategiesSupplier} with default initialization.
 	 * @return the builder
 	 */
 	static Builder builder() {
@@ -127,13 +142,21 @@ static Builder builder() {
 	 * @param applicationContext the application context to base the strategies on
 	 * @return the builder
 	 */
-	static Builder applicationContext(ApplicationContext applicationContext) {
-		Assert.notNull(applicationContext, "'applicationContext' must not be null");
+	static Builder builder(ApplicationContext applicationContext) {
+		Assert.notNull(applicationContext, "ApplicationContext must not be null");
 		DefaultStrategiesSupplierBuilder builder = new DefaultStrategiesSupplierBuilder();
 		builder.applicationContext(applicationContext);
 		return builder;
 	}
 
+	/**
+	 * Return a mutable, empty builder for a {@code StrategiesSupplier}.
+	 * @return the builder
+	 */
+	static Builder empty() {
+		return new DefaultStrategiesSupplierBuilder();
+	}
+
 
 	/**
 	 * A mutable builder for a {@link StrategiesSupplier}.
@@ -166,6 +189,6 @@ interface Builder {
 		 * @return the built strategies
 		 */
 		StrategiesSupplier build();
-
 	}
+
 }