Polishing.

Eagerly resolve QueryRewriter instances when creating JPA query objects. Tweak documentation wording. Tweak type names to align with naming scheme.

See #2162.

Author: mp911de

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/Query.java

@@ -80,10 +80,10 @@
 	String countName() default "";
 
 	/**
-	 * Define the {@link QueryRewriter} bean that should be applied to this query after the query is full assembled.
+	 * Define a {@link QueryRewriter} that should be applied to the query string after the query is fully assembled.
 	 *
 	 * @return
 	 * @since 3.0
 	 */
-	Class<? extends QueryRewriter> queryRewriter() default QueryRewriter.NoopQueryRewriter.class;
+	Class<? extends QueryRewriter> queryRewriter() default QueryRewriter.IdentityQueryRewriter.class;
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/QueryRewriter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2008-2022 the original author or authors.
+ * Copyright 2022 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,33 +19,41 @@
 import org.springframework.data.domain.Sort;
 
 /**
- * Callback to rewrite a query right before it's handed to the EntityManager.
+ * Callback to rewrite a query and apply sorting and pagination settings that cannot be applied based on a regularly
+ * detectable scheme.
+ * <p>
+ * The underlying the query is the one right before it is used for query object creation, so everything that Spring Data
+ * and tools intends to do has been done. You can customize the query to apply final changes. Rewriting can only make
+ * use of already existing contextual data. That is, adding or replacing query text or reuse of bound parameters. Query
+ * rewriting must not add additional bindable parameters as these cannot be materialized.
  *
  * @author Greg Turnquist
+ * @author Mark Paluch
  * @since 3.0
+ * @see jakarta.persistence.EntityManager#createQuery
+ * @see jakarta.persistence.EntityManager#createNativeQuery
  */
 @FunctionalInterface
 public interface QueryRewriter {
 
 	/**
-	 * The assembled query and current {@link Sort} settings are offered. This is the query right before it's handed to
-	 * the EntityManager, so everything that Spring Data and tools intends to do has been done. The user is able to make
-	 * any last minute changes.<br/>
-	 * <br/>
+	 * Rewrite the assembled query with the given {@link Sort}.
+	 * <p>
 	 * WARNING: No checks are performed before the transformed query is passed to the EntityManager.
-	 * 
-	 * @param query - the assembled generated query, right before it's handed over to the EntityManager.
-	 * @param sort - current {@link Sort} settings provided by the method, or {@link Sort#unsorted()}} if there are none.
-	 * @return alter the query however you like.
+	 *
+	 * @param query the assembled query.
+	 * @param sort current {@link Sort} settings provided by the method, or {@link Sort#unsorted()}} if there are none.
+	 * @return the query to be used with the {@code EntityManager}.
 	 */
 	String rewrite(String query, Sort sort);
 
 	/**
-	 * This alternative is used to handle {@link Pageable}-based methods.
-	 * 
-	 * @param query - the assembled generated query, right before it's handed over to the EntityManager.
-	 * @param pageRequest
-	 * @return
+	 * Rewrite the assembled query with the given {@link Pageable}.
+	 *
+	 * @param query the assembled query.
+	 * @param pageRequest current {@link Pageable} settings provided by the method, or {@link Pageable#unpaged()} if not
+	 *          paged.
+	 * @return the query to be used with the {@code EntityManager}.
 	 */
 	default String rewrite(String query, Pageable pageRequest) {
 		return rewrite(query, pageRequest.getSort());
@@ -54,7 +62,9 @@ default String rewrite(String query, Pageable pageRequest) {
 	/**
 	 * A {@link QueryRewriter} that doesn't change the query.
 	 */
-	public class NoopQueryRewriter implements QueryRewriter {
+	enum IdentityQueryRewriter implements QueryRewriter {
+
+		INSTANCE;
 
 		@Override
 		public String rewrite(String query, Sort sort) {

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/cdi/QueryRewriterBeanManagerProvider.java renamed to spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/cdi/BeanManagerQueryRewriterProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2008-2022 the original author or authors.
+ * Copyright 2022 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,37 +19,52 @@
 import jakarta.enterprise.inject.spi.Bean;
 import jakarta.enterprise.inject.spi.BeanManager;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import java.util.Iterator;
+
+import org.springframework.beans.BeanUtils;
 import org.springframework.data.jpa.repository.QueryRewriter;
+import org.springframework.data.jpa.repository.query.DelegatingQueryRewriter;
+import org.springframework.data.jpa.repository.query.JpaQueryMethod;
 import org.springframework.data.jpa.repository.query.QueryRewriterProvider;
+import org.springframework.data.util.Lazy;
 
 /**
  * A {@link BeanManager}-based {@link QueryRewriterProvider}.
  *
  * @author Greg Turnquist
+ * @author Mark Paluch
  * @since 3.0
  */
-public class QueryRewriterBeanManagerProvider extends QueryRewriterProvider {
-
-	private static final Log LOGGER = LogFactory.getLog(QueryRewriterBeanManagerProvider.class);
+public class BeanManagerQueryRewriterProvider implements QueryRewriterProvider {
 
 	private final BeanManager beanManager;
 
-	public QueryRewriterBeanManagerProvider(BeanManager beanManager) {
+	public BeanManagerQueryRewriterProvider(BeanManager beanManager) {
 		this.beanManager = beanManager;
 	}
 
 	@Override
-	protected QueryRewriter extractQueryRewriterBean(Class<? extends QueryRewriter> queryRewriter) {
+	@SuppressWarnings("unchecked")
+	public QueryRewriter getQueryRewriter(JpaQueryMethod method) {
+
+		Class<? extends QueryRewriter> queryRewriter = method.getQueryRewriter();
+		if (queryRewriter == QueryRewriter.IdentityQueryRewriter.class) {
+			return QueryRewriter.IdentityQueryRewriter.INSTANCE;
+		}
+
+		Iterator<Bean<?>> iterator = beanManager.getBeans(queryRewriter).iterator();
 
-		try {
-			Bean<QueryRewriter> bean = (Bean<QueryRewriter>) beanManager.getBeans(queryRewriter).iterator().next();
+		if (iterator.hasNext()) {
+
+			Bean<QueryRewriter> bean = (Bean<QueryRewriter>) iterator.next();
 			CreationalContext<QueryRewriter> context = beanManager.createCreationalContext(bean);
-			return (QueryRewriter) beanManager.getReference(bean, queryRewriter, context);
-		} catch (Exception e) {
-			LOGGER.error(e.toString());
-			return null;
+			Lazy<QueryRewriter> rewriter = Lazy
+					.of(() -> (QueryRewriter) beanManager.getReference(bean, queryRewriter, context));
+
+			return new DelegatingQueryRewriter(rewriter);
 		}
+
+		return BeanUtils.instantiateClass(queryRewriter);
 	}
+
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/cdi/JpaRepositoryBean.java

@@ -62,7 +62,7 @@ class JpaRepositoryBean<T> extends CdiRepositoryBean<T> {
 
 		Assert.notNull(entityManagerBean, "EntityManager bean must not be null!");
 		this.entityManagerBean = entityManagerBean;
-		this.queryRewriterProvider = new QueryRewriterBeanManagerProvider(beanManager);
+		this.queryRewriterProvider = new BeanManagerQueryRewriterProvider(beanManager);
 	}
 
 	@Override

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/AbstractStringBasedJpaQuery.java

@@ -18,10 +18,9 @@
 import jakarta.persistence.EntityManager;
 import jakarta.persistence.Query;
 
-import java.util.function.Supplier;
-
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.repository.QueryRewriter;
@@ -46,14 +45,12 @@
  */
 abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 
-	private static final Log LOGGER = LogFactory.getLog(AbstractStringBasedJpaQuery.class);
-
 	private final DeclaredQuery query;
 	private final DeclaredQuery countQuery;
 	private final QueryMethodEvaluationContextProvider evaluationContextProvider;
 	private final SpelExpressionParser parser;
 	private final QueryParameterSetter.QueryMetadataCache metadataCache = new QueryParameterSetter.QueryMetadataCache();
-	private final Supplier<QueryRewriter> queryRewriterSupplier;
+	private final QueryRewriter queryRewriter;
 
 	/**
 	 * Creates a new {@link AbstractStringBasedJpaQuery} from the given {@link JpaQueryMethod}, {@link EntityManager} and
@@ -65,16 +62,18 @@ abstract class AbstractStringBasedJpaQuery extends AbstractJpaQuery {
 	 * @param countQueryString must not be {@literal null}.
 	 * @param evaluationContextProvider must not be {@literal null}.
 	 * @param parser must not be {@literal null}.
+	 * @param queryRewriter must not be {@literal null}.
 	 */
 	public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, String queryString,
-			@Nullable String countQueryString, QueryMethodEvaluationContextProvider evaluationContextProvider,
-			SpelExpressionParser parser, QueryRewriterProvider queryRewriterProvider) {
+			@Nullable String countQueryString, QueryRewriter queryRewriter, QueryMethodEvaluationContextProvider evaluationContextProvider,
+			SpelExpressionParser parser) {
 
 		super(method, em);
 
 		Assert.hasText(queryString, "Query string must not be null or empty!");
 		Assert.notNull(evaluationContextProvider, "ExpressionEvaluationContextProvider must not be null!");
 		Assert.notNull(parser, "Parser must not be null!");
+		Assert.notNull(queryRewriter, "QueryRewriter must not be null!");
 
 		this.evaluationContextProvider = evaluationContextProvider;
 		this.query = new ExpressionBasedStringQuery(queryString, method.getEntityInformation(), parser,
@@ -85,7 +84,7 @@ public AbstractStringBasedJpaQuery(JpaQueryMethod method, EntityManager em, Stri
 				method.isNativeQuery());
 
 		this.parser = parser;
-		this.queryRewriterSupplier = queryRewriterProvider.of(method);
+		this.queryRewriter = queryRewriter;
 
 		Assert.isTrue(method.isNativeQuery() || !query.usesJdbcStyleParameters(),
 				"JDBC style parameters (?) are not supported for JPA queries.");
@@ -169,20 +168,14 @@ protected Query createJpaQuery(String queryString, Sort sort, @Nullable Pageable
 	/**
 	 * Use the {@link QueryRewriter}, potentially rewrite the query, using relevant {@link Sort} and {@link Pageable}
 	 * information.
-	 * 
+	 *
 	 * @param originalQuery
 	 * @param sort
 	 * @param pageable
 	 * @return
 	 */
 	protected String potentiallyRewriteQuery(String originalQuery, Sort sort, @Nullable Pageable pageable) {
 
-		QueryRewriter queryRewriter = this.queryRewriterSupplier.get();
-
-		if (queryRewriter == null) {
-			return originalQuery;
-		}
-
 		return pageable != null && pageable.isPaged() //
 				? queryRewriter.rewrite(originalQuery, pageable) //
 				: queryRewriter.rewrite(originalQuery, sort);

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/QueryRewriterBeanFactoryProvider.java renamed to spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/BeanFactoryQueryRewriterProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2008-2022 the original author or authors.
+ * Copyright 2022 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.
@@ -15,36 +15,38 @@
  */
 package org.springframework.data.jpa.repository.query;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.beans.BeansException;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.data.jpa.repository.QueryRewriter;
+import org.springframework.data.util.Lazy;
 
 /**
  * A {@link BeanFactory}-based {@link QueryRewriterProvider}.
  *
  * @author Greg Turnquist
+ * @author Mark Paluch
  * @since 3.0
  */
-public class QueryRewriterBeanFactoryProvider extends QueryRewriterProvider {
-
-	private static final Log LOGGER = LogFactory.getLog(QueryRewriterBeanFactoryProvider.class);
+public class BeanFactoryQueryRewriterProvider implements QueryRewriterProvider {
 
 	private final BeanFactory beanFactory;
 
-	public QueryRewriterBeanFactoryProvider(BeanFactory beanFactory) {
+	public BeanFactoryQueryRewriterProvider(BeanFactory beanFactory) {
 		this.beanFactory = beanFactory;
 	}
 
 	@Override
-	protected QueryRewriter extractQueryRewriterBean(Class<? extends QueryRewriter> queryRewriter) {
+	@SuppressWarnings("unchecked")
+	public QueryRewriter getQueryRewriter(JpaQueryMethod method) {
 
-		try {
-			return beanFactory.getBean(queryRewriter);
-		} catch (BeansException e) {
-			LOGGER.error(e.toString());
-			return null;
+		Class<? extends QueryRewriter> queryRewriter = method.getQueryRewriter();
+		if (queryRewriter == QueryRewriter.IdentityQueryRewriter.class) {
+			return QueryRewriter.IdentityQueryRewriter.INSTANCE;
 		}
+
+		Lazy<QueryRewriter> rewriter = Lazy.of(() -> beanFactory.getBeanProvider((Class<QueryRewriter>) queryRewriter)
+				.getIfAvailable(() -> BeanUtils.instantiateClass(queryRewriter)));
+
+		return new DelegatingQueryRewriter(rewriter);
 	}
 }

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/DelegatingQueryRewriter.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2022 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
+ *
+ *      https://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.util.function.Supplier;
+
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.jpa.repository.QueryRewriter;
+
+/**
+ * Delegating {@link QueryRewriter} that delegates rewrite calls to a {@link QueryRewriter delegate} provided by a
+ * {@link Supplier}.
+ *
+ * @author Mark Paluch
+ * @since 3.0
+ */
+public class DelegatingQueryRewriter implements QueryRewriter {
+
+	private final Supplier<QueryRewriter> delegate;
+
+	public DelegatingQueryRewriter(Supplier<QueryRewriter> delegate) {
+		this.delegate = delegate;
+	}
+
+	@Override
+	public String rewrite(String query, Sort sort) {
+		return delegate.get().rewrite(query, sort);
+	}
+
+	@Override
+	public String rewrite(String query, Pageable pageRequest) {
+		return delegate.get().rewrite(query, pageRequest);
+	}
+}

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/JpaQueryFactory.java

@@ -17,6 +17,7 @@
 
 import jakarta.persistence.EntityManager;
 
+import org.springframework.data.jpa.repository.QueryRewriter;
 import org.springframework.data.repository.query.QueryMethodEvaluationContextProvider;
 import org.springframework.data.repository.query.RepositoryQuery;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
@@ -39,20 +40,20 @@ enum JpaQueryFactory {
 	 *
 	 * @param method must not be {@literal null}.
 	 * @param em must not be {@literal null}.
-	 * @param queryString must not be {@literal null} or empty.
 	 * @param countQueryString
+	 * @param queryString must not be {@literal null}.
 	 * @param evaluationContextProvider
 	 * @return
 	 */
 	AbstractJpaQuery fromMethodWithQueryString(JpaQueryMethod method, EntityManager em, String queryString,
-			@Nullable String countQueryString, QueryMethodEvaluationContextProvider evaluationContextProvider,
-			QueryRewriterProvider queryRewriterProvider) {
+			@Nullable String countQueryString, QueryRewriter queryRewriter,
+			QueryMethodEvaluationContextProvider evaluationContextProvider) {
 
 		return method.isNativeQuery()
-				? new NativeJpaQuery(method, em, queryString, countQueryString, evaluationContextProvider, PARSER,
-				queryRewriterProvider)
-				: new SimpleJpaQuery(method, em, queryString, countQueryString, evaluationContextProvider, PARSER,
-				queryRewriterProvider);
+				? new NativeJpaQuery(method, em, queryString, countQueryString, queryRewriter, evaluationContextProvider,
+						PARSER)
+				: new SimpleJpaQuery(method, em, queryString, countQueryString, queryRewriter, evaluationContextProvider,
+						PARSER);
 	}
 
 	/**