diff --git a/src/main/java/org/springframework/data/repository/query/DefaultParameters.java b/src/main/java/org/springframework/data/repository/query/DefaultParameters.java index 1cadc973d..8e217ee59 100644 --- a/src/main/java/org/springframework/data/repository/query/DefaultParameters.java +++ b/src/main/java/org/springframework/data/repository/query/DefaultParameters.java @@ -31,9 +31,7 @@ public final class DefaultParameters extends Parameters 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 +217,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 +240,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..1fed8a178 100644 --- a/src/main/java/org/springframework/data/repository/query/Parameters.java +++ b/src/main/java/org/springframework/data/repository/query/Parameters.java @@ -63,10 +63,8 @@ public abstract class Parameters, T extends Parameter * Creates a new instance of {@link Parameters}. * * @param method must not be {@literal null}. - * @deprecated since 3.1, use {@link #Parameters(Method, Function)} instead. */ @SuppressWarnings("null") - @Deprecated(since = "3.1", forRemoval = true) public Parameters(Method method) { this(method, null); } @@ -77,6 +75,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,10 +175,8 @@ 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. */ @SuppressWarnings("unchecked") - @Deprecated(since = "3.1", forRemoval = true) protected T createParameter(MethodParameter parameter) { return (T) new Parameter(parameter); } 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..76d4d82b9 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; @@ -121,9 +119,7 @@ public class QueryMethod { * * @param method must not be {@literal null}. * @return must not return {@literal null}. - * @deprecated since 3.1, call or override {@link #createParameters(Method, TypeInformation)} instead. */ - @Deprecated(since = "3.1", forRemoval = true) protected Parameters createParameters(Method method) { return createParameters(method, metadata.getDomainTypeInformation()); } @@ -132,11 +128,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() }