Merge 585bbfdb44 into 7e6874ad80

Closes gh-35580

framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired.adoc

@@ -37,18 +37,18 @@ Kotlin::
 ----
 ======
 
-[NOTE]
+[TIP]
 ====
-As of Spring Framework 4.3, an `@Autowired` annotation on such a constructor is no longer
+An `@Autowired` annotation on such a constructor is not necessary if the target bean
-necessary if the target bean defines only one constructor to begin with. However, if
+defines only one constructor. However, if several constructors are available and there is
-several constructors are available and there is no primary/default constructor, at least
+no primary or default constructor, at least one of the constructors must be annotated
-one of the constructors must be annotated with `@Autowired` in order to instruct the
+with `@Autowired` in order to instruct the container which one to use. See the discussion
-container which one to use. See the discussion on
+on xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution]
-xref:core/beans/annotation-config/autowired.adoc#beans-autowired-annotation-constructor-resolution[constructor resolution] for details.
+for details.
 ====
 
-You can also apply the `@Autowired` annotation to _traditional_ setter methods,
+You can apply the `@Autowired` annotation to _traditional_ setter methods, as the
-as the following example shows:
+following example shows:
 
 [tabs]
 ======
@@ -84,8 +84,8 @@ Kotlin::
 ----
 ======
 
-You can also apply the annotation to methods with arbitrary names and multiple
+You can apply `@Autowired` to methods with arbitrary names and multiple arguments, as the
-arguments, as the following example shows:
+following example shows:
 
 [tabs]
 ======
@@ -176,14 +176,15 @@ Kotlin::
 ====
 Make sure that your target components (for example, `MovieCatalog` or `CustomerPreferenceDao`)
 are consistently declared by the type that you use for your `@Autowired`-annotated
-injection points. Otherwise, injection may fail due to a "no type match found" error at runtime.
+injection points. Otherwise, injection may fail due to a "no type match found" error at
+runtime.
 
 For XML-defined beans or component classes found via classpath scanning, the container
 usually knows the concrete type up front. However, for `@Bean` factory methods, you need
 to make sure that the declared return type is sufficiently expressive. For components
 that implement several interfaces or for components potentially referred to by their
-implementation type, consider declaring the most specific return type on your factory
+implementation type, declare the most specific return type on your factory method (at
-method (at least as specific as required by the injection points referring to your bean).
+least as specific as required by the injection points referring to your bean).
 ====
 
 .[[beans-autowired-annotation-self-injection]]Self Injection
@@ -312,8 +313,8 @@ through `@Order` values in combination with `@Primary` on a single bean for each
 ====
 
 Even typed `Map` instances can be autowired as long as the expected key type is `String`.
-The map values contain all beans of the expected type, and the keys contain the
+The map values are all beans of the expected type, and the keys are the corresponding
-corresponding bean names, as the following example shows:
+bean names, as the following example shows:
 
 [tabs]
 ======
@@ -431,7 +432,7 @@ annotated constructor does not have to be public.
 ====
 
 Alternatively, you can express the non-required nature of a particular dependency
-through Java 8's `java.util.Optional`, as the following example shows:
+through Java's `java.util.Optional`, as the following example shows:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -445,8 +446,8 @@ through Java 8's `java.util.Optional`, as the following example shows:
 ----
 
 You can also use a parameter-level `@Nullable` annotation (of any kind in any package --
-for example, `javax.annotation.Nullable` from JSR-305) or just leverage Kotlin built-in
+for example, `org.jspecify.annotations.Nullable` from JSpecify) or just leverage Kotlin's
-null-safety support:
+built-in null-safety support:
 
 [tabs]
 ======
@@ -477,13 +478,6 @@ Kotlin::
 ----
 ======
 
-[NOTE]
-====
-A type-level `@Nullable` annotation such as from JSpecify is not supported in Spring
-Framework 6.2 yet. You need to upgrade to Spring Framework 7.0 where the framework
-detects type-level annotations and consistently declares JSpecify in its own codebase.
-====
-
 You can also use `@Autowired` for interfaces that are well-known resolvable
 dependencies: `BeanFactory`, `ApplicationContext`, `Environment`, `ResourceLoader`,
 `ApplicationEventPublisher`, and `MessageSource`. These interfaces and their extended
@@ -528,5 +522,6 @@ class MovieRecommender {
 The `@Autowired`, `@Inject`, `@Value`, and `@Resource` annotations are handled by Spring
 `BeanPostProcessor` implementations. This means that you cannot apply these annotations
 within your own `BeanPostProcessor` or `BeanFactoryPostProcessor` types (if any).
+
 These types must be 'wired up' explicitly by using XML or a Spring `@Bean` method.
 ====

spring-beans/src/main/java/org/springframework/beans/factory/config/YamlProcessor.java

@@ -56,6 +56,7 @@ import org.springframework.util.StringUtils;
  * @author Juergen Hoeller
  * @author Sam Brannen
  * @author Brian Clozel
+ * @author Mengqi Xu
  * @since 4.1
  */
 public abstract class YamlProcessor {
@@ -244,13 +245,7 @@ public abstract class YamlProcessor {
 			if (value instanceof Map) {
 				value = asMap(value);
 			}
-			if (key instanceof CharSequence) {
+			result.put(key.toString(), value);
-				result.put(key.toString(), value);
-			}
-			else {
-				// It has to be a map key in this case
-				result.put("[" + key.toString() + "]", value);
-			}
 		});
 		return result;
 	}
