DATACMNS-1158 - Polishing.

Some code reorganization, polishing of nullable annotations, JavaDoc.

Original pull request: #243.
Related issue: DATAJPA-1173.

Author: odrotbohm

src/main/java/org/springframework/data/repository/core/support/RepositoryFactorySupport.java

@@ -34,7 +34,6 @@
 
 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
-import org.jetbrains.annotations.NotNull;
 import org.springframework.aop.framework.ProxyFactory;
 import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
 import org.springframework.beans.BeanUtils;
@@ -315,18 +314,23 @@ public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fra
 		postProcessors.forEach(processor -> processor.postProcess(result, information));
 
 		result.addAdvice(new DefaultMethodInvokingMethodInterceptor());
-		result.addAdvice(new QueryExecutorMethodInterceptor( //
-				information, //
-				getProjectionFactory(classLoader, beanFactory) //
-		));
+
+		ProjectionFactory projectionFactory = getProjectionFactory(classLoader, beanFactory);
+		result.addAdvice(new QueryExecutorMethodInterceptor(information, projectionFactory));
 
 		composition = composition.append(RepositoryFragment.implemented(target));
 		result.addAdvice(new ImplementationMethodExecutionInterceptor(composition));
 
 		return (T) result.getProxy(classLoader);
 	}
 
-	@NotNull
+	/**
+	 * Returns the {@link ProjectionFactory} to be used with the repository instances created.
+	 * 
+	 * @param classLoader will never be {@literal null}.
+	 * @param beanFactory will never be {@literal null}.
+	 * @return will never be {@literal null}.
+	 */
 	protected ProjectionFactory getProjectionFactory(ClassLoader classLoader, BeanFactory beanFactory) {
 
 		SpelAwareProxyProjectionFactory factory = new SpelAwareProxyProjectionFactory();
@@ -532,22 +536,25 @@ public QueryExecutorMethodInterceptor(RepositoryInformation repositoryInformatio
 						+ "infrastructure apparently does not support query methods!");
 			}
 
-			this.queries = lookupStrategy.map( //
-					it -> mapMethodsToQuery(repositoryInformation, projectionFactory, it) //
-			).orElse(Collections.emptyMap());
+			this.queries = lookupStrategy //
+					.map(it -> mapMethodsToQuery(repositoryInformation, it, projectionFactory)) //
+					.orElse(Collections.emptyMap());
 		}
 
 		private Map<Method, RepositoryQuery> mapMethodsToQuery(RepositoryInformation repositoryInformation,
-				ProjectionFactory projectionFactory, QueryLookupStrategy lookupStrategy) {
+				QueryLookupStrategy lookupStrategy, ProjectionFactory projectionFactory) {
 
 			return repositoryInformation.getQueryMethods().stream() //
-					.map(method -> Pair.of( //
-							method, //
-							lookupStrategy.resolveQuery(method, repositoryInformation, projectionFactory, namedQueries))) //
+					.map(method -> lookupQuery(method, repositoryInformation, lookupStrategy, projectionFactory)) //
 					.peek(pair -> invokeListeners(pair.getSecond())) //
 					.collect(Pair.toMap());
 		}
 
+		private Pair<Method, RepositoryQuery> lookupQuery(Method method, RepositoryInformation information,
+				QueryLookupStrategy strategy, ProjectionFactory projectionFactory) {
+			return Pair.of(method, strategy.resolveQuery(method, information, projectionFactory, namedQueries));
+		}
+
 		@SuppressWarnings({ "rawtypes", "unchecked" })
 		private void invokeListeners(RepositoryQuery query) {
 
@@ -580,6 +587,7 @@ public Object invoke(@SuppressWarnings("null") MethodInvocation invocation) thro
 			return resultHandler.postProcessInvocationResult(result, methodReturnTypeDescriptor);
 		}
 
+		@Nullable
 		private Object doInvoke(MethodInvocation invocation) throws Throwable {
 
 			Method method = invocation.getMethod();
@@ -603,7 +611,6 @@ private boolean hasQueryFor(Method method) {
 		}
 	}
 
-
 	/**
 	 * Method interceptor that calls methods on the {@link RepositoryComposition}.
 	 *

src/main/java/org/springframework/data/util/Pair.java

@@ -24,6 +24,7 @@
 import java.util.Map;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * A tuple of things.
@@ -72,6 +73,11 @@ public T getSecond() {
 		return second;
 	}
 
+	/**
+	 * A collector to create a {@link Map} from a {@link Stream} of {@link Pair}s.
+	 *
+	 * @return
+	 */
 	public static <S, T> Collector<Pair<S, T>, ?, Map<S, T>> toMap() {
 		return Collectors.toMap(Pair::getFirst, Pair::getSecond);
 	}