Add tests and fix comment for InstanceSupplier post-processing with explicit args

Clarify that applyInstanceSupplierPostProcessing() can also run for
singleton beans created via getBean(name, args), not only prototypes.
The previous comment incorrectly stated this code path only applies to
non-singleton beans. In practice, getBean(name, args) can create a
singleton on first lookup since doGetBean only reuses the singleton
cache when args == null.

The ordering (post-processing after addSingletonFactory) is consistent
with how Spring handles any BeanPostProcessor that changes bean identity:
circular reference detection at the end of doCreateBean will detect the
mismatch and throw BeanCurrentlyInCreationException. For the typical
case where post-processing returns the same instance (e.g. setter
injection), this is safe.

Add two tests verifying InstanceSupplier.andThen() post-processing is
applied when the instance supplier is bypassed due to explicit args,
for both singleton and prototype scopes.

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

@@ -601,8 +601,10 @@ protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable
 
 		// If the instance supplier was bypassed (e.g. explicit args were provided),
 		// apply any post-processing that was registered via InstanceSupplier.andThen().
-		// This is done after singleton caching since it only applies to non-singleton
-		// beans (singletons don't use explicit args with getBean).
+		// 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()) {

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

@@ -17,12 +17,11 @@
 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.BeanFactory;
-import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -36,48 +35,61 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Reproduction test for <a href="https://github.com/spring-projects/spring-framework/issues/35871">gh-35871</a>.
- * Prototype bean with {@code @Autowired} setter injection fails when retrieved
- * with explicit constructor args via {@code getBean(name, args)} in AOT mode.
+ * 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 prototypeWithArgsAndAutowiredSetterInAotMode() {
-		GenericApplicationContext applicationContext = new GenericApplicationContext();
-		registerBeanPostProcessor(applicationContext);
-
-		// Register a singleton bean
-		applicationContext.registerBeanDefinition("singletonService",
-				new RootBeanDefinition(SingletonService.class));
-
-		// Register a prototype bean with constructor arg + @Autowired setter
-		RootBeanDefinition prototypeDef = new RootBeanDefinition(PrototypeService.class);
-		prototypeDef.setScope(BeanDefinition.SCOPE_PROTOTYPE);
-		applicationContext.registerBeanDefinition("prototypeService", prototypeDef);
-
-		testCompiledResult(applicationContext, (initializer, compiled) -> {
-			GenericApplicationContext freshContext = toFreshApplicationContext(initializer);
-
-			// This is the key: getBean with explicit constructor args bypasses instance supplier
-			PrototypeService instance = (PrototypeService) freshContext.getBean("prototypeService", "testName");
-
-			assertThat(instance.getName()).isEqualTo("testName");
-			assertThat(instance.getBeanFactory())
-					.as("BeanFactoryAware should still work")
-					.isNotNull();
-			assertThat(instance.getSingletonService())
-					.as("@Autowired setter should be called even when instance supplier is bypassed")
-					.isNotNull();
+	void prototypeWithAutowiredSetterAndExplicitArgs() {
+		assertAotAndRegularModesProduceSameResult((ctx, args) -> {
+			PrototypeService instance = (PrototypeService) ctx.getBean("prototypeService", args);
+			return new BeanSnapshot(instance.getName(), instance.getSingletonService() != null);
+		}, "testName");
+	}
 
-			freshContext.close();
+	/**
+	 * 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 void registerBeanPostProcessor(GenericApplicationContext applicationContext) {
-		applicationContext.registerBeanDefinition(
+	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) {
@@ -109,16 +121,17 @@ private static GenericApplicationContext toFreshApplicationContext(
 	}
 
 
+	record BeanSnapshot(String name, boolean hasInjectedDependency) {
+	}
+
 	public static class SingletonService {
-		public String getValue() {
-			return "singleton";
-		}
 	}
 
-	public static class PrototypeService implements BeanFactoryAware {
+	public static class PrototypeService {
+
 		private final String name;
+
 		private SingletonService singletonService;
-		private BeanFactory beanFactory;
 
 		public PrototypeService(String name) {
 			this.name = name;
@@ -136,14 +149,5 @@ public SingletonService getSingletonService() {
 		public void setSingletonService(SingletonService singletonService) {
 			this.singletonService = singletonService;
 		}
-
-		@Override
-		public void setBeanFactory(BeanFactory beanFactory) {
-			this.beanFactory = beanFactory;
-		}
-
-		public BeanFactory getBeanFactory() {
-			return beanFactory;
-		}
 	}
 }