Adapt to AOT API changes in the core Spring Framework.

This minimally gets the Spring Data codebase with AOT processing support compiling again.

Author: jxblum

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

@@ -19,40 +19,50 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
+import org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution;
+import org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.config.ConstructorArgumentValues.ValueHolder;
-import org.springframework.beans.factory.generator.AotContributingBeanFactoryPostProcessor;
-import org.springframework.beans.factory.generator.BeanFactoryContribution;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.data.ManagedTypes;
+import org.springframework.lang.NonNull;
 import org.springframework.lang.Nullable;
 
 /**
- * {@link AotContributingBeanFactoryPostProcessor} implementation to capture common data infrastructure concerns.
+ * {@link BeanFactoryInitializationAotProcessor} implementation used to encapsulate common data infrastructure concerns.
  *
  * @author Christoph Strobl
+ * @author John Blum
+ * @see org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution
+ * @see org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor
  * @since 3.0
  */
-public class AotDataComponentsBeanFactoryPostProcessor implements AotContributingBeanFactoryPostProcessor {
+public class AotDataComponentsBeanFactoryInitializationAotProcessor implements BeanFactoryInitializationAotProcessor {
 
-	private static final Log logger = LogFactory.getLog(AotContributingBeanFactoryPostProcessor.class);
+	private static final Log logger = LogFactory.getLog(BeanFactoryInitializationAotProcessor.class);
 
 	@Nullable
 	@Override
-	public BeanFactoryContribution contribute(ConfigurableListableBeanFactory beanFactory) {
-		postProcessManagedTypes(beanFactory);
+	public BeanFactoryInitializationAotContribution processAheadOfTime(
+			@NonNull ConfigurableListableBeanFactory beanFactory) {
+
+		processManagedTypes(beanFactory);
 		return null;
 	}
 
-	private void postProcessManagedTypes(ConfigurableListableBeanFactory beanFactory) {
+	private void processManagedTypes(@NonNull ConfigurableListableBeanFactory beanFactory) {
 
 		if (beanFactory instanceof BeanDefinitionRegistry registry) {
 			for (String beanName : beanFactory.getBeanNamesForType(ManagedTypes.class)) {
 
 				BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
-				ValueHolder argumentValue = beanDefinition.getConstructorArgumentValues().getArgumentValue(0, null, null, null);
+
+				ValueHolder argumentValue = beanDefinition.getConstructorArgumentValues()
+						.getArgumentValue(0, null, null, null);
+
 				if (argumentValue.getValue() instanceof Supplier supplier) {
 
 					if (logger.isDebugEnabled()) {

src/main/java/org/springframework/data/aot/AotDataComponentsBeanFactoryPostProcessor.java renamed to src/main/java/org/springframework/data/aot/AotDataComponentsBeanFactoryInitializationAotProcessor.java

@@ -21,13 +21,14 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
-
-import org.springframework.aot.generator.CodeContribution;
+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.generator.AotContributingBeanPostProcessor;
-import org.springframework.beans.factory.generator.BeanInstantiationContribution;
+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;
 import org.springframework.data.ManagedTypes;
@@ -37,15 +38,16 @@
 import org.springframework.util.StringUtils;
 
 /**
- * {@link AotContributingBeanPostProcessor} handling {@link #getModulePrefix() prefixed} {@link ManagedTypes} instances.
+ * {@link BeanRegistrationAotProcessor} handling {@link #getModulePrefix() prefixed} {@link ManagedTypes} instances.
  * This allows to register store specific handling of discovered types.
  *
  * @author Christoph Strobl
+ * @author John Blum
  * @see org.springframework.beans.factory.BeanFactoryAware
- * @see org.springframework.beans.factory.generator.AotContributingBeanPostProcessor
+ * @see org.springframework.beans.factory.aot.BeanRegistrationAotProcessor
  * @since 3.0
  */
-public class AotManagedTypesPostProcessor implements AotContributingBeanPostProcessor, BeanFactoryAware {
+public class AotManagedTypesPostProcessor implements BeanRegistrationAotProcessor, BeanFactoryAware {
 
 	private static final Log logger = LogFactory.getLog(AotManagedTypesPostProcessor.class);
 
@@ -54,9 +56,13 @@ public class AotManagedTypesPostProcessor implements AotContributingBeanPostProc
 	@Nullable
 	private String modulePrefix;
 
-	@Nullable
 	@Override
-	public BeanInstantiationContribution contribute(@NonNull RootBeanDefinition beanDefinition,
+	public BeanRegistrationAotContribution processAheadOfTime(@NonNull RegisteredBean registeredBean) {
+		return contribute(registeredBean.getMergedBeanDefinition(), registeredBean.getBeanClass(), registeredBean.getBeanName());
+	}
+
+	@Nullable
+	protected BeanRegistrationAotContribution contribute(@NonNull RootBeanDefinition beanDefinition,
 			@NonNull Class<?> beanType, @NonNull String beanName) {
 
 		return isMatch(beanType, beanName)
@@ -77,33 +83,33 @@ protected boolean matchesPrefix(@Nullable String beanName) {
 	}
 
 	/**
-	 * Hook to provide a customized flavor of {@link BeanInstantiationContribution}. By overriding this method calls to
-	 * {@link #contributeType(ResolvableType, CodeContribution)} might no longer be issued.
+	 * Hook to provide a customized flavor of {@link BeanRegistrationAotContribution}. By overriding this method
+	 * calls to {@link #contributeType(ResolvableType, GenerationContext)} might no longer be issued.
 	 *
 	 * @param aotContext never {@literal null}.
 	 * @param managedTypes never {@literal null}.
 	 * @return new instance of {@link AotManagedTypesPostProcessor} or {@literal null} if nothing to do.
 	 */
 	@Nullable
-	protected BeanInstantiationContribution contribute(AotContext aotContext, ManagedTypes managedTypes) {
+	protected BeanRegistrationAotContribution contribute(AotContext aotContext, ManagedTypes managedTypes) {
 		return new ManagedTypesContribution(aotContext, managedTypes, this::contributeType);
 	}
 
 	/**
 	 * Hook to contribute configuration for a given {@literal type}.
 	 *
 	 * @param type never {@literal null}.
-	 * @param contribution never {@literal null}.
+	 * @param generationContext never {@literal null}.
 	 */
-	protected void contributeType(ResolvableType type, CodeContribution contribution) {
+	protected void contributeType(ResolvableType type, GenerationContext generationContext) {
 
 		if (logger.isDebugEnabled()) {
 			logger.debug(String.format("Contributing type information for [%s].", type.getType()));
 		}
 
-		TypeContributor.contribute(type.toClass(), Collections.singleton(TypeContributor.DATA_NAMESPACE), contribution);
+		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), contribution));
+				.contribute(annotation.getType(), Collections.singleton(TypeContributor.DATA_NAMESPACE), generationContext));
 	}
 
 	@Nullable
@@ -115,24 +121,19 @@ public void setModulePrefix(@Nullable String modulePrefix) {
 		this.modulePrefix = modulePrefix;
 	}
 
-	@Override
-	public int getOrder() {
-		return 0;
-	}
-
 	@Override
 	public void setBeanFactory(@NonNull BeanFactory beanFactory) throws BeansException {
 		this.beanFactory = beanFactory;
 	}
 
-	static class ManagedTypesContribution implements BeanInstantiationContribution {
+	static class ManagedTypesContribution implements BeanRegistrationAotContribution {
 
 		private final AotContext aotContext;
 		private final ManagedTypes managedTypes;
-		private final BiConsumer<ResolvableType, CodeContribution> contributionAction;
+		private final BiConsumer<ResolvableType, GenerationContext> contributionAction;
 
 		public ManagedTypesContribution(AotContext aotContext, ManagedTypes managedTypes,
-				BiConsumer<ResolvableType, CodeContribution> contributionAction) {
+				BiConsumer<ResolvableType, GenerationContext> contributionAction) {
 
 			this.aotContext = aotContext;
 			this.managedTypes = managedTypes;
@@ -148,12 +149,13 @@ public ManagedTypes getManagedTypes() {
 		}
 
 		@Override
-		public void applyTo(@NonNull CodeContribution contribution) {
+		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, contribution));
+				TypeCollector.inspect(types).forEach(type -> contributionAction.accept(type, generationContext));
 			}
 		}
 	}