@MatrixVariable resolvers for WebFlux

The information was already parsed and available in a request attribute
but until now there were no argument resolvers to expose it.

Issue: SPR-16005

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractNamedValueSyncArgumentResolver.java

@@ -38,13 +38,16 @@ import org.springframework.web.server.ServerWebExchange;
 public abstract class AbstractNamedValueSyncArgumentResolver extends AbstractNamedValueArgumentResolver
 		implements SyncHandlerMethodArgumentResolver {
 
+
 	/**
 	 * @param factory a bean factory to use for resolving  ${...}
 	 * placeholder and #{...} SpEL expressions in default values;
 	 * or {@code null} if default values are not expected to have expressions
 	 * @param registry for checking reactive type wrappers
 	 */
-	protected AbstractNamedValueSyncArgumentResolver(@Nullable ConfigurableBeanFactory factory, ReactiveAdapterRegistry registry) {
+	protected AbstractNamedValueSyncArgumentResolver(@Nullable ConfigurableBeanFactory factory,
+			ReactiveAdapterRegistry registry) {
+
 		super(factory, registry);
 	}
 

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/ControllerMethodResolver.java

@@ -144,6 +144,8 @@ class ControllerMethodResolver {
 		registrar.add(new RequestParamMapMethodArgumentResolver(reactiveRegistry));
 		registrar.add(new PathVariableMethodArgumentResolver(beanFactory, reactiveRegistry));
 		registrar.add(new PathVariableMapMethodArgumentResolver(reactiveRegistry));
+		registrar.add(new MatrixVariableMethodArgumentResolver(beanFactory, reactiveRegistry));
+		registrar.add(new MatrixVariableMapMethodArgumentResolver(reactiveRegistry));
 		registrar.addIfRequestBody(readers -> new RequestBodyArgumentResolver(readers, reactiveRegistry));
 		registrar.addIfRequestBody(readers -> new RequestPartMethodArgumentResolver(readers, reactiveRegistry));
 		registrar.addIfModelAttribute(() -> new ModelAttributeMethodArgumentResolver(reactiveRegistry, false));

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/MatrixVariableMapMethodArgumentResolver.java

@@ -0,0 +1,116 @@
+/*
+ * 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.web.reactive.result.method.annotation;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.core.ResolvableType;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.MatrixVariable;
+import org.springframework.web.bind.annotation.ValueConstants;
+import org.springframework.web.reactive.BindingContext;
+import org.springframework.web.reactive.HandlerMapping;
+import org.springframework.web.reactive.result.method.HandlerMethodArgumentResolverSupport;
+import org.springframework.web.reactive.result.method.SyncHandlerMethodArgumentResolver;
+import org.springframework.web.server.ServerWebExchange;
+
+/**
+ * Resolves arguments of type {@link Map} annotated with {@link MatrixVariable
+ * @MatrixVariable} where the annotation does not specify a name. In other words
+ * the purpose of this resolver is to provide access to multiple matrix
+ * variables, either all or associted with a specific path variable.
+ *
+ * <p>When a name is specified, an argument of type Map is considered to be an
+ * single attribute with a Map value, and is resolved by
+ * {@link MatrixVariableMethodArgumentResolver} instead.
+ *
+ * @author Rossen Stoyanchev
+ * @since 5.0.1
+ * @see MatrixVariableMethodArgumentResolver
+ */
+public class MatrixVariableMapMethodArgumentResolver extends HandlerMethodArgumentResolverSupport
+		implements SyncHandlerMethodArgumentResolver {
+
+
+	public MatrixVariableMapMethodArgumentResolver(ReactiveAdapterRegistry registry) {
+		super(registry);
+	}
+
+
+	@Override
+	public boolean supportsParameter(MethodParameter parameter) {
+		return checkAnnotatedParamNoReactiveWrapper(parameter, MatrixVariable.class,
+				(annot, type) -> (Map.class.isAssignableFrom(type) && !StringUtils.hasText(annot.name())));
+	}
+
+	@Nullable
+	@Override
+	public Object resolveArgumentValue(MethodParameter parameter, BindingContext bindingContext,
+			ServerWebExchange exchange) {
+
+		Map<String, MultiValueMap<String, String>> matrixVariables =
+				exchange.getAttribute(HandlerMapping.MATRIX_VARIABLES_ATTRIBUTE);
+
+		if (CollectionUtils.isEmpty(matrixVariables)) {
+			return Collections.emptyMap();
+		}
+
+		MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
+		MatrixVariable annotation = parameter.getParameterAnnotation(MatrixVariable.class);
+		Assert.state(annotation != null, "No MatrixVariable annotation");
+		String pathVariable = annotation.pathVar();
+
+		if (!pathVariable.equals(ValueConstants.DEFAULT_NONE)) {
+			MultiValueMap<String, String> mapForPathVariable = matrixVariables.get(pathVariable);
+			if (mapForPathVariable == null) {
+				return Collections.emptyMap();
+			}
+			map.putAll(mapForPathVariable);
+		}
+		else {
+			for (MultiValueMap<String, String> vars : matrixVariables.values()) {
+				for (String name : vars.keySet()) {
+					for (String value : vars.get(name)) {
+						map.add(name, value);
+					}
+				}
+			}
+		}
+
+		return (isSingleValueMap(parameter) ? map.toSingleValueMap() : map);
+	}
+
+	private boolean isSingleValueMap(MethodParameter parameter) {
+		if (!MultiValueMap.class.isAssignableFrom(parameter.getParameterType())) {
+			ResolvableType[] genericTypes = ResolvableType.forMethodParameter(parameter).getGenerics();
+			if (genericTypes.length == 2) {
+				Class<?> declaredClass = genericTypes[1].getRawClass();
+				return (declaredClass == null || !List.class.isAssignableFrom(declaredClass));
+			}
+		}
+		return false;
+	}
+
+}

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/MatrixVariableMethodArgumentResolver.java

@@ -0,0 +1,136 @@
+/*
+ * 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.web.reactive.result.method.annotation;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.MultiValueMap;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.MatrixVariable;
+import org.springframework.web.bind.annotation.ValueConstants;
+import org.springframework.web.reactive.HandlerMapping;
+import org.springframework.web.server.ServerErrorException;
+import org.springframework.web.server.ServerWebExchange;
+import org.springframework.web.server.ServerWebInputException;
+
+/**
+ * Resolves arguments annotated with {@link MatrixVariable @MatrixVariable}.
+ *
+ * <p>If the method parameter is of type {@link Map} it will by resolved by
+ * {@link MatrixVariableMapMethodArgumentResolver} instead unless the annotation
+ * specifies a name in which case it is considered to be a single attribute of
+ * type map (vs multiple attributes collected in a map).
+ *
+ * @author Rossen Stoyanchev
+ * @since 5.0.1
+ * @see MatrixVariableMapMethodArgumentResolver
+ */
+public class MatrixVariableMethodArgumentResolver extends AbstractNamedValueSyncArgumentResolver {
+
+
+	protected MatrixVariableMethodArgumentResolver(@Nullable ConfigurableBeanFactory factory,
+			ReactiveAdapterRegistry registry) {
+
+		super(factory, registry);
+	}
+
+
+	@Override
+	public boolean supportsParameter(MethodParameter parameter) {
+		return checkAnnotatedParamNoReactiveWrapper(parameter, MatrixVariable.class,
+				(annot, type) -> !Map.class.isAssignableFrom(type) || StringUtils.hasText(annot.name()));
+	}
+
+
+	@Override
+	protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
+		MatrixVariable ann = parameter.getParameterAnnotation(MatrixVariable.class);
+		Assert.state(ann != null, "No MatrixVariable annotation");
+		return new MatrixVariableNamedValueInfo(ann);
+	}
+
+	@Nullable
+	@Override
+	protected Object resolveNamedValue(String name, MethodParameter param, ServerWebExchange exchange) {
+
+		Map<String, MultiValueMap<String, String>> pathParameters =
+				exchange.getAttribute(HandlerMapping.MATRIX_VARIABLES_ATTRIBUTE);
+
+		if (CollectionUtils.isEmpty(pathParameters)) {
+			return null;
+		}
+
+		MatrixVariable ann = param.getParameterAnnotation(MatrixVariable.class);
+		Assert.state(ann != null, "No MatrixVariable annotation");
+		String pathVar = ann.pathVar();
+		List<String> paramValues = null;
+
+		if (!pathVar.equals(ValueConstants.DEFAULT_NONE)) {
+			if (pathParameters.containsKey(pathVar)) {
+				paramValues = pathParameters.get(pathVar).get(name);
+			}
+		}
+		else {
+			boolean found = false;
+			paramValues = new ArrayList<>();
+			for (MultiValueMap<String, String> params : pathParameters.values()) {
+				if (params.containsKey(name)) {
+					if (found) {
+						String paramType = param.getNestedParameterType().getName();
+						throw new ServerErrorException(
+								"Found more than one match for URI path parameter '" + name +
+								"' for parameter type [" + paramType + "]. Use 'pathVar' attribute to disambiguate.");
+					}
+					paramValues.addAll(params.get(name));
+					found = true;
+				}
+			}
+		}
+
+		if (CollectionUtils.isEmpty(paramValues)) {
+			return null;
+		}
+		else if (paramValues.size() == 1) {
+			return paramValues.get(0);
+		}
+		else {
+			return paramValues;
+		}
+	}
+
+	@Override
+	protected void handleMissingValue(String name, MethodParameter parameter) throws ServerWebInputException {
+		throw new ServerWebInputException("Missing matrix variable '" + name +
+				"' for method parameter of type " + parameter.getNestedParameterType().getSimpleName());
+	}
+
+
+	private static class MatrixVariableNamedValueInfo extends NamedValueInfo {
+
+		private MatrixVariableNamedValueInfo(MatrixVariable annotation) {
+			super(annotation.name(), annotation.required(), annotation.defaultValue());
+		}
+	}
+
+}

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

@@ -0,0 +1,99 @@
+/*
+ * 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.web.reactive.result.method.annotation;
+
+import org.junit.Test;
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpHeaders;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.MatrixVariable;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.reactive.config.EnableWebFlux;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * {@code @RequestMapping} integration focusing on controller method parameters.
+ * Also see:
+ * <ul>
+ * <li>{@link RequestMappingDataBindingIntegrationTests}
+ * <li>{@link RequestMappingMessageConversionIntegrationTests}
+ * </ul>
+ * @author Rossen Stoyanchev
+ */
+public class ControllerInputIntegrationTests extends AbstractRequestMappingIntegrationTests {
+
+
+	@Override
+	protected ApplicationContext initApplicationContext() {
+		AnnotationConfigApplicationContext wac = new AnnotationConfigApplicationContext();
+		wac.register(WebConfig.class, TestRestController.class);
+		wac.refresh();
+		return wac;
+	}
+
+
+	@Test
+	public void handleWithParam() throws Exception {
+		String expected = "Hello George!";
+		assertEquals(expected, performGet("/param?name=George", new HttpHeaders(), String.class).getBody());
+	}
+
+	@Test // SPR-15140
+	public void handleWithEncodedParam() throws Exception {
+		String expected = "Hello  + \u00e0!";
+		assertEquals(expected, performGet("/param?name=%20%2B+%C3%A0", new HttpHeaders(), String.class).getBody());
+	}
+
+	@Test
+	public void matrixVariable() throws Exception {
+		String expected = "p=11, q2=22, q4=44";
+		String url = "/first;p=11/second;q=22/third-fourth;q=44";
+		assertEquals(expected, performGet(url, new HttpHeaders(), String.class).getBody());
+	}
+
+
+	@Configuration
+	@EnableWebFlux
+	static class WebConfig {
+	}
+
+	@RestController
+	@SuppressWarnings("unused")
+	private static class TestRestController {
+
+		@GetMapping("/param")
+		public Publisher<String> param(@RequestParam String name) {
+			return Flux.just("Hello ", name, "!");
+		}
+
+		@GetMapping("/{one}/{two}/{three}-{four}")
+		public String matrixVar(
+				@MatrixVariable int p,
+				@MatrixVariable(name = "q", pathVar = "two") int q2,
+				@MatrixVariable(name = "q", pathVar = "four") int q4) {
+
+			return "p=" + p + ", q2=" + q2 + ", q4=" + q4;
+		}
+	}
+
+}

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

@@ -0,0 +1,194 @@
+/*
+ * 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.web.reactive.result.method.annotation;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
+import org.springframework.mock.web.test.server.MockServerWebExchange;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.bind.annotation.MatrixVariable;
+import org.springframework.web.method.ResolvableMethod;
+import org.springframework.web.reactive.BindingContext;
+import org.springframework.web.reactive.HandlerMapping;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.springframework.web.method.MvcAnnotationPredicates.matrixAttribute;
+
+/**
+ * Unit tests for {@link MatrixVariableMapMethodArgumentResolver}.
+ * @author Rossen Stoyanchev
+ */
+public class MatrixVariablesMapMethodArgumentResolverTests {
+
+	private final MatrixVariableMapMethodArgumentResolver resolver =
+			new MatrixVariableMapMethodArgumentResolver(new ReactiveAdapterRegistry());
+
+	private final MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/"));
+
+	private final ResolvableMethod testMethod = ResolvableMethod.on(this.getClass()).named("handle").build();
+
+
+	@Before
+	public void setUp() throws Exception {
+		this.exchange.getAttributes().put(HandlerMapping.MATRIX_VARIABLES_ATTRIBUTE, new LinkedHashMap<>());
+	}
+
+
+	@Test
+	public void supportsParameter() {
+
+		assertFalse(this.resolver.supportsParameter(this.testMethod.arg(String.class)));
+
+		assertTrue(this.resolver.supportsParameter(this.testMethod.annot(matrixAttribute().noName())
+				.arg(Map.class, String.class, String.class)));
+
+		assertTrue(this.resolver.supportsParameter(this.testMethod.annot(matrixAttribute().noPathVar())
+				.arg(MultiValueMap.class, String.class, String.class)));
+
+		assertTrue(this.resolver.supportsParameter(this.testMethod.annot(matrixAttribute().pathVar("cars"))
+				.arg(MultiValueMap.class, String.class, String.class)));
+
+		assertFalse(this.resolver.supportsParameter(this.testMethod.annot(matrixAttribute().name("name"))
+				.arg(Map.class, String.class, String.class)));
+	}
+
+	@Test
+	public void resolveArgument() throws Exception {
+		MultiValueMap<String, String> params = getMatrixVariables("cars");
+		params.add("colors", "red");
+		params.add("colors", "green");
+		params.add("colors", "blue");
+		params.add("year", "2012");
+
+		MethodParameter param = this.testMethod.annot(matrixAttribute().noName())
+				.arg(Map.class, String.class, String.class);
+
+		@SuppressWarnings("unchecked")
+		Map<String, String> map =
+				(Map<String, String>) this.resolver.resolveArgument(
+						param, new BindingContext(), this.exchange).block(Duration.ZERO);
+
+		assertNotNull(map);
+		assertEquals("red", map.get("colors"));
+
+		param = this.testMethod
+				.annot(matrixAttribute().noPathVar())
+				.arg(MultiValueMap.class, String.class, String.class);
+
+		@SuppressWarnings("unchecked")
+		MultiValueMap<String, String> multivalueMap =
+				(MultiValueMap<String, String>) this.resolver.resolveArgument(
+						param, new BindingContext(), this.exchange).block(Duration.ZERO);
+
+		assertEquals(Arrays.asList("red", "green", "blue"), multivalueMap.get("colors"));
+	}
+
+	@Test
+	public void resolveArgumentPathVariable() throws Exception {
+		MultiValueMap<String, String> params1 = getMatrixVariables("cars");
+		params1.add("colors", "red");
+		params1.add("colors", "purple");
+
+		MultiValueMap<String, String> params2 = getMatrixVariables("planes");
+		params2.add("colors", "yellow");
+		params2.add("colors", "orange");
+
+		MethodParameter param = this.testMethod.annot(matrixAttribute().pathVar("cars"))
+				.arg(MultiValueMap.class, String.class, String.class);
+
+		@SuppressWarnings("unchecked")
+		Map<String, String> mapForPathVar = (Map<String, String>)
+				this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+
+		assertNotNull(mapForPathVar);
+		assertEquals(Arrays.asList("red", "purple"), mapForPathVar.get("colors"));
+
+		param = this.testMethod.annot(matrixAttribute().noName()).arg(Map.class, String.class, String.class);
+
+		@SuppressWarnings("unchecked")
+		Map<String, String> mapAll = (Map<String, String>)
+				this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+
+		assertNotNull(mapAll);
+		assertEquals("red", mapAll.get("colors"));
+	}
+
+	@Test
+	public void resolveArgumentNoParams() throws Exception {
+
+		MethodParameter param = this.testMethod.annot(matrixAttribute().noName())
+				.arg(Map.class, String.class, String.class);
+
+		@SuppressWarnings("unchecked")
+		Map<String, String> map = (Map<String, String>)
+				this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+
+		assertEquals(Collections.emptyMap(), map);
+	}
+
+	@Test
+	public void resolveArgumentNoMatch() throws Exception {
+		MultiValueMap<String, String> params2 = getMatrixVariables("planes");
+		params2.add("colors", "yellow");
+		params2.add("colors", "orange");
+
+		MethodParameter param = this.testMethod.annot(matrixAttribute().pathVar("cars"))
+				.arg(MultiValueMap.class, String.class, String.class);
+
+		@SuppressWarnings("unchecked")
+		Map<String, String> map = (Map<String, String>) this.resolver.resolveArgument(
+				param, new BindingContext(), this.exchange).block(Duration.ZERO);
+
+		assertEquals(Collections.emptyMap(), map);
+	}
+
+
+	@SuppressWarnings("unchecked")
+	private MultiValueMap<String, String> getMatrixVariables(String pathVarName) {
+		Map<String, MultiValueMap<String, String>> matrixVariables =
+				this.exchange.getAttribute(HandlerMapping.MATRIX_VARIABLES_ATTRIBUTE);
+
+		MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+		matrixVariables.put(pathVarName, params);
+
+		return params;
+	}
+
+
+	@SuppressWarnings("unused")
+	void handle(
+			String stringArg,
+			@MatrixVariable Map<String, String> map,
+			@MatrixVariable MultiValueMap<String, String> multivalueMap,
+			@MatrixVariable(pathVar="cars") MultiValueMap<String, String> mapForPathVar,
+			@MatrixVariable("name") Map<String, String> mapWithName) {
+	}
+
+}

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

@@ -0,0 +1,149 @@
+/*
+ * 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.web.reactive.result.method.annotation;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
+import org.springframework.mock.web.test.server.MockServerWebExchange;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.bind.annotation.MatrixVariable;
+import org.springframework.web.method.ResolvableMethod;
+import org.springframework.web.reactive.BindingContext;
+import org.springframework.web.reactive.HandlerMapping;
+import org.springframework.web.server.ServerErrorException;
+import org.springframework.web.server.ServerWebInputException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.springframework.web.method.MvcAnnotationPredicates.matrixAttribute;
+
+/**
+ * Unit tests for {@link MatrixVariableMethodArgumentResolver}.
+ * @author Rossen Stoyanchev
+ */
+public class MatrixVariablesMethodArgumentResolverTests {
+
+	private MatrixVariableMethodArgumentResolver resolver =
+			new MatrixVariableMethodArgumentResolver(null, new ReactiveAdapterRegistry());
+
+	private final MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/"));
+
+	private ResolvableMethod testMethod = ResolvableMethod.on(this.getClass()).named("handle").build();
+
+
+	@Before
+	public void setUp() throws Exception {
+		this.exchange.getAttributes().put(HandlerMapping.MATRIX_VARIABLES_ATTRIBUTE, new LinkedHashMap<>());
+	}
+
+
+	@Test
+	public void supportsParameter() {
+
+		assertFalse(this.resolver.supportsParameter(this.testMethod.arg(String.class)));
+
+		assertTrue(this.resolver.supportsParameter(this.testMethod
+				.annot(matrixAttribute().noName()).arg(List.class, String.class)));
+
+		assertTrue(this.resolver.supportsParameter(this.testMethod
+				.annot(matrixAttribute().name("year")).arg(int.class)));
+	}
+
+	@Test
+	public void resolveArgument() throws Exception {
+		MultiValueMap<String, String> params = getVariablesFor("cars");
+		params.add("colors", "red");
+		params.add("colors", "green");
+		params.add("colors", "blue");
+		MethodParameter param = this.testMethod.annot(matrixAttribute().noName()).arg(List.class, String.class);
+
+		assertEquals(Arrays.asList("red", "green", "blue"),
+				this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO));
+	}
+
+	@Test
+	public void resolveArgumentPathVariable() throws Exception {
+		getVariablesFor("cars").add("year", "2006");
+		getVariablesFor("bikes").add("year", "2005");
+		MethodParameter param = this.testMethod.annot(matrixAttribute().name("year")).arg(int.class);
+
+		Object actual = this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+		assertEquals(2006, actual);
+	}
+
+	@Test
+	public void resolveArgumentDefaultValue() throws Exception {
+		MethodParameter param = this.testMethod.annot(matrixAttribute().name("year")).arg(int.class);
+		Object actual = this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+		assertEquals(2013, actual);
+	}
+
+	@Test(expected = ServerErrorException.class)
+	public void resolveArgumentMultipleMatches() throws Exception {
+		getVariablesFor("var1").add("colors", "red");
+		getVariablesFor("var2").add("colors", "green");
+
+		MethodParameter param = this.testMethod.annot(matrixAttribute().noName()).arg(List.class, String.class);
+		this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+	}
+
+	@Test(expected = ServerWebInputException.class)
+	public void resolveArgumentRequired() throws Exception {
+		MethodParameter param = this.testMethod.annot(matrixAttribute().noName()).arg(List.class, String.class);
+		this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+	}
+
+	@Test
+	public void resolveArgumentNoMatch() throws Exception {
+		MultiValueMap<String, String> params = getVariablesFor("cars");
+		params.add("anotherYear", "2012");
+		MethodParameter param = this.testMethod.annot(matrixAttribute().name("year")).arg(int.class);
+
+		Object actual = this.resolver.resolveArgument(param, new BindingContext(), this.exchange).block(Duration.ZERO);
+		assertEquals(2013, actual);
+	}
+
+	@SuppressWarnings("unchecked")
+	private MultiValueMap<String, String> getVariablesFor(String pathVarName) {
+		Map<String, MultiValueMap<String, String>> matrixVariables =
+				this.exchange.getAttribute(HandlerMapping.MATRIX_VARIABLES_ATTRIBUTE);
+
+		MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
+		matrixVariables.put(pathVarName, params);
+		return params;
+	}
+
+
+	@SuppressWarnings("unused")
+	void handle(
+			String stringArg,
+			@MatrixVariable List<String> colors,
+			@MatrixVariable(name = "year", pathVar = "cars", required = false, defaultValue = "2013") int preferredYear) {
+	}
+
+}

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

@@ -26,13 +26,13 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpHeaders;
-import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.reactive.config.EnableWebFlux;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 
 /**
  * Integration tests with {@code @RequestMapping} handler methods.
@@ -55,40 +55,23 @@ public class RequestMappingIntegrationTests extends AbstractRequestMappingIntegr
 	}
 
 
-	@Test
-	public void handleWithParam() throws Exception {
-		String expected = "Hello George!";
-		assertEquals(expected, performGet("/param?name=George", new HttpHeaders(), String.class).getBody());
-	}
-
-	@Test // SPR-15140
-	public void handleWithEncodedParam() throws Exception {
-		String expected = "Hello  + \u00e0!";
-		assertEquals(expected, performGet("/param?name=%20%2B+%C3%A0", new HttpHeaders(), String.class).getBody());
-	}
-
-	@Test
-	public void longStreamResult() throws Exception {
-		String[] expected = {"0", "1", "2", "3", "4"};
-		assertArrayEquals(expected, performGet("/long-stream-result", new HttpHeaders(), String[].class).getBody());
-	}
-
-	@Test
-	public void objectStreamResultWithAllMediaType() throws Exception {
-		String expected = "[{\"name\":\"bar\"}]";
-		assertEquals(expected, performGet("/object-stream-result", MediaType.ALL, String.class).getBody());
-	}
-
 	@Test
 	public void httpHead() throws Exception {
-		String url = "http://localhost:" + this.port + "/param?name=George";
+		String url = "http://localhost:" + this.port + "/text";
 		HttpHeaders headers = getRestTemplate().headForHeaders(url);
 		String contentType = headers.getFirst("Content-Type");
 		assertNotNull(contentType);
 		assertEquals("text/html;charset=utf-8", contentType.toLowerCase());
-		assertEquals(13, headers.getContentLength());
+		assertEquals(3, headers.getContentLength());
 	}
 
+	@Test
+	public void stream() throws Exception {
+		String[] expected = {"0", "1", "2", "3", "4"};
+		assertArrayEquals(expected, performGet("/stream", new HttpHeaders(), String[].class).getBody());
+	}
+
+
 	@Configuration
 	@EnableWebFlux
 	static class WebConfig {
@@ -96,41 +79,17 @@ public class RequestMappingIntegrationTests extends AbstractRequestMappingIntegr
 
 
 	@RestController
+	@SuppressWarnings("unused")
 	private static class TestRestController {
 
-		@GetMapping("/param")
-		public Publisher<String> handleWithParam(@RequestParam String name) {
-			return Flux.just("Hello ", name, "!");
+		@GetMapping("/text")
+		public String text() {
+			return "Foo";
 		}
 
-		@GetMapping("/long-stream-result")
-		public Publisher<Long> longStreamResponseBody() {
-			return Flux.interval(Duration.ofMillis(100)).take(5);
-		}
-
-		@GetMapping("/object-stream-result")
-		public Publisher<Foo> objectStreamResponseBody() {
-			return Flux.just(new Foo("bar"));
-		}
-	}
-
-
-	private static class Foo {
-
-		private String name;
-
-		public Foo(String name) {
-			this.name = name;
-		}
-
-		@SuppressWarnings("unused")
-		public String getName() {
-			return name;
-		}
-
-		@SuppressWarnings("unused")
-		public void setName(String name) {
-			this.name = name;
+		@GetMapping("/stream")
+		public Publisher<Long> stream() {
+			return Flux.interval(Duration.ofMillis(50)).take(5);
 		}
 	}