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();
 			}