@@ -305,17 +300,20 @@ public abstract class YamlProcessor {
 	 */
 	protected final Map<String, Object> getFlattenedMap(Map<String, Object> source) {
 		Map<String, Object> result = new LinkedHashMap<>();
-		buildFlattenedMap(result, source, null);
+		buildFlattenedMap(result, source, null, false);
 		return result;
 	}
 
 	@SuppressWarnings({"rawtypes", "unchecked"})
-	private void buildFlattenedMap(Map<String, Object> result, Map<String, Object> source, @Nullable String path) {
+	private void buildFlattenedMap(Map<String, Object> result, Map<String, Object> source, @Nullable String path, boolean isIndexedKey) {
 		source.forEach((key, value) -> {
 			if (StringUtils.hasText(path)) {
-				if (key.startsWith("[")) {
+				if (isIndexedKey) {
 					key = path + key;
 				}
+				else if (key.startsWith("[") || key.endsWith("]")) {
+					key = path + '[' + key + ']';
+				}
 				else {
 					key = path + '.' + key;
 				}
@@ -325,7 +323,7 @@ public abstract class YamlProcessor {
 			}
 			else if (value instanceof Map map) {
 				// Need a compound key
-				buildFlattenedMap(result, map, key);
+				buildFlattenedMap(result, map, key, false);
 			}
 			else if (value instanceof Collection collection) {
 				// Need a compound key
@@ -336,7 +334,7 @@ public abstract class YamlProcessor {
 					int count = 0;
 					for (Object object : collection) {
 						buildFlattenedMap(result, Collections.singletonMap(
-								"[" + (count++) + "]", object), key);
+								"[" + (count++) + "]", object), key, true);
 					}
 				}
 			}

spring-beans/src/test/java/org/springframework/beans/factory/config/YamlMapFactoryBeanTests.java

@@ -128,4 +128,18 @@ class YamlMapFactoryBeanTests {
 				this.factory.getObject().get("mymap"));
 	}
 
+	@Test
+	void testMapWithIntegerKey() {
+		this.factory.setResources(new ByteArrayResource("foo:\n  1: bar".getBytes()));
+		Map<String, Object> map = this.factory.getObject();
+
+		assertThat(map).hasSize(1);
+		assertThat(map.containsKey("foo")).isTrue();
+		Object object = map.get("foo");
+		assertThat(object).isInstanceOf(LinkedHashMap.class);
+		@SuppressWarnings("unchecked")
+		Map<String, Object> sub = (Map<String, Object>) object;
+		assertThat(sub.containsKey("1")).isTrue();
+		assertThat(sub.get("1")).isEqualTo("bar");
+	}
 }

spring-beans/src/test/java/org/springframework/beans/factory/config/YamlProcessorTests.java

@@ -99,7 +99,7 @@ class YamlProcessorTests {
 	void integerKeyBehaves() {
 		setYaml("foo: bar\n1: bar");
 		this.processor.process((properties, map) -> {
-			assertThat(properties.get("[1]")).isEqualTo("bar");
+			assertThat(properties.get("1")).isEqualTo("bar");
 			assertThat(properties).hasSize(2);
 		});
 	}
@@ -108,7 +108,7 @@ class YamlProcessorTests {
 	void integerDeepKeyBehaves() {
 		setYaml("foo:\n  1: bar");
 		this.processor.process((properties, map) -> {
-			assertThat(properties.get("foo[1]")).isEqualTo("bar");
+			assertThat(properties.get("foo.1")).isEqualTo("bar");
 			assertThat(properties).hasSize(1);
 		});
 	}

spring-beans/src/test/java/org/springframework/beans/factory/config/YamlPropertiesFactoryBeanTests.java

@@ -165,6 +165,42 @@ class YamlPropertiesFactoryBeanTests {
 		assertThat(properties.getProperty("one")).isEqualTo("two");
 	}
 
+
+	@Test // gh-27020
+	void loadResourceWithEscapedKey() {
+		String yaml = "root:\n" +
+				"  webservices:\n" +
+				"    \"[domain.test:8080]\":\n" +
+				"      - username: foo\n" +
+				"        password: bar\n";
+		YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
+		factory.setResources(
+				new ByteArrayResource(yaml.getBytes()),
+				new ByteArrayResource("indexed:\n  \"[0]\": foo\n  \"[1]\": bar".getBytes()),
+				new ByteArrayResource("indexed2:\n  - \"[a]\": foo\n    \"[b]\": bar".getBytes()),
+				new ByteArrayResource("only-left-bracket:\n  \"[/key1/\": foo".getBytes()),
+				new ByteArrayResource("only-right-bracket:\n  \"/key1/]\": foo".getBytes()),
+				new ByteArrayResource("special-bracket:\n  \"][/key1/][\": foo".getBytes()),
+				new ByteArrayResource("number-key:\n  1: foo".getBytes()));
+
+		Properties properties = factory.getObject();
+		assertThat(properties.getProperty("root.webservices[[domain.test:8080]][0].username")).isEqualTo("foo");
+		assertThat(properties.getProperty("root.webservices[[domain.test:8080]][0].password")).isEqualTo("bar");
+
+		assertThat(properties.getProperty("indexed[[0]]")).isEqualTo("foo");
+		assertThat(properties.getProperty("indexed[[1]]")).isEqualTo("bar");
+
+		assertThat(properties.getProperty("indexed2[0][[a]]")).isEqualTo("foo");
+		assertThat(properties.getProperty("indexed2[0][[b]]")).isEqualTo("bar");
+
+		assertThat(properties.getProperty("only-left-bracket[[/key1/]")).isEqualTo("foo");
+		assertThat(properties.getProperty("only-right-bracket[/key1/]]")).isEqualTo("foo");
+		assertThat(properties.getProperty("special-bracket.][/key1/][")).isEqualTo("foo");
+
+		assertThat(properties.getProperty("number-key.1")).isEqualTo("foo");
+	}
+
+
 	@Test
 	void loadNonExistentResource() {
 		YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();