Review, refactor and polish Spring Data AOT infrastructure classes.

* Refactored logic in AOT infrastructure classes.
* Annotated AOT API with Spring's @nonnull and @nullable annotations.
* Edited Javadoc.
* Introduced PredicateUtils abstract utility class encapsulating common Predicates on types and class members.
* Added comments for review and clarification.

Author: jxblum

src/main/java/org/springframework/data/ManagedTypes.java

@@ -22,43 +22,96 @@
 import java.util.stream.Stream;
 
 import org.springframework.data.util.Lazy;
+import org.springframework.lang.NonNull;
 
 /**
  * Types managed by a Spring Data implementation. Used to predefine a set of know entities that might need processing
- * during container/repository initialization phase.
+ * during the Spring container, Spring Data Repository initialization phase.
  *
  * @author Christoph Strobl
+ * @see java.lang.FunctionalInterface
  * @since 3.0
  */
+@FunctionalInterface
 public interface ManagedTypes {
 
-	void forEach(Consumer<Class<?>> action);
-
-	default List<Class<?>> toList() {
-
-		List<Class<?>> tmp = new ArrayList<>(100);
-		forEach(tmp::add);
-		return tmp;
-	}
-
-	static ManagedTypes of(Iterable<? extends Class<?>> types) {
+	/**
+	 * Factory method used to construct {@link ManagedTypes} from the given {@link Iterable} of {@link Class types}.
+	 *
+	 * @param types {@link Iterable} of {@link Class types} used to initialize the new {@link ManagedTypes} instance;
+	 * must not be {@literal null}.
+	 * @return new instance of {@link ManagedTypes} initialized the given {@link Iterable} of {@link Class types}.
+	 * @see java.lang.Iterable
+	 * @see #of(Stream)
+	 * @see #of(Supplier)
+	 */
+	@NonNull
+	static ManagedTypes of(@NonNull Iterable<? extends Class<?>> types) {
 		return types::forEach;
 	}
 
-	static ManagedTypes of(Stream<? extends Class<?>> types) {
+	/**
+	 * Factory method used to construct {@link ManagedTypes} from the given {@link Stream} of {@link Class types}.
+	 *
+	 * @param types {@link Stream} of {@link Class types} used to initialize the new {@link ManagedTypes} instance;
+	 * must not be {@literal null}.
+	 * @return new instance of {@link ManagedTypes} initialized the given {@link Stream} of {@link Class types}.
+	 * @see java.util.stream.Stream
+	 * @see #of(Iterable)
+	 * @see #of(Supplier)
+	 */
+	@NonNull
+	static ManagedTypes of(@NonNull Stream<? extends Class<?>> types) {
 		return types::forEach;
 	}
 
-	static ManagedTypes o(Supplier<Iterable<? extends Class<?>>> dataProvider) {
+	/**
+	 * Factory method used to construct {@link ManagedTypes} from the given {@link Supplier} of
+	 * an {@link Iterable} of {@link Class types}.
+	 *
+	 * @param dataProvider {@link Supplier} of an {@link Iterable} of {@link Class types} used to lazily initialize
+	 * the new {@link ManagedTypes} instance; must not be {@literal null}.
+	 * @return new instance of {@link ManagedTypes} initialized the given {@link Supplier} of
+	 * an {@link Iterable} of {@link Class types}.
+	 * @see java.util.function.Supplier
+	 * @see java.lang.Iterable
+	 * @see #of(Iterable)
+	 * @see #of(Stream)
+	 */
+	@NonNull
+	static ManagedTypes of(@NonNull Supplier<Iterable<? extends Class<?>>> dataProvider) {
 
 		return new ManagedTypes() {
 
-			Lazy<Iterable<? extends Class<?>>> lazyProvider = Lazy.of(dataProvider);
+			final Lazy<Iterable<? extends Class<?>>> lazyProvider = Lazy.of(dataProvider);
 
 			@Override
-			public void forEach(Consumer<Class<?>> action) {
+			public void forEach(@NonNull Consumer<Class<?>> action) {
 				lazyProvider.get().forEach(action);
 			}
 		};
 	}
+
+	/**
+	 * Applies the given {@link Consumer action} to each of the {@link Class type} contained in
+	 * this {@link ManagedTypes} instance.
+	 *
+	 * @param action {@link Consumer} defining the action to perform on the {@link Class types}
+	 * contained in this {@link ManagedTypes} instance; must not be {@literal null}.
+	 * @see java.util.function.Consumer
+	 */
+	void forEach(Consumer<Class<?>> action);
+
+	/**
+	 * Returns all the {@link ManagedTypes} in a {@link List}.
+	 *
+	 * @return these {@link ManagedTypes} in a {@link List}; never {@literal null}.
+	 * @see java.util.List
+	 */
+	default List<Class<?>> toList() {
+
+		List<Class<?>> list = new ArrayList<>(100);
+		forEach(list::add);
+		return list;
+	}
 }

src/main/java/org/springframework/data/aot/AotContext.java

@@ -28,113 +28,249 @@
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ObjectUtils;
 
 /**
- * The context in which the AOT processing happens. Grants access to the {@link ConfigurableListableBeanFactory
- * beanFactory} and {@link ClassLoader}. Holds a few convenience methods to check if a type
- * {@link #isTypePresent(String) is present} and allows resolution of them. <strong>WARNING:</strong> Unstable internal
- * API!
+ * The context in which the AOT processing happens.
+ *
+ * Grants access to the {@link ConfigurableListableBeanFactory beanFactory} and {@link ClassLoader}. Holds a few
+ * convenience methods to check if a type {@link #isTypePresent(String) is present} and allows resolution of them.
+ *
+ * <strong>WARNING:</strong> Unstable internal API!
  *
  * @author Christoph Strobl
+ * @author John Blum
+ * @see org.springframework.beans.factory.config.ConfigurableListableBeanFactory
+ * @since 3.0
  */
 public interface AotContext {
 
 	/**
 	 * Create an {@link AotContext} backed by the given {@link BeanFactory}.
 	 *
-	 * @param beanFactory must not be {@literal null}.
-	 * @return new instance of {@link AotContext}.
+	 * @param beanFactory reference to the {@link BeanFactory}; must not be {@literal null}.
+	 * @return a new instance of {@link AotContext}.
+	 * @see BeanFactory
 	 */
-	static AotContext context(BeanFactory beanFactory) {
+	static AotContext from(@NonNull BeanFactory beanFactory) {
 
-		Assert.notNull(beanFactory, "BeanFactory must not be null!");
+		Assert.notNull(beanFactory, "BeanFactory must not be null");
 
 		return new AotContext() {
 
 			private final ConfigurableListableBeanFactory bf = beanFactory instanceof ConfigurableListableBeanFactory
 					? (ConfigurableListableBeanFactory) beanFactory
 					: new DefaultListableBeanFactory(beanFactory);
 
+			@NonNull
 			@Override
 			public ConfigurableListableBeanFactory getBeanFactory() {
 				return bf;
 			}
 		};
 	}
 
+	/**
+	 * Returns a reference to the {@link ConfigurableListableBeanFactory} backing this {@link AotContext}.
+	 *
+	 * @return a reference to the {@link ConfigurableListableBeanFactory} backing this {@link AotContext}.
+	 * @see ConfigurableListableBeanFactory
+	 */
 	ConfigurableListableBeanFactory getBeanFactory();
 
+	/**
+	 * Returns the {@link ClassLoader} used by this {@link AotContext} to resolve {@link Class types}.
+	 *
+	 * By default, this is the same {@link ClassLoader} used by the {@link BeanFactory} to resolve {@link Class types}
+	 * declared in bean definitions.
+	 *
+	 * @return the {@link ClassLoader} used by this {@link AotContext} to resolve {@link Class types}.
+	 * @see ConfigurableListableBeanFactory#getBeanClassLoader()
+	 */
+	@Nullable
 	default ClassLoader getClassLoader() {
 		return getBeanFactory().getBeanClassLoader();
 	}
 
-	default boolean isTypePresent(String typeName) {
-		return ClassUtils.isPresent(typeName, getBeanFactory().getBeanClassLoader());
+	/**
+	 * Determines whether the given {@link String named} {@link Class type} is present on the application classpath.
+	 *
+	 * @param typeName {@link String name} of the {@link Class type} to evaluate; must not be {@literal null}.
+	 * @return {@literal true} if the given {@link String named} {@link Class type} is present
+	 * on the application classpath.
+	 * @see #getClassLoader()
+	 */
+	default boolean isTypePresent(@NonNull String typeName) {
+		return ClassUtils.isPresent(typeName, getClassLoader());
 	}
 
+	/**
+	 * Returns a new {@link TypeScanner} used to scan for {@link Class types} that will be contributed to the AOT
+	 * processing infrastructure.
+	 *
+	 * @return a {@link TypeScanner} used to scan for {@link Class types} that will be contributed to the AOT
+	 * processing infrastructure.
+	 * @see TypeScanner
+	 */
+	@NonNull
 	default TypeScanner getTypeScanner() {
 		return new TypeScanner(getClassLoader());
 	}
 
-	default Set<Class<?>> scanPackageForTypes(Collection<Class<? extends Annotation>> identifyingAnnotations,
+	/**
+	 * Scans for {@link Class types} in the given {@link String named packages} annotated with the store-specific
+	 * {@link Annotation identifying annotations}.
+	 *
+	 * @param identifyingAnnotations {@link Collection} of {@link Annotation Annotations} identifying store-specific
+	 * model {@link Class types}; must not be {@literal null}.
+	 * @param packageNames {@link Collection} of {@link String package names} to scan.
+	 * @return a {@link Set} of {@link Class types} found during the scan.
+	 * @see TypeScanner#scanForTypesAnnotatedWith(Class[])
+	 * @see TypeScanner.Scanner#inPackages(Collection)
+	 * @see #getTypeScanner()
+	 */
+	default Set<Class<?>> scanPackageForTypes(@NonNull Collection<Class<? extends Annotation>> identifyingAnnotations,
 			Collection<String> packageNames) {
+
 		return getTypeScanner().scanForTypesAnnotatedWith(identifyingAnnotations).inPackages(packageNames);
 	}
 
-	default Optional<Class<?>> resolveType(String typeName) {
-
-		if (!isTypePresent(typeName)) {
-			return Optional.empty();
-		}
-		return Optional.of(resolveRequiredType(typeName));
-	}
+	/**
+	 * Resolves the required {@link String named} {@link Class type}.
+	 *
+	 * @param typeName {@link String} containing the {@literal fully-qualified class name} of the {@link Class type}
+	 * to resolve; must not be {@literal null}.
+	 * @return a resolved {@link Class type} for the given, required {@link String name}.
+	 * @throws TypeNotPresentException if the {@link String named} {@link Class type} cannot be found.
+	 */
+	@NonNull
+	default Class<?> resolveRequiredType(@NonNull String typeName) throws TypeNotPresentException {
 
-	default Class<?> resolveRequiredType(String typeName) throws TypeNotPresentException {
 		try {
 			return ClassUtils.forName(typeName, getClassLoader());
-		} catch (ClassNotFoundException e) {
-			throw new TypeNotPresentException(typeName, e);
+		} catch (ClassNotFoundException cause) {
+			throw new TypeNotPresentException(typeName, cause);
 		}
 	}
 
+	/**
+	 * Resolves the given {@link String named} {@link Class type} if present.
+	 *
+	 * @param typeName {@link String} containing the {@literal fully-qualified class name} of the {@link Class type}
+	 * to resolve; must not be {@literal null}.
+	 * @return an {@link Optional} value containing the {@link Class type}
+	 * if the {@link String fully-qualified class name} is present on the application classpath.
+	 * @see #isTypePresent(String)
+	 * @see #resolveRequiredType(String)
+	 * @see java.util.Optional
+	 */
+	default Optional<Class<?>> resolveType(@NonNull String typeName) {
+
+		return isTypePresent(typeName)
+			? Optional.of(resolveRequiredType(typeName))
+			: Optional.empty();
+	}
+
+	/**
+	 * Resolves the {@link BeanDefinition bean's} defined {@link Class type}.
+	 *
+	 * @param beanReference {@link BeanReference} to the managed bean.
+	 * @return the {@link Class type} of the {@link BeanReference referenced bean} if defined; may be {@literal null}.
+	 * @see BeanReference
+	 */
 	@Nullable
-	default Class<?> resolveType(BeanReference beanReference) {
+	default Class<?> resolveType(@NonNull BeanReference beanReference) {
 		return getBeanFactory().getType(beanReference.getBeanName(), false);
 	}
 
-	default BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
+	/**
+	 * Gets the {@link BeanDefinition} for the given, required {@link String named bean}.
+	 *
+	 * @param beanName {@link String} containing the {@literal name} of the bean; must not be {@literal null}.
+	 * @return the {@link BeanDefinition} for the given, required {@link String named bean}.
+	 * @throws NoSuchBeanDefinitionException if a {@link BeanDefinition} cannot be found for
+	 * the {@link String named bean}.
+	 * @see BeanDefinition
+	 */
+	@NonNull
+	default BeanDefinition getBeanDefinition(@NonNull String beanName) throws NoSuchBeanDefinitionException {
 		return getBeanFactory().getBeanDefinition(beanName);
 	}
 
-	default RootBeanDefinition getRootBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
+	/**
+	 * Gets the {@link RootBeanDefinition} for the given, required {@link String bean name}.
+	 *
+	 * @param beanName {@link String} containing the {@literal name} of the bean.
+	 * @return the {@link RootBeanDefinition} for the given, required {@link String bean name}.
+	 * @throws NoSuchBeanDefinitionException if a {@link BeanDefinition} cannot be found for
+	 * the {@link String named bean}.
+	 * @throws IllegalStateException if the bean is not a {@link RootBeanDefinition root bean}.
+	 * @see RootBeanDefinition
+	 */
+	@NonNull
+	default RootBeanDefinition getRootBeanDefinition(@NonNull String beanName) throws NoSuchBeanDefinitionException {
+
+		BeanDefinition beanDefinition = getBeanDefinition(beanName);
 
-		BeanDefinition val = getBeanFactory().getBeanDefinition(beanName);
-		if (!(val instanceof RootBeanDefinition)) {
-			throw new IllegalStateException(String.format("%s is not a root bean", beanName));
+		if (beanDefinition instanceof RootBeanDefinition rootBeanDefinition) {
+			return rootBeanDefinition;
 		}
-		return RootBeanDefinition.class.cast(val);
+
+		throw new IllegalStateException(String.format("%s is not a root bean", beanName));
 	}
 
-	default boolean isFactoryBean(String beanName) {
+	/**
+	 * Determines whether a bean identified by the given, required {@link String name} is a
+	 * {@link org.springframework.beans.factory.FactoryBean}.
+	 *
+	 * @param beanName {@link String} containing the {@literal name} of the bean to evaluate;
+	 * must not be {@literal null}.
+	 * @return {@literal true} if the bean identified by the given, required {@link String name} is a
+	 * {@link org.springframework.beans.factory.FactoryBean}.
+	 */
+	default boolean isFactoryBean(@NonNull String beanName) {
 		return getBeanFactory().isFactoryBean(beanName);
 	}
 
+	/**
+	 * Determines whether a Spring {@link org.springframework.transaction.TransactionManager} is present.
+	 *
+	 * @return {@literal true} if a Spring {@link org.springframework.transaction.TransactionManager} is present.
+	 */
 	default boolean isTransactionManagerPresent() {
 
-		return resolveType("org.springframework.transaction.TransactionManager") //
-				.map(it -> !ObjectUtils.isEmpty(getBeanFactory().getBeanNamesForType(it))) //
-				.orElse(false);
+		return resolveType("org.springframework.transaction.TransactionManager")
+				.filter(it -> !ObjectUtils.isEmpty(getBeanFactory().getBeanNamesForType(it)))
+				.isPresent();
 	}
 
-	default void ifTypePresent(String typeName, Consumer<Class<?>> action) {
+	/**
+	 * Determines whether the given, required {@link String type name} is declared on the application classpath
+	 * and performs the given, required {@link Consumer action} if present.
+	 *
+	 * @param typeName {@link String name} of the {@link Class type} to process; must not be {@literal null}.
+	 * @param action {@link Consumer} defining the action to perform on the resolved {@link Class type};
+	 * must not be {@literal null}.
+	 * @see java.util.function.Consumer
+	 * @see #resolveType(String)
+	 */
+	default void ifTypePresent(@NonNull String typeName, @NonNull Consumer<Class<?>> action) {
 		resolveType(typeName).ifPresent(action);
 	}
 
-	default void ifTransactionManagerPresent(Consumer<String[]> beanNamesConsumer) {
+	/**
+	 * Runs the given {@link Consumer action} on any {@link org.springframework.transaction.TransactionManager} beans
+	 * defined in the application context.
+	 *
+	 * @param beanNamesConsumer {@link Consumer} defining the action to perform on
+	 * the {@link org.springframework.transaction.TransactionManager} beans if present; must not be {@literal null}.
+	 * @see java.util.function.Consumer
+	 */
+	default void ifTransactionManagerPresent(@NonNull Consumer<String[]> beanNamesConsumer) {
 
 		ifTypePresent("org.springframework.transaction.TransactionManager", txMgrType -> {
 			String[] txMgrBeanNames = getBeanFactory().getBeanNamesForType(txMgrType);