Merge branch '6.1.x'

Author: snicoll

spring-beans/src/main/java/org/springframework/beans/factory/aot/BeanInstanceSupplier.java

@@ -213,12 +213,13 @@ private T invokeBeanSupplier(Executable executable, ThrowingSupplier<T> beanSupp
 		if (!(executable instanceof Method method)) {
 			return beanSupplier.get();
 		}
+		Method priorInvokedFactoryMethod = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
 		try {
 			SimpleInstantiationStrategy.setCurrentlyInvokedFactoryMethod(method);
 			return beanSupplier.get();
 		}
 		finally {
-			SimpleInstantiationStrategy.setCurrentlyInvokedFactoryMethod(null);
+			SimpleInstantiationStrategy.setCurrentlyInvokedFactoryMethod(priorInvokedFactoryMethod);
 		}
 	}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2024 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.
@@ -55,12 +55,18 @@ public static Method getCurrentlyInvokedFactoryMethod() {
 	}
 
 	/**
-	 * Set the factory method currently being invoked or {@code null} to reset.
+	 * Set the factory method currently being invoked or {@code null} to remove
+	 * the  current value, if any.
 	 * @param method the factory method currently being invoked or {@code null}
 	 * @since 6.0
 	 */
 	public static void setCurrentlyInvokedFactoryMethod(@Nullable Method method) {
-		currentlyInvokedFactoryMethod.set(method);
+		if (method != null) {
+			currentlyInvokedFactoryMethod.set(method);
+		}
+		else {
+			currentlyInvokedFactoryMethod.remove();
+		}
 	}
 
 
@@ -134,22 +140,17 @@ public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, Bean
 		try {
 			ReflectionUtils.makeAccessible(factoryMethod);
 
-			Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
+			Method priorInvokedFactoryMethod = getCurrentlyInvokedFactoryMethod();
 			try {
-				currentlyInvokedFactoryMethod.set(factoryMethod);
+				setCurrentlyInvokedFactoryMethod(factoryMethod);
 				Object result = factoryMethod.invoke(factoryBean, args);
 				if (result == null) {
 					result = new NullBean();
 				}
 				return result;
 			}
 			finally {
-				if (priorInvokedFactoryMethod != null) {
-					currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
-				}
-				else {
-					currentlyInvokedFactoryMethod.remove();
-				}
+				setCurrentlyInvokedFactoryMethod(priorInvokedFactoryMethod);
 			}
 		}
 		catch (IllegalArgumentException ex) {

spring-beans/src/test/java/org/springframework/beans/factory/aot/BeanInstanceSupplierTests.java

@@ -25,6 +25,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
@@ -51,6 +52,7 @@
 import org.springframework.beans.factory.support.InstanceSupplier;
 import org.springframework.beans.factory.support.RegisteredBean;
 import org.springframework.beans.factory.support.RootBeanDefinition;
+import org.springframework.beans.factory.support.SimpleInstantiationStrategy;
 import org.springframework.core.env.Environment;
 import org.springframework.core.io.DefaultResourceLoader;
 import org.springframework.core.io.ResourceLoader;
@@ -293,6 +295,33 @@ void getNestedWithNoGeneratorUsesReflection(Source source) throws Exception {
 		assertThat(instance).isEqualTo("1");
 	}
 
+	@Test // gh-33180
+	void getWithNestedInvocationRetainsFactoryMethod() throws Exception {
+		AtomicReference<Method> testMethodReference = new AtomicReference<>();
+		AtomicReference<Method> anotherMethodReference = new AtomicReference<>();
+
+		BeanInstanceSupplier<Object> nestedInstanceSupplier = BeanInstanceSupplier
+				.forFactoryMethod(AnotherTestStringFactory.class, "another")
+				.withGenerator(registeredBean -> {
+					anotherMethodReference.set(SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod());
+					return "Another";
+				});
+		RegisteredBean nestedRegisteredBean = new Source(String.class, nestedInstanceSupplier).registerBean(this.beanFactory);
+		BeanInstanceSupplier<Object> instanceSupplier = BeanInstanceSupplier
+				.forFactoryMethod(TestStringFactory.class, "test")
+				.withGenerator(registeredBean -> {
+					Object nested = nestedInstanceSupplier.get(nestedRegisteredBean);
+					testMethodReference.set(SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod());
+					return "custom" + nested;
+				});
+		RegisteredBean registeredBean = new Source(String.class, instanceSupplier).registerBean(this.beanFactory);
+		Object value = instanceSupplier.get(registeredBean);
+
+		assertThat(value).isEqualTo("customAnother");
+		assertThat(testMethodReference.get()).isEqualTo(instanceSupplier.getFactoryMethod());
+		assertThat(anotherMethodReference.get()).isEqualTo(nestedInstanceSupplier.getFactoryMethod());
+	}
+
 	@Test
 	void resolveArgumentsWithNoArgConstructor() {
 		RootBeanDefinition beanDefinition = new RootBeanDefinition(
@@ -1031,4 +1060,18 @@ static class MethodOnInterfaceImpl implements MethodOnInterface {
 
 	}
 
+	static class TestStringFactory {
+
+		String test() {
+			return "test";
+		}
+	}
+
+	static class AnotherTestStringFactory {
+
+		String another() {
+			return "another";
+		}
+	}
+
 }