Apply InstanceSupplier post-processing when bypassed by explicit args

When getBean(name, args) is called with explicit constructor arguments,
the InstanceSupplier is intentionally bypassed (gh-32657). However, in
AOT mode, @Autowired setter/field injection is baked into the
InstanceSupplier's andThen() chain and AutowiredAnnotationBeanPostProcessor
is excluded from runtime registration. This means the autowiring
post-processing is lost when the supplier is bypassed.

Add InstanceSupplier.postProcessInstance() to allow applying only the
post-processing steps (from andThen()) to an already-created instance
without re-invoking creation. Call this from doCreateBean() when the
instance supplier was bypassed due to explicit args.

Closes gh-35871

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: Vladimir Sitnikov <sitnikov.vladimir@gmail.com>

Author: vlsi

spring-beans/src/main/java/org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java

@@ -598,6 +598,20 @@ protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable
 
 		// Initialize the bean instance.
 		Object exposedObject = bean;
+
+		// If the instance supplier was bypassed (e.g. explicit args were provided),
+		// apply any post-processing that was registered via InstanceSupplier.andThen().
+		// Note: this runs after early singleton caching. For the typical case where
+		// post-processing returns the same instance, this is safe. If post-processing
+		// wraps the instance, circular reference detection at the end of this method
+		// will detect the mismatch and throw BeanCurrentlyInCreationException.
+		if (args != null && mbd.getInstanceSupplier() instanceof InstanceSupplier<?>) {
+			exposedObject = applyInstanceSupplierPostProcessing(exposedObject, beanName, mbd);
+			if (exposedObject != instanceWrapper.getWrappedInstance()) {
+				instanceWrapper = new BeanWrapperImpl(exposedObject);
+				initBeanWrapper(instanceWrapper);
+			}
+		}
 		try {
 			populateBean(beanName, mbd, instanceWrapper);
 			exposedObject = initializeBean(beanName, exposedObject, mbd);
@@ -1285,6 +1299,23 @@ private BeanWrapper obtainFromSupplier(Supplier<?> supplier, String beanName, Ro
 		return supplier.get();
 	}
 
+	/**
+	 * Apply any post-processing from the bean definition's
+	 * {@link InstanceSupplier} to an already-created instance. This is called
+	 * when the instance supplier was bypassed during creation (for example,
+	 * when explicit constructor arguments were provided) but the post-processing
+	 * registered via {@link InstanceSupplier#andThen} still needs to be applied.
+	 * @param bean the already-created bean instance
+	 * @param beanName the name of the bean
+	 * @param mbd the bean definition for the bean
+	 * @return the post-processed bean instance
+	 * @since 7.0
+	 * @see InstanceSupplier#postProcessInstance
+	 */
+	protected Object applyInstanceSupplierPostProcessing(Object bean, String beanName, RootBeanDefinition mbd) {
+		return bean;
+	}
+
 	/**
 	 * Overridden in order to implicitly register the currently created bean as
 	 * dependent on further beans getting programmatically retrieved during a

spring-beans/src/main/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java

@@ -1026,6 +1026,26 @@ protected boolean isBeanEligibleForMetadataCaching(String beanName) {
 		return super.obtainInstanceFromSupplier(supplier, beanName, mbd);
 	}
 
+	@Override
+	@SuppressWarnings("unchecked")
+	protected Object applyInstanceSupplierPostProcessing(Object bean, String beanName, RootBeanDefinition mbd) {
+		InstanceSupplier<?> instanceSupplier = (InstanceSupplier<?>) mbd.getInstanceSupplier();
+		if (instanceSupplier != null) {
+			try {
+				return ((InstanceSupplier<Object>) instanceSupplier)
+						.postProcessInstance(RegisteredBean.of(this, beanName, mbd), bean);
+			}
+			catch (RuntimeException ex) {
+				throw ex;
+			}
+			catch (Exception ex) {
+				throw new BeanCreationException(beanName,
+						"Post-processing of instance supplier failed", ex);
+			}
+		}
+		return bean;
+	}
+
 	@Override
 	protected void cacheMergedBeanDefinition(RootBeanDefinition mbd, String beanName) {
 		super.cacheMergedBeanDefinition(mbd, beanName);

spring-beans/src/main/java/org/springframework/beans/factory/support/InstanceSupplier.java

@@ -64,6 +64,25 @@ default T getWithException() {
 		return null;
 	}
 
+	/**
+	 * Apply only the post-processing steps of this supplier to an
+	 * already-created instance, without invoking the instance creation itself.
+	 * <p>This is used when the instance was created through a different path
+	 * (for example, when explicit constructor arguments bypass the instance
+	 * supplier) but post-processing registered via {@link #andThen} still
+	 * needs to be applied.
+	 * @param registeredBean the registered bean
+	 * @param instance the already-created instance to post-process
+	 * @return the post-processed instance
+	 * @throws Exception on error
+	 * @since 7.0
+	 * @see #andThen
+	 */
+	@SuppressWarnings("unchecked")
+	default T postProcessInstance(RegisteredBean registeredBean, T instance) throws Exception {
+		return instance;
+	}
+
 	/**
 	 * Return a composed instance supplier that first obtains the instance from
 	 * this supplier and then applies the {@code after} function to obtain the
@@ -83,6 +102,12 @@ public V get(RegisteredBean registeredBean) throws Exception {
 				return after.applyWithException(registeredBean, InstanceSupplier.this.get(registeredBean));
 			}
 			@Override
+			@SuppressWarnings("unchecked")
+			public V postProcessInstance(RegisteredBean registeredBean, V instance) throws Exception {
+				T postProcessed = InstanceSupplier.this.postProcessInstance(registeredBean, (T) instance);
+				return after.applyWithException(registeredBean, postProcessed);
+			}
+			@Override
 			public @Nullable Method getFactoryMethod() {
 				return InstanceSupplier.this.getFactoryMethod();
 			}

spring-context/src/test/java/org/springframework/context/aot/PrototypeWithArgsAotTests.java

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2002-present 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
+ *
+ *      https://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.context.aot;
+
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aot.test.generate.TestGenerationContext;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.annotation.AnnotationConfigUtils;
+import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.core.test.tools.Compiled;
+import org.springframework.core.test.tools.TestCompiler;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for <a href="https://github.com/spring-projects/spring-framework/issues/35871">gh-35871</a>.
+ *
+ * <p>Verifies that {@code getBean(name, args)} produces beans with the same
+ * observable state in both regular and AOT modes. In AOT mode, an
+ * {@code InstanceSupplier} with {@code andThen()} post-processing is generated
+ * for {@code @Autowired} setter injection. When explicit constructor args
+ * bypass the instance supplier, the post-processing must still be applied.
+ */
+class PrototypeWithArgsAotTests {
+
+	@Test
+	void prototypeWithAutowiredSetterAndExplicitArgs() {
+		assertAotAndRegularModesProduceSameResult((ctx, args) -> {
+			PrototypeService instance = (PrototypeService) ctx.getBean("prototypeService", args);
+			return new BeanSnapshot(instance.getName(), instance.getSingletonService() != null);
+		}, "testName");
+	}
+
+	/**
+	 * Sets up a context with a prototype bean that has an {@code @Autowired}
+	 * setter, then asserts that the given extractor produces the same result
+	 * in regular mode and in AOT-compiled mode.
+	 */
+	private static void assertAotAndRegularModesProduceSameResult(
+			BiFunction<GenericApplicationContext, Object[], BeanSnapshot> extractor, Object... args) {
+
+		// Regular mode
+		GenericApplicationContext regularContext = createApplicationContext();
+		regularContext.refresh();
+		BeanSnapshot regularResult = extractor.apply(regularContext, args);
+		regularContext.close();
+
+		// AOT mode
+		GenericApplicationContext aotSource = createApplicationContext();
+		testCompiledResult(aotSource, (initializer, compiled) -> {
+			GenericApplicationContext aotContext = toFreshApplicationContext(initializer);
+			BeanSnapshot aotResult = extractor.apply(aotContext, args);
+			assertThat(aotResult)
+					.as("AOT mode should produce the same result as regular mode")
+					.isEqualTo(regularResult);
+			aotContext.close();
+		});
+	}
+
+	private static GenericApplicationContext createApplicationContext() {
+		GenericApplicationContext context = new GenericApplicationContext();
+		context.registerBeanDefinition(
+				AnnotationConfigUtils.AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME,
+				new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class));
+		context.registerBeanDefinition("singletonService",
+				new RootBeanDefinition(SingletonService.class));
+		RootBeanDefinition prototypeDef = new RootBeanDefinition(PrototypeService.class);
+		prototypeDef.setScope(BeanDefinition.SCOPE_PROTOTYPE);
+		context.registerBeanDefinition("prototypeService", prototypeDef);
+		return context;
+	}
+
+	private static TestGenerationContext processAheadOfTime(GenericApplicationContext applicationContext) {
+		ApplicationContextAotGenerator generator = new ApplicationContextAotGenerator();
+		TestGenerationContext generationContext = new TestGenerationContext();
+		generator.processAheadOfTime(applicationContext, generationContext);
+		generationContext.writeGeneratedContent();
+		return generationContext;
+	}
+
+	private static void testCompiledResult(GenericApplicationContext applicationContext,
+			BiConsumer<ApplicationContextInitializer<GenericApplicationContext>, Compiled> result) {
+		testCompiledResult(processAheadOfTime(applicationContext), result);
+	}
+
+	@SuppressWarnings("unchecked")
+	private static void testCompiledResult(TestGenerationContext generationContext,
+			BiConsumer<ApplicationContextInitializer<GenericApplicationContext>, Compiled> result) {
+		TestCompiler.forSystem().with(generationContext).compile(compiled ->
+				result.accept(compiled.getInstance(ApplicationContextInitializer.class), compiled));
+	}
+
+	private static GenericApplicationContext toFreshApplicationContext(
+			ApplicationContextInitializer<GenericApplicationContext> initializer) {
+		GenericApplicationContext freshApplicationContext = new GenericApplicationContext();
+		initializer.initialize(freshApplicationContext);
+		freshApplicationContext.refresh();
+		return freshApplicationContext;
+	}
+
+
+	record BeanSnapshot(String name, boolean hasInjectedDependency) {
+	}
+
+	public static class SingletonService {
+	}
+
+	public static class PrototypeService {
+
+		private final String name;
+
+		private SingletonService singletonService;
+
+		public PrototypeService(String name) {
+			this.name = name;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public SingletonService getSingletonService() {
+			return singletonService;
+		}
+
+		@Autowired
+		public void setSingletonService(SingletonService singletonService) {
+			this.singletonService = singletonService;
+		}
+	}
+}