Use RepositoryMetadata for Parameters construction.

mp911de · mp911de · commit 6feecb0711fa · 2023-12-04T16:02:46.000+01:00
diff --git a/src/main/java/org/springframework/data/repository/query/DefaultParameters.java b/src/main/java/org/springframework/data/repository/query/DefaultParameters.java
@@ -20,6 +20,7 @@
 import java.util.function.IntFunction;
 
 import org.springframework.core.MethodParameter;
+import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.util.TypeInformation;
 
 /**
@@ -44,28 +45,26 @@ public DefaultParameters(Method method) {
 	 * Creates a new {@link DefaultParameters} instance from the given {@link Method} and aggregate
 	 * {@link TypeInformation}. Note that this constructor uses a {@link IntFunction MethodParameterFactory} that doesn't
 	 * resolve generic method parameter types that are declared on the containing class. Use
-	 * {@link DefaultParameters#DefaultParameters(Method, IntFunction, TypeInformation)} with a
-	 * {@link MethodParameter#withContainingClass(Class) contextual factory} to ensure proper gerneric resolution.
+	 * {@link DefaultParameters#DefaultParameters(RepositoryMetadata, Method)} with a
+	 * {@link MethodParameter#withContainingClass(Class) contextual factory} to ensure proper generic resolution.
 	 *
 	 * @param method must not be {@literal null}.
 	 * @param aggregateType must not be {@literal null}.
 	 */
 	public DefaultParameters(Method method, TypeInformation<?> aggregateType) {
-		this(method, index -> new MethodParameter(method, index), aggregateType);
+		super(method, param -> new Parameter(param, aggregateType));
 	}
 
 	/**
 	 * Creates a new {@link DefaultParameters} instance from the given {@link Method} and aggregate
 	 * {@link TypeInformation}.
 	 *
+	 * @param metadata must not be {@literal null}.
 	 * @param method must not be {@literal null}.
-	 * @param parameterFactory must not be {@literal null}.
-	 * @param aggregateType must not be {@literal null}.
 	 * @since 3.2.1
 	 */
