Allow to add a special parameter type from a Spring Data JPA extension

Author: reda-alaoui

src/main/java/org/springframework/data/jpa/repository/query/JpaParameters.java

@@ -33,6 +33,7 @@
  *
  * @author Thomas Darimont
  * @author Mark Paluch
+ * @author Reda.Housni-Alaoui
  */
 public class JpaParameters extends Parameters<JpaParameters, JpaParameter> {
 
@@ -73,7 +74,7 @@ protected JpaParameters createFrom(List<JpaParameter> parameters) {
 	 * @author Thomas Darimont
 	 * @author Oliver Gierke
 	 */
-	static class JpaParameter extends Parameter {
+	public static class JpaParameter extends Parameter {
 
 		private final @Nullable Temporal annotation;
 		private @Nullable TemporalType temporalType;
@@ -83,7 +84,7 @@ static class JpaParameter extends Parameter {
 		 *
 		 * @param parameter must not be {@literal null}.
 		 */
-		JpaParameter(MethodParameter parameter) {
+		protected JpaParameter(MethodParameter parameter) {
 
 			super(parameter);
 

src/main/java/org/springframework/data/jpa/repository/query/JpaQueryLookupStrategy.java

@@ -38,6 +38,7 @@
  * @author Oliver Gierke
  * @author Thomas Darimont
  * @author Mark Paluch
+ * @author Reda.Housni-Alaoui
  */
 public final class JpaQueryLookupStrategy {
 
@@ -56,17 +57,21 @@ private abstract static class AbstractQueryLookupStrategy implements QueryLookup
 
 		private final EntityManager em;
 		private final QueryExtractor provider;
+		private final JpaQueryMethodFactory queryMethodFactory;
 
 		/**
 		 * Creates a new {@link AbstractQueryLookupStrategy}.
 		 *
 		 * @param em
 		 * @param extractor
+		 * @param queryMethodFactory
 		 */
-		public AbstractQueryLookupStrategy(EntityManager em, QueryExtractor extractor) {
+		public AbstractQueryLookupStrategy(EntityManager em, QueryExtractor extractor,
+				JpaQueryMethodFactory queryMethodFactory) {
 
 			this.em = em;
 			this.provider = extractor;
+			this.queryMethodFactory = queryMethodFactory;
 		}
 
 		/*
@@ -76,7 +81,7 @@ public AbstractQueryLookupStrategy(EntityManager em, QueryExtractor extractor) {
 		@Override
 		public final RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
 				NamedQueries namedQueries) {
-			return resolveQuery(new JpaQueryMethod(method, metadata, factory, provider), em, namedQueries);
+			return resolveQuery(queryMethodFactory.build(method, metadata, factory, provider), em, namedQueries);
 		}
 
 		protected abstract RepositoryQuery resolveQuery(JpaQueryMethod method, EntityManager em, NamedQueries namedQueries);
@@ -93,10 +98,9 @@ private static class CreateQueryLookupStrategy extends AbstractQueryLookupStrate
 		private final PersistenceProvider persistenceProvider;
 		private final EscapeCharacter escape;
 
-		public CreateQueryLookupStrategy(EntityManager em, QueryExtractor extractor, EscapeCharacter escape) {
-
-			super(em, extractor);
+		public CreateQueryLookupStrategy(EntityManager em, QueryExtractor extractor, EscapeCharacter escape, JpaQueryMethodFactory queryMethodFactory) {
 
+			super(em, extractor, queryMethodFactory);
 			this.persistenceProvider = PersistenceProvider.fromEntityManager(em);
 			this.escape = escape;
 		}
@@ -123,12 +127,13 @@ private static class DeclaredQueryLookupStrategy extends AbstractQueryLookupStra
 		 *
 		 * @param em
 		 * @param extractor
+		 * @param queryMethodFactory
 		 * @param evaluationContextProvider
 		 */
 		public DeclaredQueryLookupStrategy(EntityManager em, QueryExtractor extractor,
-				QueryMethodEvaluationContextProvider evaluationContextProvider) {
+				JpaQueryMethodFactory queryMethodFactory, QueryMethodEvaluationContextProvider evaluationContextProvider) {
 
-			super(em, extractor);
+			super(em, extractor, queryMethodFactory);
 			this.evaluationContextProvider = evaluationContextProvider;
 		}
 
@@ -186,13 +191,15 @@ private static class CreateIfNotFoundQueryLookupStrategy extends AbstractQueryLo
 		 *
 		 * @param em
 		 * @param extractor
+		 * @param queryMethodFactory
 		 * @param createStrategy
 		 * @param lookupStrategy
 		 */
 		public CreateIfNotFoundQueryLookupStrategy(EntityManager em, QueryExtractor extractor,
-				CreateQueryLookupStrategy createStrategy, DeclaredQueryLookupStrategy lookupStrategy) {
+				JpaQueryMethodFactory queryMethodFactory, CreateQueryLookupStrategy createStrategy,
+				DeclaredQueryLookupStrategy lookupStrategy) {
 
-			super(em, extractor);
+			super(em, extractor, queryMethodFactory);
 
 			this.createStrategy = createStrategy;
 			this.lookupStrategy = lookupStrategy;
@@ -219,26 +226,27 @@ protected RepositoryQuery resolveQuery(JpaQueryMethod method, EntityManager em,
 	 * @param em must not be {@literal null}.
 	 * @param key may be {@literal null}.
 	 * @param extractor must not be {@literal null}.
+	 * @param queryMethodFactory must not be {@literal null}.
 	 * @param evaluationContextProvider must not be {@literal null}.
 	 * @param escape
 	 * @return
 	 */
 	public static QueryLookupStrategy create(EntityManager em, @Nullable Key key, QueryExtractor extractor,
-			QueryMethodEvaluationContextProvider evaluationContextProvider, EscapeCharacter escape) {
+			JpaQueryMethodFactory queryMethodFactory, QueryMethodEvaluationContextProvider evaluationContextProvider, EscapeCharacter escape) {
 
 		Assert.notNull(em, "EntityManager must not be null!");
 		Assert.notNull(extractor, "QueryExtractor must not be null!");
 		Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");
 
 		switch (key != null ? key : Key.CREATE_IF_NOT_FOUND) {
 			case CREATE:
-				return new CreateQueryLookupStrategy(em, extractor, escape);
+				return new CreateQueryLookupStrategy(em, extractor, escape, queryMethodFactory);
 			case USE_DECLARED_QUERY:
-				return new DeclaredQueryLookupStrategy(em, extractor, evaluationContextProvider);
+				return new DeclaredQueryLookupStrategy(em, extractor, queryMethodFactory, evaluationContextProvider);
 			case CREATE_IF_NOT_FOUND:
-				return new CreateIfNotFoundQueryLookupStrategy(em, extractor,
-						new CreateQueryLookupStrategy(em, extractor, escape),
-						new DeclaredQueryLookupStrategy(em, extractor, evaluationContextProvider));
+				return new CreateIfNotFoundQueryLookupStrategy(em, extractor,queryMethodFactory,
+						new CreateQueryLookupStrategy(em, extractor, escape, queryMethodFactory),
+						new DeclaredQueryLookupStrategy(em, extractor, queryMethodFactory, evaluationContextProvider));
 			default:
 				throw new IllegalArgumentException(String.format("Unsupported query lookup strategy %s!", key));
 		}

src/main/java/org/springframework/data/jpa/repository/query/JpaQueryMethod.java

@@ -53,6 +53,7 @@
  * @author Nicolas Cirigliano
  * @author Mark Paluch
  * @author Сергей Цыпанов
+ * @author Reda.Housni-Alaoui
  */
 public class JpaQueryMethod extends QueryMethod {
 
@@ -88,7 +89,7 @@ public class JpaQueryMethod extends QueryMethod {
 	 * @param factory must not be {@literal null}
 	 * @param extractor must not be {@literal null}
 	 */
-	public JpaQueryMethod(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
+	protected JpaQueryMethod(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
 			QueryExtractor extractor) {
 
 		super(method, metadata, factory);
@@ -403,4 +404,19 @@ StoredProcedureAttributes getProcedureAttributes() {
 
 		return storedProcedureAttributes;
 	}
+
+	public static class Factory implements JpaQueryMethodFactory {
+
+		public static final Factory INSTANCE = new Factory();
+
+		private Factory() {
+
+		}
+
+		@Override
+		public JpaQueryMethod build(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
+				QueryExtractor extractor) {
+			return new JpaQueryMethod(method, metadata, factory, extractor);
+		}
+	}
 }

src/main/java/org/springframework/data/jpa/repository/query/JpaQueryMethodFactory.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2012-2019 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.jpa.repository.query;
+
+import java.lang.reflect.Method;
+
+import org.springframework.data.jpa.provider.QueryExtractor;
+import org.springframework.data.projection.ProjectionFactory;
+import org.springframework.data.repository.core.RepositoryMetadata;
+
+/**
+ * @author Reda.Housni-Alaoui
+ */
+public interface JpaQueryMethodFactory {
+
+	/**
+	 * Creates a {@link JpaQueryMethod}.
+	 *
+	 * @param method must not be {@literal null}
+	 * @param metadata must not be {@literal null}
+	 * @param factory must not be {@literal null}
+	 * @param extractor must not be {@literal null}
+	 */
+	JpaQueryMethod build(Method method, RepositoryMetadata metadata, ProjectionFactory factory, QueryExtractor extractor);
+
+}

src/main/java/org/springframework/data/jpa/repository/support/JpaRepositoryFactory.java

@@ -15,7 +15,7 @@
  */
 package org.springframework.data.jpa.repository.support;
 
-import static org.springframework.data.querydsl.QuerydslUtils.*;
+import static org.springframework.data.querydsl.QuerydslUtils.QUERY_DSL_PRESENT;
 
 import lombok.extern.slf4j.Slf4j;
 
@@ -35,6 +35,7 @@
 import org.springframework.data.jpa.repository.query.EscapeCharacter;
 import org.springframework.data.jpa.repository.query.JpaQueryLookupStrategy;
 import org.springframework.data.jpa.repository.query.JpaQueryMethod;
+import org.springframework.data.jpa.repository.query.JpaQueryMethodFactory;
 import org.springframework.data.jpa.util.JpaMetamodel;
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.querydsl.EntityPathResolver;
@@ -61,6 +62,7 @@
  * @author Christoph Strobl
  * @author Jens Schauder
  * @author Stefan Fussenegger
+ * @author Reda.Housni-Alaoui
  */
 public class JpaRepositoryFactory extends RepositoryFactorySupport {
 
@@ -70,6 +72,7 @@ public class JpaRepositoryFactory extends RepositoryFactorySupport {
 
 	private EntityPathResolver entityPathResolver;
 	private EscapeCharacter escapeCharacter = EscapeCharacter.DEFAULT;
+	private JpaQueryMethodFactory queryMethodFactory;
 
 	/**
 	 * Creates a new {@link JpaRepositoryFactory}.
@@ -84,6 +87,7 @@ public JpaRepositoryFactory(EntityManager entityManager) {
 		this.extractor = PersistenceProvider.fromEntityManager(entityManager);
 		this.crudMethodMetadataPostProcessor = new CrudMethodMetadataPostProcessor();
 		this.entityPathResolver = SimpleEntityPathResolver.INSTANCE;
+		this.queryMethodFactory = JpaQueryMethod.Factory.INSTANCE;
 
 		addRepositoryProxyPostProcessor(crudMethodMetadataPostProcessor);
 
@@ -124,6 +128,17 @@ public void setEscapeCharacter(EscapeCharacter escapeCharacter) {
 		this.escapeCharacter = escapeCharacter;
 	}
 
+	/**
+	 * Configures the {@link JpaQueryMethodFactory} to be used. Defaults to {@link JpaQueryMethod.Factory#INSTANCE}.
+	 * 
+	 * @param queryMethodFactory must not be {@literal null}.
+	 */
+	public void setQueryMethodFactory(JpaQueryMethodFactory queryMethodFactory) {
+		Assert.notNull(queryMethodFactory, "QueryMethodFactory must not be null!");
+
+		this.queryMethodFactory = queryMethodFactory;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.core.support.RepositoryFactorySupport#getTargetRepository(org.springframework.data.repository.core.RepositoryMetadata)
@@ -187,7 +202,8 @@ protected ProjectionFactory getProjectionFactory(ClassLoader classLoader, BeanFa
 	protected Optional<QueryLookupStrategy> getQueryLookupStrategy(@Nullable Key key,
 			QueryMethodEvaluationContextProvider evaluationContextProvider) {
 		return Optional
-				.of(JpaQueryLookupStrategy.create(entityManager, key, extractor, evaluationContextProvider, escapeCharacter));
+				.of(
+				JpaQueryLookupStrategy.create(entityManager, key, extractor, queryMethodFactory, evaluationContextProvider, escapeCharacter));
 	}
 
 	/*

src/main/java/org/springframework/data/jpa/repository/support/JpaRepositoryFactoryBean.java

@@ -21,6 +21,8 @@
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.query.EscapeCharacter;
+import org.springframework.data.jpa.repository.query.JpaQueryMethod;
+import org.springframework.data.jpa.repository.query.JpaQueryMethodFactory;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.querydsl.EntityPathResolver;
 import org.springframework.data.querydsl.SimpleEntityPathResolver;
@@ -38,6 +40,7 @@
  * @author Eberhard Wolff
  * @author Mark Paluch
  * @author Jens Schauder
+ * @author Reda.Housni-Alaoui
  * @param <T> the type of the repository
  */
 public class JpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID>
@@ -46,6 +49,7 @@ public class JpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID>
 	private @Nullable EntityManager entityManager;
 	private EntityPathResolver entityPathResolver;
 	private EscapeCharacter escapeCharacter = EscapeCharacter.DEFAULT;
+	private JpaQueryMethodFactory queryMethodFactory;
 
 	/**
 	 * Creates a new {@link JpaRepositoryFactoryBean} for the given repository interface.
@@ -86,6 +90,17 @@ public void setEntityPathResolver(ObjectProvider<EntityPathResolver> resolver) {
 		this.entityPathResolver = resolver.getIfAvailable(() -> SimpleEntityPathResolver.INSTANCE);
 	}
 
+	/**
+	 * Configures the {@link JpaQueryMethodFactory} to be used. Will expect a canonical bean to be present but fallback to
+	 * {@link JpaQueryMethod.Factory#INSTANCE} in case none is available.
+	 *
+	 * @param resolver must not be {@literal null}.
+	 */
+	@Autowired
+	public void setQueryMethodFactory(ObjectProvider<JpaQueryMethodFactory> resolver) {
+		this.queryMethodFactory = resolver.getIfAvailable(() -> JpaQueryMethod.Factory.INSTANCE);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.core.support.TransactionalRepositoryFactoryBeanSupport#doCreateRepositoryFactory()
@@ -106,6 +121,8 @@ protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityM
 		JpaRepositoryFactory jpaRepositoryFactory = new JpaRepositoryFactory(entityManager);
 		jpaRepositoryFactory.setEntityPathResolver(entityPathResolver);
 		jpaRepositoryFactory.setEscapeCharacter(escapeCharacter);
+		jpaRepositoryFactory.setQueryMethodFactory(queryMethodFactory);
+
 		return jpaRepositoryFactory;
 	}
 

src/test/java/org/springframework/data/jpa/repository/query/JpaQueryLookupStrategyUnitTests.java

@@ -15,9 +15,9 @@
  */
 package org.springframework.data.jpa.repository.query;
 
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.*;
-import static org.mockito.Mockito.*;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
 
 import java.lang.reflect.Method;
 import java.util.List;
@@ -50,11 +50,13 @@
  * @author Oliver Gierke
  * @author Thomas Darimont
  * @author Jens Schauder
+ * @author Reda.Housni-Alaoui
  */
 @RunWith(MockitoJUnitRunner.class)
 public class JpaQueryLookupStrategyUnitTests {
 
 	private static final QueryMethodEvaluationContextProvider EVALUATION_CONTEXT_PROVIDER = QueryMethodEvaluationContextProvider.DEFAULT;
+	private static final JpaQueryMethodFactory QUERY_METHOD_FACTORY = JpaQueryMethod.Factory.INSTANCE;
 
 	@Mock EntityManager em;
 	@Mock EntityManagerFactory emf;
@@ -76,7 +78,7 @@ public void setUp() {
 	public void invalidAnnotatedQueryCausesException() throws Exception {
 
 		QueryLookupStrategy strategy = JpaQueryLookupStrategy.create(em, Key.CREATE_IF_NOT_FOUND, extractor,
-				EVALUATION_CONTEXT_PROVIDER, EscapeCharacter.DEFAULT);
+				QUERY_METHOD_FACTORY, EVALUATION_CONTEXT_PROVIDER, EscapeCharacter.DEFAULT);
 		Method method = UserRepository.class.getMethod("findByFoo", String.class);
 		RepositoryMetadata metadata = new DefaultRepositoryMetadata(UserRepository.class);
 
@@ -92,7 +94,7 @@ public void invalidAnnotatedQueryCausesException() throws Exception {
 	public void sholdThrowMorePreciseExceptionIfTryingToUsePaginationInNativeQueries() throws Exception {
 
 		QueryLookupStrategy strategy = JpaQueryLookupStrategy.create(em, Key.CREATE_IF_NOT_FOUND, extractor,
-				EVALUATION_CONTEXT_PROVIDER, EscapeCharacter.DEFAULT);
+				QUERY_METHOD_FACTORY, EVALUATION_CONTEXT_PROVIDER, EscapeCharacter.DEFAULT);
 		Method method = UserRepository.class.getMethod("findByInvalidNativeQuery", String.class, Sort.class);
 		RepositoryMetadata metadata = new DefaultRepositoryMetadata(UserRepository.class);