Support RouterFunction in @EnableWebFlux

This commit removes the RouterFunctions.toHandlerMapping method, in
favor of native support for RouterFunctions in @EnableWebFlux
configuration classes.

In order to accomplish this, the HandlerStrategies components has been
repurposed to only be used for the "bare-bones" HttpHandler, while the
(newly introduced) RouterFunctionMapping uses the strategies as exposed
through WebFluxConfigurationSupport.

Furthermore, this commit also introduces support for testing
RouterFunctions without resorting to an application context.

Issue: SPR-15536

Author: poutsma

spring-test/src/main/java/org/springframework/test/web/reactive/server/DefaultRouterFunctionSpec.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.test.web.reactive.server;
+
+import org.springframework.web.reactive.function.server.HandlerStrategies;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+import org.springframework.web.server.WebHandler;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+
+/**
+ * Spec for setting up server-less testing against a RouterFunction.
+ *
+ * @author Arjen Poutsma
+ * @since 5.0
+ */
+class DefaultRouterFunctionSpec extends AbstractMockServerSpec<WebTestClient.RouterFunctionSpec>
+		implements WebTestClient.RouterFunctionSpec {
+
+	private final RouterFunction<?> routerFunction;
+
+	private HandlerStrategies handlerStrategies = HandlerStrategies.withDefaults();
+
+
+	DefaultRouterFunctionSpec(RouterFunction<?> routerFunction) {
+		this.routerFunction = routerFunction;
+	}
+
+
+	@Override
+	public WebTestClient.RouterFunctionSpec handlerStrategies(HandlerStrategies handlerStrategies) {
+		if (handlerStrategies != null) {
+			this.handlerStrategies = handlerStrategies;
+		}
+		return this;
+	}
+
+	@Override
+	protected WebHttpHandlerBuilder initHttpHandlerBuilder() {
+		WebHandler webHandler = RouterFunctions.toWebHandler(this.routerFunction, this.handlerStrategies);
+		return WebHttpHandlerBuilder.webHandler(webHandler);
+	}
+
+}

spring-test/src/main/java/org/springframework/test/web/reactive/server/RouterFunctionSpec.java

@@ -48,6 +48,7 @@
 import org.springframework.web.reactive.function.client.ExchangeFunction;
 import org.springframework.web.reactive.function.client.ExchangeStrategies;
 import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.reactive.function.server.HandlerStrategies;
 import org.springframework.web.reactive.function.server.RouterFunction;
 import org.springframework.web.reactive.result.method.annotation.ArgumentResolverConfigurer;
 import org.springframework.web.server.ServerWebExchange;