-	public DefaultParameters(Method method, IntFunction<MethodParameter> parameterFactory,
-			TypeInformation<?> aggregateType) {
-		super(method, parameterFactory, param -> new Parameter(param, aggregateType));
+	public DefaultParameters(RepositoryMetadata metadata, Method method) {
+		super(metadata, method, param -> new Parameter(param, metadata.getDomainTypeInformation()));
 	}
 
 	private DefaultParameters(List<Parameter> parameters) {
diff --git a/src/main/java/org/springframework/data/repository/query/Parameters.java b/src/main/java/org/springframework/data/repository/query/Parameters.java
@@ -23,7 +23,6 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Function;
-import java.util.function.IntFunction;
 
 import org.springframework.core.DefaultParameterNameDiscoverer;
 import org.springframework.core.MethodParameter;
@@ -32,6 +31,7 @@
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.ScrollPosition;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.util.Lazy;
 import org.springframework.data.util.Streamable;
 import org.springframework.util.Assert;
@@ -84,21 +84,23 @@ public Parameters(Method method) {
 	 * @param method must not be {@literal null}.
 	 * @param parameterFactory must not be {@literal null}.
 	 * @since 3.0.2
+	 * @deprecated since 3.2.1, use {@link Parameters(RepositoryMetadata, Method, Function)} instead.
 	 */
+	@Deprecated(since = "3.2.1", forRemoval = true)
 	protected Parameters(Method method, Function<MethodParameter, T> parameterFactory) {
-		this(method, index -> new MethodParameter(method, index), parameterFactory);
+		this(null, method, parameterFactory);
 	}
 
 	/**
 	 * Creates a new {@link Parameters} instance for the given {@link Method} and {@link Function} to create a
 	 * {@link Parameter} instance from a {@link MethodParameter}.
 	 *
+	 * @param repositoryMetadata must not be {@literal null}.
 	 * @param method must not be {@literal null}.
-	 * @param methodParameterFactory must not be {@literal null}.
 	 * @param parameterFactory must not be {@literal null}.
 	 * @since 3.2.1
 	 */
-	protected Parameters(Method method, IntFunction<MethodParameter> methodParameterFactory,
+	protected Parameters(RepositoryMetadata repositoryMetadata, Method method,
 			Function<MethodParameter, T> parameterFactory) {
 
 		Assert.notNull(method, "Method must not be null");
@@ -118,7 +120,11 @@ protected Parameters(Method method, IntFunction<MethodParameter> methodParameter
 
 		for (int i = 0; i < parameterCount; i++) {
 
-			MethodParameter methodParameter = methodParameterFactory.apply(i);
+			MethodParameter methodParameter = new MethodParameter(method, i);
+
+			if (repositoryMetadata != null) {
+				methodParameter = methodParameter.withContainingClass(repositoryMetadata.getRepositoryInterface());
+			}
 
 			methodParameter.initParameterNameDiscovery(PARAMETER_NAME_DISCOVERER);
 
diff --git a/src/main/java/org/springframework/data/repository/query/QueryMethod.java b/src/main/java/org/springframework/data/repository/query/QueryMethod.java
@@ -20,11 +20,9 @@
 import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.Set;
-import java.util.function.IntFunction;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 
-import org.springframework.core.MethodParameter;
 import org.springframework.data.domain.Limit;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
@@ -63,7 +61,6 @@ public class QueryMethod {
 	private final ResultProcessor resultProcessor;
 	private final Lazy<Class<?>> domainClass;
 	private final Lazy<Boolean> isCollectionQuery;
-	private final IntFunction<MethodParameter> methodParameterFactory;
 
 	/**
 	 * Creates a new {@link QueryMethod} from the given parameters. Looks up the correct query to use for following
@@ -88,8 +85,6 @@ public QueryMethod(Method method, RepositoryMetadata metadata, ProjectionFactory
 		this.method = method;
 		this.unwrappedReturnType = potentiallyUnwrapReturnTypeFor(metadata, method);
 		this.metadata = metadata;
-		this.methodParameterFactory = index -> new MethodParameter(method, index)
-				.withContainingClass(metadata.getRepositoryInterface());
 		this.parameters = createParameters(method);
 
 		this.domainClass = Lazy.of(() -> {
@@ -188,20 +183,24 @@ private boolean calculateIsCollectionQuery() {
 	 * @param method must not be {@literal null}.
 	 * @param domainType must not be {@literal null}.
 	 * @return must not return {@literal null}.
+	 * @deprecated since 3.2.1
 	 * @since 3.0.2
 	 */
+	@Deprecated(since = "3.2.1", forRemoval = true)
 	protected Parameters<?, ?> createParameters(Method method, TypeInformation<?> domainType) {
-		return new DefaultParameters(method, getMethodParameterFactory(), domainType);
+		return createParameters(metadata, method);
 	}
 
 	/**
-	 * The {@link IntFunction MethodParameterFactory} to create method parameters.
+	 * Creates a {@link Parameters} instance.
 	 *
-	 * @return factory to create method parameters.
+	 * @param metadata must not be {@literal null}.
+	 * @param method must not be {@literal null}.
+	 * @return must not return {@literal null}.
 	 * @since 3.2.1
 	 */
-	protected IntFunction<MethodParameter> getMethodParameterFactory() {
-		return methodParameterFactory;
+	protected Parameters<?, ?> createParameters(RepositoryMetadata metadata, Method method) {
+		return new DefaultParameters(metadata, method);
 	}
 
 	/**
@@ -329,7 +328,7 @@ public ResultProcessor getResultProcessor() {
 		return resultProcessor;
 	}
 
-	protected RepositoryMetadata getMetadata() {
+	RepositoryMetadata getMetadata() {
 		return metadata;
 	}
 
diff --git a/src/test/java/org/springframework/data/repository/query/ParametersParameterAccessorUnitTests.java b/src/test/java/org/springframework/data/repository/query/ParametersParameterAccessorUnitTests.java
@@ -25,6 +25,7 @@
 import org.springframework.data.domain.ScrollPosition;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Sort.Order;
+import org.springframework.data.repository.core.RepositoryMetadata;
 
 /**
  * Unit tests for {@link ParametersParameterAccessor}.
@@ -36,6 +37,7 @@
 class ParametersParameterAccessorUnitTests {
 
 	Parameters<?, ?> parameters;
+	RepositoryMetadata metadata;
 
 	@BeforeEach
 	void setUp() throws Exception {
diff --git a/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java b/src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java
@@ -27,15 +27,15 @@
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Publisher;
 
-import org.springframework.core.MethodParameter;
 import org.springframework.data.domain.Limit;
 import org.springframework.data.domain.OffsetScrollPosition;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Window;
 import org.springframework.data.repository.Repository;
-import org.springframework.data.util.TypeInformation;
+import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.data.repository.core.support.DefaultRepositoryMetadata;
 import org.springframework.test.util.ReflectionTestUtils;
 
 /**
@@ -47,11 +47,13 @@
 class ParametersUnitTests {
 
 	private Method valid;
+	private RepositoryMetadata metadata;
 
 	@BeforeEach
 	void setUp() throws SecurityException, NoSuchMethodException {
 
 		valid = SampleDao.class.getMethod("valid", String.class);
+		metadata = new DefaultRepositoryMetadata(SampleDao.class);
 	}
 
 	@Test
@@ -60,14 +62,14 @@ void checksValidMethodCorrectly() throws Exception {
 		var validWithPageable = SampleDao.class.getMethod("validWithPageable", String.class, Pageable.class);
 		var validWithSort = SampleDao.class.getMethod("validWithSort", String.class, Sort.class);
 
-		new DefaultParameters(valid);
-		new DefaultParameters(validWithPageable);
-		new DefaultParameters(validWithSort);
+		new DefaultParameters(metadata, valid);
+		new DefaultParameters(metadata, validWithPageable);
+		new DefaultParameters(metadata, validWithSort);
 	}
 
 	@Test
 	void rejectsNullMethod() {
-		assertThatIllegalArgumentException().isThrownBy(() -> new DefaultParameters(null));
+		assertThatIllegalArgumentException().isThrownBy(() -> new DefaultParameters(metadata, null));
 	}
 
 	@Test
@@ -91,12 +93,12 @@ void calculatesPlaceholderPositionCorrectly() throws Exception {
 
 		var method = SampleDao.class.getMethod("validWithSortFirst", Sort.class, String.class);
 
-		Parameters<?, ?> parameters = new DefaultParameters(method);
+		Parameters<?, ?> parameters = new DefaultParameters(metadata, method);
 		assertThat(parameters.getBindableParameter(0).getIndex()).isEqualTo(1);
 
 		method = SampleDao.class.getMethod("validWithSortInBetween", String.class, Sort.class, String.class);
 
-		parameters = new DefaultParameters(method);
+		parameters = new DefaultParameters(metadata, method);
 
 		assertThat(parameters.getBindableParameter(0).getIndex()).isEqualTo(0);
 		assertThat(parameters.getBindableParameter(1).getIndex()).isEqualTo(2);
@@ -211,9 +213,7 @@ void considersGenericType() throws Exception {
 
 		var method = TypedInterface.class.getMethod("foo", Object.class);
 
-		var parameters = new DefaultParameters(method,
-				index -> new MethodParameter(method, index).withContainingClass(TypedInterface.class),
-				TypeInformation.of(User.class));
+		var parameters = new DefaultParameters(new DefaultRepositoryMetadata(TypedInterface.class), method);
 
 		assertThat(parameters.getParameter(0).getType()).isEqualTo(Long.class);
 	}
@@ -223,14 +223,14 @@ private Parameters<?, Parameter> getParametersFor(String methodName, Class<?>...
 
 		var method = SampleDao.class.getMethod(methodName, parameterTypes);
 
-		return new DefaultParameters(method);
+		return new DefaultParameters(metadata, method);
 	}
 
 	static class User {
 
 	}
 
-	interface SampleDao {
+	interface SampleDao extends Repository<User, String> {
 
 		User valid(@Param("username") String username);
 
