Polish changes in Spring Data adapting to the core Spring Framework AOT API changes.

* Reorganize the Spring Data AOT infrastructure classes; simplify logic.
* Use AotSpringFactoriesLoader.
* Fix failing tests.

Author: jxblum

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

@@ -16,31 +16,64 @@
 package org.springframework.data;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 import org.springframework.data.util.Lazy;
 import org.springframework.lang.NonNull;
+import org.springframework.lang.Nullable;
 
 /**
- * Types managed by a Spring Data implementation. Used to predefine a set of know entities that might need processing
- * during the Spring container, Spring Data Repository initialization phase.
+ * Types managed by a Spring Data implementation.
+ *
+ * Used to predefine a set of know entities that might need processing during the Spring container,
+ * Spring Data Repository initialization phase.
  *
  * @author Christoph Strobl
+ * @author John Blum
  * @see java.lang.FunctionalInterface
  * @since 3.0
  */
+// TODO: Does this need to be in org.springframework.data? Maybe move to org.springframework.data.domain?
 @FunctionalInterface
 public interface ManagedTypes {
 
 	/**
-	 * Factory method used to construct {@link ManagedTypes} from the given {@link Iterable} of {@link Class types}.
+	 * Factory method used to construct a new instance of {@link ManagedTypes} containing no {@link Class types}.
+	 *
+	 * @return an empty {@link ManagedTypes} instance.
+	 * @see java.util.Collections#emptySet()
+	 * @see #of(Iterable)
+	 */
+	@NonNull
+	static ManagedTypes empty() {
+		return of(Collections.emptySet());
+	}
+
+	/**
+	 * Factory method used to return a {@literal null-safe} instance of {@link ManagedTypes}.
+	 *
+	 * @param types {@link ManagedTypes} to evaluate.
+	 * @return the given {@link ManagedTypes} if not {@literal null}
+	 * or an {@link #empty()} {@link ManagedTypes} instance.
+	 * @see #empty()
+	 */
+	@NonNull
+	static ManagedTypes nullSafeManagedTypes(@Nullable ManagedTypes types) {
+		return types != null ? types : empty();
+	}
+
+	/**
+	 * Factory method used to construct {@link ManagedTypes} from the given, required {@link Iterable}
+	 * of {@link Class types}.
 	 *
-	 * @param types {@link Iterable} of {@link Class types} used to initialize the new {@link ManagedTypes} instance;
+	 * @param types {@link Iterable} of {@link Class types} used to initialize the {@link ManagedTypes};
 	 * must not be {@literal null}.
-	 * @return new instance of {@link ManagedTypes} initialized the given {@link Iterable} of {@link Class types}.
+	 * @return new instance of {@link ManagedTypes} initialized the given, required {@link Iterable}
+	 * of {@link Class types}.
 	 * @see java.lang.Iterable
 	 * @see #of(Stream)
 	 * @see #of(Supplier)
@@ -51,11 +84,13 @@ static ManagedTypes of(@NonNull Iterable<? extends Class<?>> types) {
 	}
 
 	/**
-	 * Factory method used to construct {@link ManagedTypes} from the given {@link Stream} of {@link Class types}.
+	 * Factory method used to construct {@link ManagedTypes} from the given, required {@link Stream}
+	 * of {@link Class types}.
 	 *
-	 * @param types {@link Stream} of {@link Class types} used to initialize the new {@link ManagedTypes} instance;
+	 * @param types {@link Stream} of {@link Class types} used to initialize the {@link ManagedTypes};
 	 * must not be {@literal null}.
-	 * @return new instance of {@link ManagedTypes} initialized the given {@link Stream} of {@link Class types}.
+	 * @return new instance of {@link ManagedTypes} initialized the given, required {@link Stream}
+	 * of {@link Class types}.
 	 * @see java.util.stream.Stream
 	 * @see #of(Iterable)
 	 * @see #of(Supplier)
@@ -66,12 +101,12 @@ static ManagedTypes of(@NonNull Stream<? extends Class<?>> types) {
 	}
 
 	/**
-	 * Factory method used to construct {@link ManagedTypes} from the given {@link Supplier} of
+	 * Factory method used to construct {@link ManagedTypes} from the given, required {@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
+	 * the {@link ManagedTypes}; must not be {@literal null}.
+	 * @return new instance of {@link ManagedTypes} initialized the given, required {@link Supplier} of
 	 * an {@link Iterable} of {@link Class types}.
 	 * @see java.util.function.Supplier
 	 * @see java.lang.Iterable
@@ -93,7 +128,7 @@ public void forEach(@NonNull Consumer<Class<?>> action) {
 	}
 
 	/**
-	 * Applies the given {@link Consumer action} to each of the {@link Class type} contained in
+	 * Applies the given {@link Consumer action} to each of the {@link Class types} contained in
 	 * this {@link ManagedTypes} instance.
 	 *
 	 * @param action {@link Consumer} defining the action to perform on the {@link Class types}

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

@@ -171,8 +171,8 @@ default Class<?> resolveRequiredType(@NonNull String typeName) throws TypeNotPre
 	default Optional<Class<?>> resolveType(@NonNull String typeName) {
 
 		return isTypePresent(typeName)
-			? Optional.of(resolveRequiredType(typeName))
-			: Optional.empty();
+				? Optional.of(resolveRequiredType(typeName))
+				: Optional.empty();
 	}
 
 	/**

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

@@ -62,21 +62,21 @@ public ConfigurableListableBeanFactory getBeanFactory() {
 	}
 
 	@Override
-	public String getBeanName() {
-		return beanName;
+	public Set<String> getBasePackages() {
+		return basePackages;
 	}
 
-	public void setBeanName(String beanName) {
-		this.beanName = beanName;
+	public void setBasePackages(Set<String> basePackages) {
+		this.basePackages = basePackages;
 	}
 
 	@Override
-	public Set<String> getBasePackages() {
-		return basePackages;
+	public String getBeanName() {
+		return beanName;
 	}
 
-	public void setBasePackages(Set<String> basePackages) {
-		this.basePackages = basePackages;
+	public void setBeanName(String beanName) {
+		this.beanName = beanName;
 	}
 
 	@Override
@@ -110,8 +110,8 @@ public Set<Class<?>> getResolvedTypes() {
 	protected Set<MergedAnnotation<Annotation>> discoverAnnotations() {
 
 		Set<MergedAnnotation<Annotation>> annotations = getResolvedTypes().stream()
-			.flatMap(type -> TypeUtils.resolveUsedAnnotations(type).stream())
-			.collect(Collectors.toCollection(LinkedHashSet::new));
+				.flatMap(type -> TypeUtils.resolveUsedAnnotations(type).stream())
+				.collect(Collectors.toCollection(LinkedHashSet::new));
 
 		annotations.addAll(TypeUtils.resolveUsedAnnotations(repositoryInformation.getRepositoryInterface()));
 

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2012-2018 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.aot;
+
+import java.util.List;
+import java.util.function.BiConsumer;
+
+import org.springframework.aot.generate.GenerationContext;
+import org.springframework.beans.factory.aot.BeanRegistrationAotContribution;
+import org.springframework.beans.factory.aot.BeanRegistrationCode;
+import org.springframework.core.ResolvableType;
+import org.springframework.data.ManagedTypes;
+import org.springframework.lang.NonNull;
+
+/**
+ * {@link BeanRegistrationAotContribution} used to contribute a {@link ManagedTypes} registration.
+ *
+ * @author John Blum
+ * @see org.springframework.beans.factory.aot.BeanRegistrationAotContribution
+ * @since 3.0.0
+ */
+public class ManagedTypesRegistrationAotContribution implements BeanRegistrationAotContribution {
+
+	private final AotContext aotContext;
+	private final ManagedTypes managedTypes;
+	private final BiConsumer<ResolvableType, GenerationContext> contributionAction;
+
+	public ManagedTypesRegistrationAotContribution(AotContext aotContext, ManagedTypes managedTypes,
+			@NonNull BiConsumer<ResolvableType, GenerationContext> contributionAction) {
+
+		this.aotContext = aotContext;
+		this.managedTypes = managedTypes;
+		this.contributionAction = contributionAction;
+	}
+
+	protected AotContext getAotContext() {
+		return this.aotContext;
+	}
+
+	@NonNull
+	protected ManagedTypes getManagedTypes() {
+		return ManagedTypes.nullSafeManagedTypes(this.managedTypes);
+	}
+
+	@Override
+	public void applyTo(@NonNull GenerationContext generationContext,
+			@NonNull BeanRegistrationCode beanRegistrationCode) {
+
+		List<Class<?>> types = getManagedTypes().toList();
+
+		if (!types.isEmpty()) {
+			TypeCollector.inspect(types).forEach(type -> contributionAction.accept(type, generationContext));
+		}
+	}
+}

src/main/java/org/springframework/data/aot/AotManagedTypesPostProcessor.java renamed to src/main/java/org/springframework/data/aot/ManagedTypesRegistrationAotProcessor.java

@@ -16,18 +16,17 @@
 package org.springframework.data.aot;
 
 import java.util.Collections;
-import java.util.List;
-import java.util.function.BiConsumer;
+import java.util.Set;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.springframework.aot.generate.GenerationContext;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.aot.BeanRegistrationAotContribution;
 import org.springframework.beans.factory.aot.BeanRegistrationAotProcessor;
-import org.springframework.beans.factory.aot.BeanRegistrationCode;
 import org.springframework.beans.factory.support.RegisteredBean;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.ResolvableType;
@@ -38,18 +37,18 @@
 import org.springframework.util.StringUtils;
 
 /**
- * {@link BeanRegistrationAotProcessor} handling {@link #getModulePrefix() prefixed} {@link ManagedTypes} instances.
- * This allows to register store specific handling of discovered types.
+ * {@link BeanRegistrationAotProcessor} handling {@link #getModulePrefix() module prefixed} {@link ManagedTypes}
+ * instances. This AOT processor allows store specific handling of discovered types to be registered.
  *
  * @author Christoph Strobl
  * @author John Blum
  * @see org.springframework.beans.factory.BeanFactoryAware
  * @see org.springframework.beans.factory.aot.BeanRegistrationAotProcessor
  * @since 3.0
  */
-public class AotManagedTypesPostProcessor implements BeanRegistrationAotProcessor, BeanFactoryAware {
+public class ManagedTypesRegistrationAotProcessor implements BeanRegistrationAotProcessor, BeanFactoryAware {
 
-	private static final Log logger = LogFactory.getLog(AotManagedTypesPostProcessor.class);
+	private final Log logger = LogFactory.getLog(getClass());
 
 	private BeanFactory beanFactory;
 
@@ -62,6 +61,7 @@ public BeanRegistrationAotContribution processAheadOfTime(@NonNull RegisteredBea
 	}
 
 	@Nullable
+	@SuppressWarnings("unused")
 	protected BeanRegistrationAotContribution contribute(@NonNull RootBeanDefinition beanDefinition,
 			@NonNull Class<?> beanType, @NonNull String beanName) {
 
@@ -88,11 +88,11 @@ protected boolean matchesPrefix(@Nullable String beanName) {
 	 *
 	 * @param aotContext never {@literal null}.
 	 * @param managedTypes never {@literal null}.
-	 * @return new instance of {@link AotManagedTypesPostProcessor} or {@literal null} if nothing to do.
+	 * @return new instance of {@link ManagedTypesRegistrationAotProcessor} or {@literal null} if nothing to do.
 	 */
 	@Nullable
 	protected BeanRegistrationAotContribution contribute(AotContext aotContext, ManagedTypes managedTypes) {
-		return new ManagedTypesContribution(aotContext, managedTypes, this::contributeType);
+		return new ManagedTypesRegistrationAotContribution(aotContext, managedTypes, this::contributeType);
 	}
 
 	/**
@@ -104,59 +104,28 @@ protected BeanRegistrationAotContribution contribute(AotContext aotContext, Mana
 	protected void contributeType(ResolvableType type, GenerationContext generationContext) {
 
 		if (logger.isDebugEnabled()) {
-			logger.debug(String.format("Contributing type information for [%s].", type.getType()));
+			logger.debug(String.format("Contributing type information for [%s]", type.getType()));
 		}
 
-		TypeContributor.contribute(type.toClass(), Collections.singleton(TypeContributor.DATA_NAMESPACE), generationContext);
-		TypeUtils.resolveUsedAnnotations(type.toClass()).forEach(annotation -> TypeContributor
-				.contribute(annotation.getType(), Collections.singleton(TypeContributor.DATA_NAMESPACE), generationContext));
-	}
+		Set<String> annotationNamespaces = Collections.singleton(TypeContributor.DATA_NAMESPACE);
 
-	@Nullable
-	public String getModulePrefix() {
-		return modulePrefix;
-	}
+		TypeContributor.contribute(type.toClass(), annotationNamespaces, generationContext);
 
-	public void setModulePrefix(@Nullable String modulePrefix) {
-		this.modulePrefix = modulePrefix;
+		TypeUtils.resolveUsedAnnotations(type.toClass()).forEach(annotation ->
+				TypeContributor.contribute(annotation.getType(), annotationNamespaces, generationContext));
 	}
 
 	@Override
 	public void setBeanFactory(@NonNull BeanFactory beanFactory) throws BeansException {
 		this.beanFactory = beanFactory;
 	}
 
-	static class ManagedTypesContribution implements BeanRegistrationAotContribution {
-
-		private final AotContext aotContext;
-		private final ManagedTypes managedTypes;
-		private final BiConsumer<ResolvableType, GenerationContext> contributionAction;
-
-		public ManagedTypesContribution(AotContext aotContext, ManagedTypes managedTypes,
-				BiConsumer<ResolvableType, GenerationContext> contributionAction) {
-
-			this.aotContext = aotContext;
-			this.managedTypes = managedTypes;
-			this.contributionAction = contributionAction;
-		}
-
-		public AotContext getAotContext() {
-			return aotContext;
-		}
-
-		public ManagedTypes getManagedTypes() {
-			return managedTypes;
-		}
-
-		@Override
-		public void applyTo(@NonNull GenerationContext generationContext,
-				@NonNull BeanRegistrationCode beanRegistrationCode) {
-
-			List<Class<?>> types = getManagedTypes().toList();
+	public void setModulePrefix(@Nullable String modulePrefix) {
+		this.modulePrefix = modulePrefix;
+	}
 
-			if (!types.isEmpty()) {
-				TypeCollector.inspect(types).forEach(type -> contributionAction.accept(type, generationContext));
-			}
-		}
+	@Nullable
+	public String getModulePrefix() {
+		return this.modulePrefix;
 	}
 }