diff --git a/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java b/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java index acffa04e0..d9b470aaf 100644 --- a/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java +++ b/src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java @@ -1,5 +1,5 @@ /* - * Copyright 2011-2016 the original author or authors. + * Copyright 2011-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. @@ -19,7 +19,6 @@ import java.lang.reflect.Method; import java.util.Arrays; import java.util.Collections; import java.util.Set; -import java.util.stream.Stream; import org.springframework.data.domain.Pageable; import org.springframework.data.repository.Repository; @@ -37,6 +36,7 @@ import org.springframework.util.Assert; * * @author Oliver Gierke * @author Thomas Darimont + * @author Jens Schauder */ public abstract class AbstractRepositoryMetadata implements RepositoryMetadata { @@ -79,7 +79,7 @@ public abstract class AbstractRepositoryMetadata implements RepositoryMetadata { * @see org.springframework.data.repository.core.RepositoryMetadata#getReturnedDomainClass(java.lang.reflect.Method) */ public Class getReturnedDomainClass(Method method) { - return unwrapWrapperTypes(typeInformation.getReturnType(method)); + return QueryExecutionConverters.unwrapWrapperTypes(typeInformation.getReturnType(method)).getType(); } /* @@ -128,20 +128,4 @@ public abstract class AbstractRepositoryMetadata implements RepositoryMetadata { public boolean isReactiveRepository() { return ReactiveWrappers.usesReactiveType(repositoryInterface); } - - /** - * Recursively unwraps well known wrapper types from the given {@link TypeInformation}. - * - * @param type must not be {@literal null}. - * @return - */ - private static Class unwrapWrapperTypes(TypeInformation type) { - - Class rawType = type.getType(); - - boolean needToUnwrap = Iterable.class.isAssignableFrom(rawType) || rawType.isArray() - || QueryExecutionConverters.supports(rawType) || Stream.class.isAssignableFrom(rawType); - - return needToUnwrap ? unwrapWrapperTypes(type.getRequiredComponentType()) : rawType; - } } 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 59b5bfcdb..692950d74 100644 --- a/src/main/java/org/springframework/data/repository/query/Parameter.java +++ b/src/main/java/org/springframework/data/repository/query/Parameter.java @@ -1,5 +1,5 @@ /* - * Copyright 2008-2015 the original author or authors. + * Copyright 2008-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. @@ -36,6 +36,7 @@ import org.springframework.util.Assert; * * @author Oliver Gierke * @author Mark Paluch + * @author Jens Schauder */ public class Parameter { @@ -207,7 +208,8 @@ public class Parameter { TypeInformation bound = parameterTypes.getTypeArguments().get(0); TypeInformation returnType = ClassTypeInformation.fromReturnTypeOf(method); - return bound.equals(returnType.getActualType()); + + return bound.equals(QueryExecutionConverters.unwrapWrapperTypes(returnType)); } /** diff --git a/src/main/java/org/springframework/data/repository/util/QueryExecutionConverters.java b/src/main/java/org/springframework/data/repository/util/QueryExecutionConverters.java index 35d2c796f..40f08d909 100644 --- a/src/main/java/org/springframework/data/repository/util/QueryExecutionConverters.java +++ b/src/main/java/org/springframework/data/repository/util/QueryExecutionConverters.java @@ -35,6 +35,7 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Future; import java.util.stream.Collectors; +import java.util.stream.Stream; import javax.annotation.Nonnull; @@ -47,6 +48,7 @@ import org.springframework.data.domain.Page; import org.springframework.data.domain.Slice; import org.springframework.data.util.StreamUtils; import org.springframework.data.util.Streamable; +import org.springframework.data.util.TypeInformation; import org.springframework.lang.Nullable; import org.springframework.scheduling.annotation.AsyncResult; import org.springframework.util.Assert; @@ -76,6 +78,7 @@ import com.google.common.base.Optional; * @author Mark Paluch * @author Christoph Strobl * @author Maciek Opała + * @author Jens Schauder * @since 1.8 * @see ReactiveWrappers */ @@ -285,6 +288,23 @@ public abstract class QueryExecutionConverters { return source; } + /** + * Recursively unwraps well known wrapper types from the given {@link TypeInformation}. + * + * @param type must not be {@literal null}. + */ + public static TypeInformation unwrapWrapperTypes(TypeInformation type) { + + Assert.notNull(type, "type must not be null"); + + Class rawType = type.getType(); + + boolean needToUnwrap = Iterable.class.isAssignableFrom(rawType) || rawType.isArray() || supports(rawType) + || Stream.class.isAssignableFrom(rawType); + + return needToUnwrap ? unwrapWrapperTypes(type.getRequiredComponentType()) : type; + } + /** * Base class for converters that create instances of wrapper types such as Google Guava's and JDK 8's * {@code Optional} types. diff --git a/src/test/java/org/springframework/data/repository/query/ParameterUnitTests.java b/src/test/java/org/springframework/data/repository/query/ParameterUnitTests.java new file mode 100644 index 000000000..f36517e2a --- /dev/null +++ b/src/test/java/org/springframework/data/repository/query/ParameterUnitTests.java @@ -0,0 +1,68 @@ +/* + * Copyright 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.data.repository.query; + +import static org.assertj.core.api.Assertions.*; + +import java.util.Collections; +import java.util.List; +import java.util.stream.Stream; + +import org.jetbrains.annotations.NotNull; +import org.junit.Test; +import org.springframework.core.MethodParameter; + +/** + * Unit tests for {@link Parameter}. + * + * @author Jens Schauder + */ +public class ParameterUnitTests { + + @Test // DATAJPA-1185 + public void classParameterWithSameTypeParameterAsReturnedListIsDynamicProjectionParameter() throws Exception { + + Parameter parameter = new Parameter(getMethodParameter("dynamicProjectionWithList")); + + assertThat(parameter.isDynamicProjectionParameter()).isTrue(); + } + + @Test // DATAJPA-1185 + public void classParameterWithSameTypeParameterAsReturnedStreamIsDynamicProjectionParameter() throws Exception { + + Parameter parameter = new Parameter(getMethodParameter("dynamicProjectionWithStream")); + + assertThat(parameter.isDynamicProjectionParameter()).isTrue(); + } + + @NotNull + private MethodParameter getMethodParameter(String methodName) throws NoSuchMethodException { + return new MethodParameter( // + this.getClass().getDeclaredMethod( // + methodName, // + Class.class // + ), // + 0); + } + + List dynamicProjectionWithList(Class type) { + return Collections.emptyList(); + } + + Stream dynamicProjectionWithStream(Class type) { + return Stream.empty(); + } +}