DATAJDBC-430 - Polishing.

Renames *Bean annotation attributes to *Ref to match other similar attributes.
Removes additional arguments from constructors of public classes in order to avoid breaking the API.
Gathers application context configuration for StringBasedJdbcQueryMappingConfigurationIntegrationTests in a single java file.
Formatting.
Adds the author tag.
Changes default value of references to the empty String.

Original pull request: #249.

Author: schauder

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/JdbcQueryMethod.java

@@ -46,6 +46,7 @@
  * @author Jens Schauder
  * @author Kazuki Shimizu
  * @author Moises Cisneros
+ * @author Hebert Coelho
  */
 public class JdbcQueryMethod extends QueryMethod {
 
@@ -175,13 +176,13 @@ Class<? extends RowMapper> getRowMapperClass() {
 
 
 	/**
-	 * Returns the bean to be used as {@link org.springframework.jdbc.core.RowMapper}
+	 * Returns the name of the bean to be used as {@link org.springframework.jdbc.core.RowMapper}
 	 *
 	 * @return May be {@code null}.
 	 */
 	@Nullable
-	String getRowMapperBean() {
-		return getMergedAnnotationAttribute("rowMapperBean");
+	String getRowMapperRef() {
+		return getMergedAnnotationAttribute("rowMapperRef");
 	}
 
 	/**
@@ -195,13 +196,13 @@ Class<? extends ResultSetExtractor> getResultSetExtractorClass() {
 	}
 
 	/**
-	 * Returns the bean to be used as {@link org.springframework.jdbc.core.ResultSetExtractor}
+	 * Returns the bean name to be used as {@link org.springframework.jdbc.core.ResultSetExtractor}
 	 *
 	 * @return May be {@code null}.
 	 */
 	@Nullable
-	String getResultSetExtractorBean() {
-		return getMergedAnnotationAttribute("resultSetExtractorBean");
+	String getResultSetExtractorRef() {
+		return getMergedAnnotationAttribute("resultSetExtractorRef");
 	}
 
 	/**

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

@@ -32,6 +32,7 @@
  *
  * @author Jens Schauder
  * @author Moises Cisneros
+ * @author Hebert Coelho
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
@@ -57,10 +58,12 @@
 	Class<? extends RowMapper> rowMapperClass() default RowMapper.class;
 
 	/**
-	 * Optional bean of type {@link RowMapper} to use to convert the result of the query to domain class instances. Cannot be used
+	 * Optional name of a bean of type {@link RowMapper} to use to convert the result of the query to domain class instances. Cannot be used
 	 * along with {@link #resultSetExtractorClass()} only one of the two can be set.
+	 *
+	 * @since 2.1
 	 */
-	String rowMapperBean() default "RowMapper";
+	String rowMapperRef() default "";
 
 	/**
 	 * Optional {@link ResultSetExtractor} to use to convert the result of the query to domain class instances. Cannot be
@@ -69,8 +72,10 @@
 	Class<? extends ResultSetExtractor> resultSetExtractorClass() default ResultSetExtractor.class;
 
 	/**
-	 * Optional bean of type {@link ResultSetExtractor} to use to convert the result of the query to domain class instances. Cannot be
+	 * Optional name of a bean of type {@link ResultSetExtractor} to use to convert the result of the query to domain class instances. Cannot be
 	 * used along with {@link #rowMapperClass()} only one of the two can be set.
+	 *
+	 * @since 2.1
 	 */
-	String resultSetExtractorBean() default "ResultSetExtractor";
+	String resultSetExtractorRef() default "";
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/StringBasedJdbcQuery.java

@@ -26,11 +26,13 @@
 import org.springframework.data.jdbc.support.JdbcUtil;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 import org.springframework.data.repository.query.Parameter;
+import org.springframework.data.util.Lazy;
 import org.springframework.jdbc.core.ResultSetExtractor;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
 import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
@@ -43,16 +45,17 @@
  * @author Oliver Gierke
  * @author Maciej Walkowiak
  * @author Mark Paluch
+ * @author Hebert Coelho
  * @since 2.0
  */
 public class StringBasedJdbcQuery extends AbstractJdbcQuery {
 
 	private static final String PARAMETER_NEEDS_TO_BE_NAMED = "For queries with named parameters you need to provide names for method parameters. Use @Param for query method parameters, or when on Java 8+ use the javac flag -parameters.";
 
 	private final JdbcQueryMethod queryMethod;
-	private final JdbcQueryExecution<?> executor;
+	private final Lazy<JdbcQueryExecution<?>> executor;
 	private final JdbcConverter converter;
-	private BeanFactory beanfactory;
+	private BeanFactory beanFactory;
 
 	/**
 	 * Creates a new {@link StringBasedJdbcQuery} for the given {@link JdbcQueryMethod}, {@link RelationalMappingContext}
@@ -63,20 +66,20 @@ public class StringBasedJdbcQuery extends AbstractJdbcQuery {
 	 * @param defaultRowMapper can be {@literal null} (only in case of a modifying query).
 	 */
 	public StringBasedJdbcQuery(JdbcQueryMethod queryMethod, NamedParameterJdbcOperations operations,
-			@Nullable RowMapper<?> defaultRowMapper, JdbcConverter converter, BeanFactory beanfactory) {
+			@Nullable RowMapper<?> defaultRowMapper, JdbcConverter converter) {
 
 		super(queryMethod, operations, defaultRowMapper);
 
 		this.queryMethod = queryMethod;
 		this.converter = converter;
-		this.beanfactory = beanfactory;
 
-		RowMapper<Object> rowMapper = determineRowMapper(defaultRowMapper);
-		executor = getQueryExecution( //
+		executor = Lazy.of(() -> {
+			RowMapper<Object> rowMapper = determineRowMapper(defaultRowMapper);
+			return getQueryExecution( //
 				queryMethod, //
 				determineResultSetExtractor(rowMapper != defaultRowMapper ? rowMapper : null), //
 				rowMapper //
-		);
+		);});
 	}
 
 	/*
@@ -85,7 +88,7 @@ public StringBasedJdbcQuery(JdbcQueryMethod queryMethod, NamedParameterJdbcOpera
 	 */
 	@Override
 	public Object execute(Object[] objects) {
-		return executor.execute(determineQuery(), this.bindParameters(objects));
+		return executor.get().execute(determineQuery(), this.bindParameters(objects));
 	}
 
 	/*
@@ -97,7 +100,7 @@ public JdbcQueryMethod getQueryMethod() {
 		return queryMethod;
 	}
 
-	MapSqlParameterSource bindParameters(Object[] objects) {
+	private MapSqlParameterSource bindParameters(Object[] objects) {
 
 		MapSqlParameterSource parameters = new MapSqlParameterSource();
 
@@ -140,10 +143,14 @@ private String determineQuery() {
 	@Nullable
 	@SuppressWarnings({ "rawtypes", "unchecked" })
 	ResultSetExtractor<Object> determineResultSetExtractor(@Nullable RowMapper<Object> rowMapper) {
-		String resultSetExtractorBean = queryMethod.getResultSetExtractorBean();
 
-		if (resultSetExtractorBean != null && !"ResultSetExtractor".equals(resultSetExtractorBean)) {
-			return (ResultSetExtractor<Object>) beanfactory.getBean(resultSetExtractorBean);
+		String resultSetExtractorRef = queryMethod.getResultSetExtractorRef();
+
+		if (!StringUtils.isEmpty(resultSetExtractorRef)) {
+
+			Assert.notNull(beanFactory, "When a ResultSetExtractorRef is specified the BeanFactory must not be null");
+
+			return (ResultSetExtractor<Object>) beanFactory.getBean(resultSetExtractorRef);
 		}
 
 		Class<? extends ResultSetExtractor> resultSetExtractorClass = queryMethod.getResultSetExtractorClass();
@@ -163,12 +170,16 @@ ResultSetExtractor<Object> determineResultSetExtractor(@Nullable RowMapper<Objec
 	}
 
 	@SuppressWarnings("unchecked")
+	@Nullable
 	RowMapper<Object> determineRowMapper(@Nullable RowMapper<?> defaultMapper) {
 
-		String rowMapperBean = queryMethod.getRowMapperBean();
+		String rowMapperRef = queryMethod.getRowMapperRef();
 
-		if (rowMapperBean != null && !"RowMapper".equals(rowMapperBean)) {
-			return (RowMapper<Object>) beanfactory.getBean(rowMapperBean);
+		if (!StringUtils.isEmpty(rowMapperRef)) {
+
+			Assert.notNull(beanFactory, "When a RowMapperRef is specified the BeanFactory must not be null");
+
+			return (RowMapper<Object>) beanFactory.getBean(rowMapperRef);
 		}
 
 		Class<?> rowMapperClass = queryMethod.getRowMapperClass();
@@ -183,4 +194,8 @@ RowMapper<Object> determineRowMapper(@Nullable RowMapper<?> defaultMapper) {
 	private static boolean isUnconfigured(@Nullable Class<?> configuredClass, Class<?> defaultClass) {
 		return configuredClass == null || configuredClass == defaultClass;
 	}
+
+	public void setBeanFactory(BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
+	}
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategy.java

@@ -54,6 +54,7 @@
  * @author Mark Paluch
  * @author Maciej Walkowiak
  * @author Moises Cisneros
+ * @author Hebert Coelho
  */
 class JdbcQueryLookupStrategy implements QueryLookupStrategy {
 
@@ -64,9 +65,9 @@ class JdbcQueryLookupStrategy implements QueryLookupStrategy {
 	private final Dialect dialect;
 	private final QueryMappingConfiguration queryMappingConfiguration;
 	private final NamedParameterJdbcOperations operations;
-	private BeanFactory beanfactory;
+	private final BeanFactory beanfactory;
 
-	public JdbcQueryLookupStrategy(ApplicationEventPublisher publisher, @Nullable EntityCallbacks callbacks,
+	JdbcQueryLookupStrategy(ApplicationEventPublisher publisher, @Nullable EntityCallbacks callbacks,
 			RelationalMappingContext context, JdbcConverter converter, Dialect dialect,
 			QueryMappingConfiguration queryMappingConfiguration, NamedParameterJdbcOperations operations,
 		    BeanFactory beanfactory) {
@@ -103,12 +104,14 @@ public RepositoryQuery resolveQuery(Method method, RepositoryMetadata repository
 			if (namedQueries.hasQuery(queryMethod.getNamedQueryName()) || queryMethod.hasAnnotatedQuery()) {
 
 				RowMapper<?> mapper = queryMethod.isModifyingQuery() ? null : createMapper(queryMethod);
-				return new StringBasedJdbcQuery(queryMethod, operations, mapper, converter, beanfactory);
+				StringBasedJdbcQuery query = new StringBasedJdbcQuery(queryMethod, operations, mapper, converter);
+				query.setBeanFactory(beanfactory);
+				return query;
 			} else {
 				return new PartTreeJdbcQuery(context, queryMethod, dialect, converter, operations, createMapper(queryMethod));
 			}
 		} catch (Exception e) {
-			throw QueryCreationException.create(queryMethod, e.getMessage());
+			throw QueryCreationException.create(queryMethod, e);
 		}
 	}
 
@@ -120,10 +123,10 @@ private RowMapper<Object> createMapper(JdbcQueryMethod queryMethod) {
 		RelationalPersistentEntity<?> persistentEntity = context.getPersistentEntity(returnedObjectType);
 
 		if (persistentEntity == null) {
-			return (RowMapper) SingleColumnRowMapper.newInstance(returnedObjectType, converter.getConversionService());
+			return (RowMapper<Object>) SingleColumnRowMapper.newInstance(returnedObjectType, converter.getConversionService());
 		}
 
-		return (RowMapper) determineDefaultMapper(queryMethod);
+		return (RowMapper<Object>) determineDefaultMapper(queryMethod);
 	}
 
 	private RowMapper<?> determineDefaultMapper(JdbcQueryMethod queryMethod) {

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java

@@ -45,6 +45,7 @@
  * @author Greg Turnquist
  * @author Christoph Strobl
  * @author Mark Paluch
+ * @author Hebert Coelho
  */
 public class JdbcRepositoryFactory extends RepositoryFactorySupport {
 
@@ -54,7 +55,7 @@ public class JdbcRepositoryFactory extends RepositoryFactorySupport {
 	private final DataAccessStrategy accessStrategy;
 	private final NamedParameterJdbcOperations operations;
 	private final Dialect dialect;
-	private BeanFactory beanfactory;
+	@Nullable private BeanFactory beanFactory;
 
 	private QueryMappingConfiguration queryMappingConfiguration = QueryMappingConfiguration.EMPTY;
 	private EntityCallbacks entityCallbacks;
@@ -72,7 +73,7 @@ public class JdbcRepositoryFactory extends RepositoryFactorySupport {
 	 */
 	public JdbcRepositoryFactory(DataAccessStrategy dataAccessStrategy, RelationalMappingContext context,
 			JdbcConverter converter, Dialect dialect, ApplicationEventPublisher publisher,
-			NamedParameterJdbcOperations operations, BeanFactory beanfactory) {
+			NamedParameterJdbcOperations operations) {
 
 		Assert.notNull(dataAccessStrategy, "DataAccessStrategy must not be null!");
 		Assert.notNull(context, "RelationalMappingContext must not be null!");
@@ -86,7 +87,6 @@ public JdbcRepositoryFactory(DataAccessStrategy dataAccessStrategy, RelationalMa
 		this.dialect = dialect;
 		this.accessStrategy = dataAccessStrategy;
 		this.operations = operations;
-		this.beanfactory = beanfactory;
 	}
 
 	/**
@@ -122,7 +122,8 @@ protected Object getTargetRepository(RepositoryInformation repositoryInformation
 			template.setEntityCallbacks(entityCallbacks);
 		}
 
-		RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(repositoryInformation.getDomainType());
+		RelationalPersistentEntity<?> persistentEntity = context
+				.getRequiredPersistentEntity(repositoryInformation.getDomainType());
 
 		return getTargetRepositoryViaReflection(repositoryInformation.getRepositoryBaseClass(), template, persistentEntity);
 	}
@@ -145,7 +146,7 @@ protected Optional<QueryLookupStrategy> getQueryLookupStrategy(@Nullable QueryLo
 			QueryMethodEvaluationContextProvider evaluationContextProvider) {
 
 		return Optional.of(new JdbcQueryLookupStrategy(publisher, entityCallbacks, context, converter, dialect,
-				queryMappingConfiguration, operations, beanfactory));
+				queryMappingConfiguration, operations, beanFactory));
 	}
 
 	/**
@@ -155,4 +156,12 @@ protected Optional<QueryLookupStrategy> getQueryLookupStrategy(@Nullable QueryLo
 	public void setEntityCallbacks(EntityCallbacks entityCallbacks) {
 		this.entityCallbacks = entityCallbacks;
 	}
+
+	/**
+	 * @param beanFactory the {@link BeanFactory} used for looking up {@link org.springframework.jdbc.core.RowMapper} and
+	 *          {@link org.springframework.jdbc.core.ResultSetExtractor} beans.
+	 */
+	public void setBeanFactory(@Nullable BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
+	}
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java

@@ -44,6 +44,7 @@
  * @author Christoph Strobl
  * @author Oliver Gierke
  * @author Mark Paluch
+ * @author Hebert Coelho
  */
 public class JdbcRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extends Serializable>
 		extends TransactionalRepositoryFactoryBeanSupport<T, S, ID> implements ApplicationEventPublisherAware {
@@ -86,9 +87,10 @@ public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
 	protected RepositoryFactorySupport doCreateRepositoryFactory() {
 
 		JdbcRepositoryFactory jdbcRepositoryFactory = new JdbcRepositoryFactory(dataAccessStrategy, mappingContext,
-				converter, dialect, publisher, operations, beanFactory);
+				converter, dialect, publisher, operations);
 		jdbcRepositoryFactory.setQueryMappingConfiguration(queryMappingConfiguration);
 		jdbcRepositoryFactory.setEntityCallbacks(entityCallbacks);
+		jdbcRepositoryFactory.setBeanFactory(beanFactory);
 
 		return jdbcRepositoryFactory;
 	}

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/SimpleJdbcRepositoryEventsUnitTests.java

@@ -32,7 +32,6 @@
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.stubbing.Answer;
-import org.springframework.beans.factory.BeanFactory;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.domain.PageRequest;
@@ -83,7 +82,6 @@ public class SimpleJdbcRepositoryEventsUnitTests {
 
 	DummyEntityRepository repository;
 	DefaultDataAccessStrategy dataAccessStrategy;
-	BeanFactory beanFactory = mock(BeanFactory.class);
 
 	@Before
 	public void before() {
@@ -101,7 +99,7 @@ public void before() {
 		doReturn(true).when(dataAccessStrategy).update(any(), any());
 
 		JdbcRepositoryFactory factory = new JdbcRepositoryFactory(dataAccessStrategy, context, converter,
-				H2Dialect.INSTANCE, publisher, operations, beanFactory);
+				H2Dialect.INSTANCE, publisher, operations);
 
 		this.repository = factory.getRepository(DummyEntityRepository.class);
 	}