diff --git a/src/main/java/org/springframework/data/repository/query/Parameter.java b/src/main/java/org/springframework/data/repository/query/Parameter.java index d1f792f9f..304772e50 100644 --- a/src/main/java/org/springframework/data/repository/query/Parameter.java +++ b/src/main/java/org/springframework/data/repository/query/Parameter.java @@ -79,19 +79,20 @@ public class Parameter { } /** - * Creates a new {@link Parameter} for the given {@link MethodParameter} and aggregate {@link TypeInformation}. + * Creates a new {@link Parameter} for the given {@link MethodParameter} and domain {@link TypeInformation}. * * @param parameter must not be {@literal null}. - * @param aggregateType must not be {@literal null}. + * @param domainType must not be {@literal null}. + * @since 3.0.2 */ - protected Parameter(MethodParameter parameter, TypeInformation aggregateType) { + protected Parameter(MethodParameter parameter, TypeInformation domainType) { Assert.notNull(parameter, "MethodParameter must not be null"); - Assert.notNull(aggregateType, "TypeInformation must not be null!"); + Assert.notNull(domainType, "TypeInformation must not be null!"); this.parameter = parameter; this.parameterType = potentiallyUnwrapParameterType(parameter); - this.isDynamicProjectionParameter = isDynamicProjectionParameter(parameter, aggregateType); + this.isDynamicProjectionParameter = isDynamicProjectionParameter(parameter, domainType); this.name = isSpecialParameterType(parameter.getParameterType()) ? Lazy.of(Optional.empty()) : Lazy.of(() -> { Param annotation = parameter.getParameterAnnotation(Param.class); return Optional.ofNullable(annotation == null ? parameter.getParameterName() : annotation.value()); @@ -218,10 +219,10 @@ public class Parameter { * * * @param parameter must not be {@literal null}. - * @param aggregateType the reference aggregate type, must not be {@literal null}. + * @param domainType the reference domain type, must not be {@literal null}. * @return */ - private static boolean isDynamicProjectionParameter(MethodParameter parameter, TypeInformation aggregateType) { + private static boolean isDynamicProjectionParameter(MethodParameter parameter, TypeInformation domainType) { if (!parameter.getParameterType().equals(Class.class)) { return false; @@ -241,7 +242,7 @@ public class Parameter { var unwrapped = QueryExecutionConverters.unwrapWrapperTypes(returnType); var reactiveUnwrapped = ReactiveWrapperConverters.unwrapWrapperTypes(unwrapped); - if (aggregateType.isAssignableFrom(reactiveUnwrapped)) { + if (domainType.isAssignableFrom(reactiveUnwrapped)) { return false; } diff --git a/src/main/java/org/springframework/data/repository/query/Parameters.java b/src/main/java/org/springframework/data/repository/query/Parameters.java index 7dfdf74c0..24426f4bd 100644 --- a/src/main/java/org/springframework/data/repository/query/Parameters.java +++ b/src/main/java/org/springframework/data/repository/query/Parameters.java @@ -77,6 +77,7 @@ public abstract class Parameters, T extends Parameter * * @param method must not be {@literal null}. * @param parameterFactory must not be {@literal null}. + * @since 3.0.2 */ protected Parameters(Method method, Function parameterFactory) { @@ -176,7 +177,7 @@ public abstract class Parameters, T extends Parameter * * @param parameter will never be {@literal null}. * @return - * @deprecated since 3.1, in your extension, call {@link #Parameters(Method, ParameterFactory)} instead. + * @deprecated since 3.1, in your extension, call {@link #Parameters(Method, Function)} instead. */ @SuppressWarnings("unchecked") @Deprecated(since = "3.1", forRemoval = true) diff --git a/src/main/java/org/springframework/data/repository/query/QueryMethod.java b/src/main/java/org/springframework/data/repository/query/QueryMethod.java index 76120505b..9a39f271c 100644 --- a/src/main/java/org/springframework/data/repository/query/QueryMethod.java +++ b/src/main/java/org/springframework/data/repository/query/QueryMethod.java @@ -69,12 +69,10 @@ public class QueryMethod { Assert.notNull(metadata, "Repository metadata must not be null"); Assert.notNull(factory, "ProjectionFactory must not be null"); - Parameters.TYPES.stream() - .filter(type -> getNumberOfOccurrences(method, type) > 1) - .findFirst().ifPresent(type -> { - throw new IllegalStateException( - String.format("Method must have only one argument of type %s; Offending method: %s", - type.getSimpleName(), method)); + Parameters.TYPES.stream() // + .filter(type -> getNumberOfOccurrences(method, type) > 1).findFirst().ifPresent(type -> { + throw new IllegalStateException(String.format( + "Method must have only one argument of type %s; Offending method: %s", type.getSimpleName(), method)); }); this.method = method; @@ -132,11 +130,12 @@ public class QueryMethod { * Creates a {@link Parameters} instance. * * @param method must not be {@literal null}. - * @param aggregateType must not be {@literal null}. + * @param domainType must not be {@literal null}. * @return must not return {@literal null}. + * @since 3.0.2 */ - protected Parameters createParameters(Method method, TypeInformation aggregateType) { - return new DefaultParameters(method, aggregateType); + protected Parameters createParameters(Method method, TypeInformation domainType) { + return new DefaultParameters(method, domainType); } /** diff --git a/src/test/java/org/springframework/data/repository/query/ParameterUnitTests.java b/src/test/java/org/springframework/data/repository/query/ParameterUnitTests.java index f0e08bba1..f0fba2ac1 100644 --- a/src/test/java/org/springframework/data/repository/query/ParameterUnitTests.java +++ b/src/test/java/org/springframework/data/repository/query/ParameterUnitTests.java @@ -20,6 +20,7 @@ import static org.assertj.core.api.Assertions.*; import java.util.Collections; import java.util.List; import java.util.Optional; +import java.util.function.Function; import java.util.stream.Stream; import org.jetbrains.annotations.NotNull; @@ -34,6 +35,7 @@ import org.springframework.data.util.TypeInformation; * Unit tests for {@link Parameter}. * * @author Jens Schauder + * @author Oliver Drotbohm */ class ParameterUnitTests { @@ -69,9 +71,9 @@ class ParameterUnitTests { "staticReturnNonDynamicBindWildcard", // "staticReturnNonDynamicBindWildcardExtends"); - return DynamicTest.stream(methods, it -> it, it -> { - assertThat(new Parameter(getMethodParameter(it), TypeInformation.of(User.class)) - .isDynamicProjectionParameter()).isFalse(); + return DynamicTest.stream(methods, Function.identity(), it -> { + Parameter parameter = new Parameter(getMethodParameter(it), TypeInformation.of(User.class)); + assertThat(parameter.isDynamicProjectionParameter()).isFalse(); }); } diff --git a/src/test/kotlin/org/springframework/data/repository/query/ParameterUnitTests.kt b/src/test/kotlin/org/springframework/data/repository/query/KParameterUnitTests.kt similarity index 73% rename from src/test/kotlin/org/springframework/data/repository/query/ParameterUnitTests.kt rename to src/test/kotlin/org/springframework/data/repository/query/KParameterUnitTests.kt index 9ae5d8149..7d3f1ef97 100644 --- a/src/test/kotlin/org/springframework/data/repository/query/ParameterUnitTests.kt +++ b/src/test/kotlin/org/springframework/data/repository/query/KParameterUnitTests.kt @@ -26,17 +26,17 @@ import kotlin.reflect.jvm.javaMethod * * @author Mark Paluch */ -class ParameterUnitTests { +class KParameterUnitTests { - @Test // DATACMNS-1508 - fun `should consider Continuation a special parameter`() { + @Test // DATACMNS-1508 + fun `should consider Continuation a special parameter`() { - val methodParameter = - MethodParameter(MyCoroutineRepository::hello.javaMethod!!, 0) - methodParameter.initParameterNameDiscovery(DefaultParameterNameDiscoverer()) - val parameter = Parameter(methodParameter) + val methodParameter = + MethodParameter(MyCoroutineRepository::hello.javaMethod!!, 0) + methodParameter.initParameterNameDiscovery(DefaultParameterNameDiscoverer()) + val parameter = Parameter(methodParameter) - assertThat(parameter.name).isEmpty() + assertThat(parameter.name).isEmpty() assertThat(parameter.isBindable).isFalse() }