@@ -169,8 +170,8 @@ static MockServerSpec<?> bindToApplicationContext(ApplicationContext application
 	 * @param routerFunction the RouterFunction to test
 	 * @return the {@link WebTestClient} builder
 	 */
-	static MockServerSpec<?> bindToRouterFunction(RouterFunction<?> routerFunction) {
-		return new RouterFunctionSpec(routerFunction);
+	static RouterFunctionSpec bindToRouterFunction(RouterFunction<?> routerFunction) {
+		return new DefaultRouterFunctionSpec(routerFunction);
 	}
 
 	/**
@@ -285,6 +286,18 @@ interface ControllerSpec extends MockServerSpec<ControllerSpec> {
 
 	}
 
+	/**
+	 * Specification for customizing router function configuration.
+	 */
+	interface RouterFunctionSpec extends MockServerSpec<RouterFunctionSpec> {
+
+		/**
+		 * Configure handler strategies.
+		 */
+		RouterFunctionSpec handlerStrategies(HandlerStrategies handlerStrategies);
+
+	}
+
 	/**
 	 * Steps for customizing the {@link WebClient} used to test with
 	 * internally delegating to a {@link WebClient.Builder}.

spring-test/src/main/java/org/springframework/test/web/reactive/server/WebTestClient.java

@@ -47,6 +47,9 @@
 import org.springframework.web.reactive.HandlerMapping;
 import org.springframework.web.reactive.accept.CompositeContentTypeResolver;
 import org.springframework.web.reactive.accept.RequestedContentTypeResolverBuilder;
+import org.springframework.web.reactive.function.server.support.HandlerFunctionAdapter;
+import org.springframework.web.reactive.function.server.support.RouterFunctionMapping;
+import org.springframework.web.reactive.function.server.support.ServerResponseResultHandler;
 import org.springframework.web.reactive.handler.AbstractHandlerMapping;
 import org.springframework.web.reactive.result.SimpleHandlerAdapter;
 import org.springframework.web.reactive.result.method.annotation.ArgumentResolverConfigurer;
@@ -81,6 +84,8 @@ public class WebFluxConfigurationSupport implements ApplicationContextAware {
 
 	private PathMatchConfigurer pathMatchConfigurer;
 
+	private ViewResolverRegistry viewResolverRegistry;
+
 	private ApplicationContext applicationContext;
 
 
@@ -203,6 +208,23 @@ protected final PathMatchConfigurer getPathMatchConfigurer() {
 	public void configurePathMatching(PathMatchConfigurer configurer) {
 	}
 
+	@Bean
+	public RouterFunctionMapping routerFunctionMapping() {
+		RouterFunctionMapping mapping = createRouterFunctionMapping();
+		mapping.setOrder(-1); // go before RequestMappingHandlerMapping
+		mapping.setMessageCodecConfigurer(serverCodecConfigurer());
+		mapping.setCorsConfigurations(getCorsConfigurations());
+
+		return mapping;
+	}
+
+	/**
+	 * Override to plug a sub-class of {@link RouterFunctionMapping}.
+	 */
+	protected RouterFunctionMapping createRouterFunctionMapping() {
+		return new RouterFunctionMapping();
+	}
+
 	/**
 	 * Return a handler mapping ordered at Integer.MAX_VALUE-1 with mapped
 	 * resource handlers. To configure resource handling, override
@@ -362,6 +384,11 @@ protected MessageCodesResolver getMessageCodesResolver() {
 		return null;
 	}
 
+	@Bean
+	public HandlerFunctionAdapter handlerFunctionAdapter() {
+		return new HandlerFunctionAdapter();
+	}
+
 	@Bean
 	public SimpleHandlerAdapter simpleHandlerAdapter() {
 		return new SimpleHandlerAdapter();
@@ -381,15 +408,38 @@ public ResponseBodyResultHandler responseBodyResultHandler() {
 
 	@Bean
 	public ViewResolutionResultHandler viewResolutionResultHandler() {
-		ViewResolverRegistry registry = new ViewResolverRegistry(getApplicationContext());
-		configureViewResolvers(registry);
+		ViewResolverRegistry registry = getViewResolverRegistry();
 		List<ViewResolver> resolvers = registry.getViewResolvers();
 		ViewResolutionResultHandler handler = new ViewResolutionResultHandler(
 				resolvers, webFluxContentTypeResolver(), webFluxAdapterRegistry());
 		handler.setDefaultViews(registry.getDefaultViews());
 		handler.setOrder(registry.getOrder());
 		return handler;
+	}
+
+	@Bean
+	public ServerResponseResultHandler serverResponseResultHandler() {
+		ViewResolverRegistry registry = getViewResolverRegistry();
+		List<ViewResolver> resolvers = registry.getViewResolvers();
+
+		ServerResponseResultHandler handler = new ServerResponseResultHandler();
+		handler.setMessageCodecConfigurer(serverCodecConfigurer());
+		handler.setViewResolvers(resolvers);
+		handler.setOrder(registry.getOrder() + 1);
+
+		return handler;
+	}
 
+	/**
+	 * Callback for building the {@link ViewResolverRegistry}. This method is final,
+	 * use {@link #configureViewResolvers} to customize view resolvers.
+	 */
+	protected final ViewResolverRegistry getViewResolverRegistry() {
+		if (this.viewResolverRegistry == null) {
+			this.viewResolverRegistry = new ViewResolverRegistry(getApplicationContext());
+			configureViewResolvers(this.viewResolverRegistry);
+		}
+		return this.viewResolverRegistry;
 	}
 
 	/**

spring-webflux/src/main/java/org/springframework/web/reactive/config/WebFluxConfigurationSupport.java

@@ -203,13 +203,13 @@ public T entity() {
 		}
 
 		@Override
-		public Mono<Void> writeTo(ServerWebExchange exchange, HandlerStrategies strategies) {
+		public Mono<Void> writeTo(ServerWebExchange exchange, Context context) {
 			ServerHttpResponse response = exchange.getResponse();
 			writeStatusAndHeaders(response);
 			return inserter().insert(response, new BodyInserter.Context() {
 				@Override
 				public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
-					return strategies.messageWriters();
+					return context.messageWriters();
 				}
 
 				@Override

spring-webflux/src/main/java/org/springframework/web/reactive/function/server/DefaultEntityResponseBuilder.java

@@ -19,10 +19,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Locale;
-import java.util.Optional;
 import java.util.function.Consumer;
-import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
@@ -44,18 +41,10 @@
  */
 class DefaultHandlerStrategiesBuilder implements HandlerStrategies.Builder {
 
-	static final Function<ServerRequest, Optional<Locale>> DEFAULT_LOCALE_RESOLVER =
-			request -> request.headers().acceptLanguage().stream()
-					.map(Locale.LanguageRange::getRange)
-					.map(Locale::forLanguageTag).findFirst();
-
-
 	private final ServerCodecConfigurer codecConfigurer = ServerCodecConfigurer.create();
 
 	private final List<ViewResolver> viewResolvers = new ArrayList<>();
 
-	private Function<ServerRequest, Optional<Locale>> localeResolver;
-
 	private final List<WebFilter> webFilters = new ArrayList<>();
 
 	private final List<WebExceptionHandler> exceptionHandlers = new ArrayList<>();
@@ -67,7 +56,6 @@ public DefaultHandlerStrategiesBuilder() {
 
 	public void defaultConfiguration() {
 		this.codecConfigurer.registerDefaults(true);
-		localeResolver(DEFAULT_LOCALE_RESOLVER);
 		exceptionHandler(new ResponseStatusExceptionHandler());
 	}
 
@@ -94,13 +82,6 @@ public HandlerStrategies.Builder viewResolver(ViewResolver viewResolver) {
 		return this;
 	}
 
-	@Override
-	public HandlerStrategies.Builder localeResolver(Function<ServerRequest, Optional<Locale>> localeResolver) {
-		Assert.notNull(localeResolver, "'localeResolver' must not be null");
-		this.localeResolver = localeResolver;
-		return this;
-	}
-
 	@Override
 	public HandlerStrategies.Builder webFilter(WebFilter filter) {
 		Assert.notNull(filter, "'filter' must not be null");
@@ -118,8 +99,8 @@ public HandlerStrategies.Builder exceptionHandler(WebExceptionHandler exceptionH
 	@Override
 	public HandlerStrategies build() {
 		return new DefaultHandlerStrategies(this.codecConfigurer.getReaders(),
-				this.codecConfigurer.getWriters(), this.viewResolvers, this.localeResolver,
-				this.webFilters, this.exceptionHandlers);
+				this.codecConfigurer.getWriters(), this.viewResolvers, this.webFilters,
+				this.exceptionHandlers);
 	}
 
 
@@ -131,8 +112,6 @@ private static class DefaultHandlerStrategies implements HandlerStrategies {
 
 		private final List<ViewResolver> viewResolvers;
 
-		private final Function<ServerRequest, Optional<Locale>> localeResolver;
-
 		private final List<WebFilter> webFilters;
 
 		private final List<WebExceptionHandler> exceptionHandlers;
@@ -141,14 +120,12 @@ public DefaultHandlerStrategies(
 				List<HttpMessageReader<?>> messageReaders,
 				List<HttpMessageWriter<?>> messageWriters,
 				List<ViewResolver> viewResolvers,
-				Function<ServerRequest, Optional<Locale>> localeResolver,
 				List<WebFilter> webFilters,
 				List<WebExceptionHandler> exceptionHandlers) {
 
 			this.messageReaders = unmodifiableCopy(messageReaders);
 			this.messageWriters = unmodifiableCopy(messageWriters);
 			this.viewResolvers = unmodifiableCopy(viewResolvers);
-			this.localeResolver = localeResolver;
 			this.webFilters = unmodifiableCopy(webFilters);
 			this.exceptionHandlers = unmodifiableCopy(exceptionHandlers);
 		}
@@ -172,11 +149,6 @@ public Supplier<Stream<ViewResolver>> viewResolvers() {
 			return this.viewResolvers::stream;
 		}
 
-		@Override
-		public Supplier<Function<ServerRequest, Optional<Locale>>> localeResolver() {
-			return () -> this.localeResolver;
-		}
-
 		@Override
 		public Supplier<Stream<WebFilter>> webFilters() {
 			return this.webFilters::stream;