Polishing.

Imports, Javadoc, ticket references in test cases.

Removed the need for MethodParameterAware… flavors of the ResourceAssemblers by keeping the MethodParameter reference in the original assemblers in the first place. Extracted common Pageable MethodParameter lookup code into PageableMethodParameterUtils.

Related ticket: #1307.

Author: odrotbohm

Diff for: src/main/java/org/springframework/data/web/MethodParameterAwarePagedResourcesAssembler.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2023 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
+ *
+ *      https://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.data.web;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.core.MethodParameter;
+import org.springframework.core.log.LogMessage;
+import org.springframework.data.domain.Pageable;
+import org.springframework.hateoas.server.core.MethodParameters;
+import org.springframework.lang.Nullable;
+
+/**
+ * Utility methods to obtain a {@link MethodParameter} of type {@link Pageable} with the same {@link Qualifier}.
+ *
+ * @author Oliver Drotbohm
+ * @since 3.1
+ * @soundtrack The Intersphere - Wanderer (https://www.youtube.com/watch?v=Sp_VyFBbDPA)
+ */
+class PageableMethodParameterUtils {
+
+	private static final Log logger = LogFactory.getLog(PageableMethodParameterUtils.class);
+
+	private static final String SUPERFLOUS_QUALIFIER = "Found qualified %s parameter, but a unique unqualified %s parameter; Using that one, but you might want to check your controller method configuration";
+	private static final String PARAMETER_AMBIGUITY = "Discovered multiple parameters of type Pageable but no qualifier annotations to disambiguate";
+
+	/**
+	 * Returns finds the {@link MethodParameter} for a {@link Pageable} instance matching the given
+	 * {@link MethodParameter} requesting a {@link PagedResourcesAssembler}.
+	 *
+	 * @param parameter must not be {@literal null}.
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	static MethodParameter findMatchingPageableParameter(MethodParameter parameter) {
+
+		Method method = parameter.getMethod();
+
+		if (method == null) {
+			throw new IllegalArgumentException(String.format("Could not obtain method from parameter %s", parameter));
+		}
+
+		MethodParameters parameters = MethodParameters.of(method);
+		List<MethodParameter> pageableParameters = parameters.getParametersOfType(Pageable.class);
+		Qualifier assemblerQualifier = parameter.getParameterAnnotation(Qualifier.class);
+
+		if (pageableParameters.isEmpty()) {
+			return null;
+		}
+
+		if (pageableParameters.size() == 1) {
+
+			MethodParameter pageableParameter = pageableParameters.get(0);
+			MethodParameter matchingParameter = returnIfQualifiersMatch(pageableParameter, assemblerQualifier);
+
+			if (matchingParameter == null) {
+				logger.info(LogMessage.format(SUPERFLOUS_QUALIFIER, PagedResourcesAssembler.class.getSimpleName(),
+						Pageable.class.getName()));
+			}
+
+			return pageableParameter;
+		}
+
+		if (assemblerQualifier == null) {
+			throw new IllegalStateException(PARAMETER_AMBIGUITY);
+		}
+
+		for (MethodParameter pageableParameter : pageableParameters) {
+
+			MethodParameter matchingParameter = returnIfQualifiersMatch(pageableParameter, assemblerQualifier);
+
+			if (matchingParameter != null) {
+				return matchingParameter;
+			}
+		}
+
+		throw new IllegalStateException(PARAMETER_AMBIGUITY);
+	}
+
+	@Nullable
+	private static MethodParameter returnIfQualifiersMatch(MethodParameter pageableParameter,
+			@Nullable Qualifier assemblerQualifier) {
+
+		if (assemblerQualifier == null) {
+			return pageableParameter;
+		}
+
+		Qualifier pageableParameterQualifier = pageableParameter.getParameterAnnotation(Qualifier.class);
+
+		return pageableParameterQualifier != null
+				? pageableParameterQualifier.value().equals(assemblerQualifier.value()) ? pageableParameter : null
+				: null;
+	}
+}

Diff for: src/main/java/org/springframework/data/web/MethodParameterAwareSlicedResourcesAssembler.java

@@ -58,6 +58,7 @@ public class PagedResourcesAssembler<T> implements RepresentationModelAssembler<
 	private final EmbeddedWrappers wrappers = new EmbeddedWrappers(false);
 
 	private boolean forceFirstAndLastRels = false;
+	private @Nullable MethodParameter parameter;
 
 	/**
 	 * Creates a new {@link PagedResourcesAssembler} using the given {@link PageableHandlerMethodArgumentResolver} and
@@ -69,9 +70,15 @@ public class PagedResourcesAssembler<T> implements RepresentationModelAssembler<
 	 */
 	public PagedResourcesAssembler(@Nullable HateoasPageableHandlerMethodArgumentResolver resolver,
 			@Nullable UriComponents baseUri) {
+		this(resolver, Optional.ofNullable(baseUri), null);
+	}
+
+	private PagedResourcesAssembler(@Nullable HateoasPageableHandlerMethodArgumentResolver resolver,
+			Optional<UriComponents> baseUri, @Nullable MethodParameter parameter) {
 
 		this.pageableResolver = resolver == null ? new HateoasPageableHandlerMethodArgumentResolver() : resolver;
-		this.baseUri = Optional.ofNullable(baseUri);
+		this.baseUri = baseUri;
+		this.parameter = parameter;
 	}
 
 	/**
@@ -87,6 +94,17 @@ public void setForceFirstAndLastRels(boolean forceFirstAndLastRels) {
 		this.forceFirstAndLastRels = forceFirstAndLastRels;
 	}
 
+	/**
+	 * Creates a new {@link PagedResourcesAssembler} with the given reference {@link MethodParameter}.
+	 *
+	 * @param parameter can be {@literal null}.
+	 * @return will never be {@literal null}.
+	 * @since 3.1
+	 */
+	public PagedResourcesAssembler<T> withParameter(@Nullable MethodParameter parameter) {
+		return new PagedResourcesAssembler<>(pageableResolver, baseUri, parameter);
+	}
+
 	@Override
 	public PagedModel<EntityModel<T>> toModel(Page<T> entity) {
 		return toModel(entity, EntityModel::of);
@@ -267,7 +285,7 @@ private UriTemplate getUriTemplate(Optional<Link> baseLink) {
 	private Link createLink(UriTemplate base, Pageable pageable, LinkRelation relation) {
 
 		UriComponentsBuilder builder = fromUri(base.expand());
-		pageableResolver.enhance(builder, getMethodParameter(), pageable);
+		pageableResolver.enhance(builder, parameter, pageable);
 
 		return Link.of(UriTemplate.of(builder.build().toString()), relation);
 	}
@@ -278,8 +296,10 @@ private Link createLink(UriTemplate base, Pageable pageable, LinkRelation relati
 	 *
 	 * @return
 	 * @since 1.7
+	 * @deprecated since 3.1, rather set up the instance with {@link #withParameter(MethodParameter)}.
 	 */
 	@Nullable
+	@Deprecated(since = "3.1", forRemoval = true)
 	protected MethodParameter getMethodParameter() {
 		return null;
 	}