From e7475e5e0f0ac76e1144290c2a5d3ce47bc2d93c Mon Sep 17 00:00:00 2001 From: Thomas Darimont Date: Thu, 5 Sep 2013 13:45:29 +0200 Subject: [PATCH] DATACMNS-364 - Infrastructure to allow redeclaring CRUD methods with queries. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduced new meta-annotation QueryAnnotation to mark and identify store specific Query annotations. This enables us to handle finder methods annotated with such store specific annotations in a generic way. Adjusted DefaultRepositoryInformation.getQueryMethods(…) to consider custom store specific query annotations. Original pull request: #43. --- .../data/annotation/QueryAnnotation.java | 34 ++++++++++++++++++ .../support/DefaultRepositoryInformation.java | 26 +++++++++++++- ...DefaultRepositoryInformationUnitTests.java | 35 ++++++++++++++++--- 3 files changed, 90 insertions(+), 5 deletions(-) create mode 100644 src/main/java/org/springframework/data/annotation/QueryAnnotation.java diff --git a/src/main/java/org/springframework/data/annotation/QueryAnnotation.java b/src/main/java/org/springframework/data/annotation/QueryAnnotation.java new file mode 100644 index 000000000..8f4d48157 --- /dev/null +++ b/src/main/java/org/springframework/data/annotation/QueryAnnotation.java @@ -0,0 +1,34 @@ +/* + * Copyright 2013 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.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +import org.springframework.data.repository.Repository; + +/** + * Meta-Annotation to mark a store specific annotation as a query annotation. This allows generic special handing of + * finder methods on {@link Repository} interfaces. + * + * @author Thomas Darimont + */ +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.ANNOTATION_TYPE) +public @interface QueryAnnotation { +} diff --git a/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java b/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java index d0e75ed4b..9a2eadae9 100644 --- a/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java +++ b/src/main/java/org/springframework/data/repository/core/support/DefaultRepositoryInformation.java @@ -29,6 +29,8 @@ import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.springframework.core.MethodParameter; +import org.springframework.core.annotation.AnnotationUtils; +import org.springframework.data.annotation.QueryAnnotation; import org.springframework.data.repository.Repository; import org.springframework.data.repository.core.CrudMethods; import org.springframework.data.repository.core.RepositoryInformation; @@ -167,7 +169,7 @@ class DefaultRepositoryInformation extends AbstractRepositoryMetadata implements for (Method method : getRepositoryInterface().getMethods()) { method = ClassUtils.getMostSpecificMethod(method, getRepositoryInterface()); - if (!isCustomMethod(method) && !isBaseClassMethod(method)) { + if (isQueryMethodCandidate(method)) { result.add(method); } } @@ -175,6 +177,28 @@ class DefaultRepositoryInformation extends AbstractRepositoryMetadata implements return Collections.unmodifiableSet(result); } + /** + * Checks whether the given method is a query method candidate. + * + * @param method + * @return + */ + private boolean isQueryMethodCandidate(Method method) { + return isQueryAnnotationPresentOn(method) || (!isCustomMethod(method) && !isBaseClassMethod(method)); + } + + /** + * Checks whether the given method contains a custom store specific query annotation annotated with + * {@link QueryAnnotation}. The method-hierarchy is also considered in the search for the annotation. + * + * @param method + * @return + */ + private boolean isQueryAnnotationPresentOn(Method method) { + + return AnnotationUtils.findAnnotation(method, QueryAnnotation.class) != null; + } + /* * (non-Javadoc) * @see org.springframework.data.repository.support.RepositoryInformation#isCustomMethod(java.lang.reflect.Method) diff --git a/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java b/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java index 1bf3ecfbf..cac78e443 100644 --- a/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java +++ b/src/test/java/org/springframework/data/repository/core/support/DefaultRepositoryInformationUnitTests.java @@ -4,6 +4,10 @@ import static org.hamcrest.Matchers.*; import static org.junit.Assert.*; import java.io.Serializable; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; import java.lang.reflect.Method; import java.util.List; @@ -13,6 +17,7 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.runners.MockitoJUnitRunner; +import org.springframework.data.annotation.QueryAnnotation; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; @@ -29,11 +34,9 @@ import org.springframework.data.repository.core.support.DefaultRepositoryMetadat @RunWith(MockitoJUnitRunner.class) public class DefaultRepositoryInformationUnitTests { - @SuppressWarnings("rawtypes") - static final Class REPOSITORY = DummyGenericRepositorySupport.class; + @SuppressWarnings("rawtypes") static final Class REPOSITORY = DummyGenericRepositorySupport.class; - @Mock - FooRepositoryCustom customImplementation; + @Mock FooRepositoryCustom customImplementation; @Test public void discoversRepositoryBaseClassMethod() throws Exception { @@ -157,6 +160,20 @@ public class DefaultRepositoryInformationUnitTests { assertThat(information.isQueryMethod(queryMethod), is(true)); } + /** + * @see DATACMNS-364 + */ + @Test + public void ignoresCrudMethodsAnnotatedWithQuery() throws Exception { + + RepositoryMetadata metadata = new DefaultRepositoryMetadata(ConcreteRepository.class); + RepositoryInformation information = new DefaultRepositoryInformation(metadata, CrudRepository.class, null); + + Method method = BaseRepository.class.getMethod("findOne", Serializable.class); + + assertThat(information.getQueryMethods(), hasItem(method)); + } + private Method getMethodFrom(Class type, String name) { for (Method method : type.getMethods()) { if (method.getName().equals(name)) { @@ -166,6 +183,13 @@ public class DefaultRepositoryInformationUnitTests { return null; } + @Target(ElementType.METHOD) + @Retention(RetentionPolicy.RUNTIME) + @QueryAnnotation + @interface MyQuery { + + } + interface FooRepository extends CrudRepository, FooRepositoryCustom { // Redeclared method @@ -200,6 +224,9 @@ public class DefaultRepositoryInformationUnitTests { K save(K entity); void delete(S entity); + + @MyQuery + S findOne(ID id); } interface ConcreteRepository extends BaseRepository {