Release v6.2.2

.github/actions/prepare-gradle-build/action.yml

@@ -31,7 +31,7 @@ runs:
           ${{ inputs.java-early-access == 'true' && format('{0}-ea', inputs.java-version) || inputs.java-version }}
           ${{ inputs.java-toolchain == 'true' && '17' || '' }}
     - name: Set Up Gradle
-      uses: gradle/actions/setup-gradle@0bdd871935719febd78681f197cd39af5b6e16a6 # v4.2.2
+      uses: gradle/actions/setup-gradle@cc4fc85e6b35bafd578d5ffbc76a5518407e1af0 # v4.2.1
       with:
         cache-read-only: false
         develocity-access-key: ${{ inputs.develocity-access-key }}

.github/actions/sync-to-maven-central/action.yml

@@ -20,7 +20,7 @@ runs:
   using: composite
   steps:
     - name: Set Up JFrog CLI
-      uses: jfrog/setup-jfrog-cli@f748a0599171a192a2668afee8d0497f7c1069df # v4.5.6
+      uses: jfrog/setup-jfrog-cli@dff217c085c17666e8849ebdbf29c8fe5e3995e6 # v4.5.2
       env:
         JF_ENV_SPRING: ${{ inputs.jfrog-cli-config-token }}
     - name: Download Release Artifacts

.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
           develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
           publish: true
       - name: Stage Release
-        uses: spring-io/artifactory-deploy-action@dc1913008c0599f0c4b1fdafb6ff3c502b3565ea # v0.0.2
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
         with:
           artifact-properties: |
             /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false

.github/workflows/verify.yml

@@ -46,7 +46,7 @@ jobs:
           distribution: 'liberica'
           java-version: 17
       - name: Set Up Gradle
-        uses: gradle/actions/setup-gradle@0bdd871935719febd78681f197cd39af5b6e16a6 # v4.2.2
+        uses: gradle/actions/setup-gradle@cc4fc85e6b35bafd578d5ffbc76a5518407e1af0 # v4.2.1
         with:
           cache-read-only: false
       - name: Configure Gradle Properties

build.gradle

@@ -91,7 +91,7 @@ configure([rootProject] + javaProjects) { project ->
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
 			"https://jakarta.ee/specifications/platform/9/apidocs/",
 			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
-			"https://eclipse.dev/aspectj/doc/latest/runtime-api/",
+			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
 			"https://fasterxml.github.io/jackson-core/javadoc/2.14/",
 			"https://fasterxml.github.io/jackson-databind/javadoc/2.14/",

buildSrc/src/main/java/org/springframework/build/CheckstyleConventions.java

@@ -50,7 +50,7 @@ public class CheckstyleConventions {
 			project.getPlugins().apply(CheckstylePlugin.class);
 			project.getTasks().withType(Checkstyle.class).forEach(checkstyle -> checkstyle.getMaxHeapSize().set("1g"));
 			CheckstyleExtension checkstyle = project.getExtensions().getByType(CheckstyleExtension.class);
-			checkstyle.setToolVersion("10.21.2");
+			checkstyle.setToolVersion("10.21.1");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();

buildSrc/src/main/java/org/springframework/build/hint/RuntimeHintsAgentPlugin.java

@@ -27,7 +27,6 @@ import org.gradle.api.attributes.Usage;
 import org.gradle.api.attributes.java.TargetJvmVersion;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.jvm.JvmTestSuite;
-import org.gradle.api.tasks.TaskProvider;
 import org.gradle.api.tasks.testing.Test;
 import org.gradle.testing.base.TestingExtension;
 
@@ -53,7 +52,7 @@ public class RuntimeHintsAgentPlugin implements Plugin<Project> {
 			TestingExtension testing = project.getExtensions().getByType(TestingExtension.class);
 			JvmTestSuite jvmTestSuite = (JvmTestSuite) testing.getSuites().getByName("test");
 			RuntimeHintsAgentExtension agentExtension = createRuntimeHintsAgentExtension(project);
-			TaskProvider<Test> agentTest = project.getTasks().register(RUNTIMEHINTS_TEST_TASK, Test.class, test -> {
+			Test agentTest = project.getTasks().create(RUNTIMEHINTS_TEST_TASK, Test.class, test -> {
 				test.useJUnitPlatform(options -> {
 					options.includeTags("RuntimeHintsTests");
 				});
@@ -64,7 +63,7 @@ public class RuntimeHintsAgentPlugin implements Plugin<Project> {
 				test.setClasspath(jvmTestSuite.getSources().getRuntimeClasspath());
 				test.getJvmArgumentProviders().add(createRuntimeHintsAgentArgumentProvider(project, agentExtension));
 			});
-			project.getTasks().named("check", task -> task.dependsOn(agentTest));
+			project.getTasks().getByName("check", task -> task.dependsOn(agentTest));
 			project.getDependencies().add(CONFIGURATION_NAME, project.project(":spring-core-test"));
 		});
 	}

framework-docs/modules/ROOT/pages/core/beans/definition.adoc

@@ -57,9 +57,9 @@ The following table describes these properties:
 In addition to bean definitions that contain information on how to create a specific
 bean, the `ApplicationContext` implementations also permit the registration of existing
 objects that are created outside the container (by users). This is done by accessing the
-ApplicationContext's `BeanFactory` through the `getAutowireCapableBeanFactory()` method,
-which returns the `DefaultListableBeanFactory` implementation. `DefaultListableBeanFactory`
-supports this registration through the `registerSingleton(..)` and `registerBeanDefinition(..)`
+ApplicationContext's `BeanFactory` through the `getBeanFactory()` method, which returns
+the `DefaultListableBeanFactory` implementation. `DefaultListableBeanFactory` supports
+this registration through the `registerSingleton(..)` and `registerBeanDefinition(..)`
 methods. However, typical applications work solely with beans defined through regular
 bean definition metadata.
 

framework-docs/modules/ROOT/pages/core/beans/dependencies/factory-method-injection.adoc

@@ -120,6 +120,8 @@ dynamically generate a subclass that overrides the method.
   subclasses cannot be `final`, and the method to be overridden cannot be `final`, either.
 * Unit-testing a class that has an `abstract` method requires you to subclass the class
   yourself and to supply a stub implementation of the `abstract` method.
+* Concrete methods are also necessary for component scanning, which requires concrete
+  classes to pick up.
 * A further key limitation is that lookup methods do not work with factory methods and
   in particular not with `@Bean` methods in configuration classes, since, in that case,
   the container is not in charge of creating the instance and therefore cannot create
@@ -291,6 +293,11 @@ Kotlin::
 ----
 ======
 
+Note that you should typically declare such annotated lookup methods with a concrete
+stub implementation, in order for them to be compatible with Spring's component
+scanning rules where abstract classes get ignored by default. This limitation does not
+apply to explicitly registered or explicitly imported bean classes.
+
 [TIP]
 ====
 Another way of accessing differently scoped target beans is an `ObjectFactory`/

framework-docs/modules/ROOT/pages/index.adoc

@@ -7,7 +7,7 @@ xref:overview.adoc[Overview] :: History, Design Philosophy, Feedback,
 Getting Started.
 xref:core.adoc[Core] :: IoC Container, Events, Resources, i18n,
 Validation, Data Binding, Type Conversion, SpEL, AOP, AOT.
-xref:testing.adoc[Testing] :: Mock Objects, TestContext Framework,
+<<testing.adoc#testing, Testing>> :: Mock Objects, TestContext Framework,
 Spring MVC Test, WebTestClient.
 xref:data-access.adoc[Data Access] :: Transactions, DAO Support,
 JDBC, R2DBC, O/R Mapping, XML Marshalling.

framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

@@ -115,15 +115,11 @@ Finally, the body can be set to a callback function that writes to an `OutputStr
 
 ==== Retrieving the response
 
-Once the request has been set up, it can be sent by chaining method calls after `retrieve()`.
-For example, the response body can be accessed by using `retrieve().body(Class)` or `retrieve().body(ParameterizedTypeReference)` for parameterized types like lists.
+Once the request has been set up, the HTTP response is accessed by invoking `retrieve()`.
+The response body can be accessed by using `body(Class)` or `body(ParameterizedTypeReference)` for parameterized types like lists.
 The `body` method converts the response contents into various types – for instance, bytes can be converted into a `String`, JSON can be converted into objects using Jackson, and so on (see <<rest-message-conversion>>).
 
-The response can also be converted into a `ResponseEntity`, giving access to the response headers as well as the body, with `retrieve().toEntity(Class)`
-
-NOTE: Calling `retrieve()` by itself is a no-op and returns a `ResponseSpec`.
-Applications must invoke a terminal operation on the `ResponseSpec` to have any side effect.
-If consuming the response has no interest for your use case, you can use `retrieve().toBodilessEntity()`.
+The response can also be converted into a `ResponseEntity`, giving access to the response headers as well as the body.
 
 This sample shows how `RestClient` can be used to perform a simple `GET` request.
 
@@ -992,27 +988,6 @@ parameter annotation) is set to `false`, or the parameter is marked optional as
 
 
 
-[[rest-http-interface.custom-resolver]]
-=== Custom argument resolver
-
-For more complex cases, HTTP interfaces do not support `RequestEntity` types as method parameters.
-This would take over the entire HTTP request and not improve the semantics of the interface.
-Instead of adding many method parameters, developers can combine them into a custom type
-and configure a dedicated `HttpServiceArgumentResolver` implementation.
-
-In the following HTTP interface, we are using a custom `Search` type as a parameter:
-
-include-code::./CustomHttpServiceArgumentResolver[tag=httpinterface,indent=0]
-
-We can implement our own `HttpServiceArgumentResolver` that supports our custom `Search` type
-and writes its data in the outgoing HTTP request.
-
-include-code::./CustomHttpServiceArgumentResolver[tag=argumentresolver,indent=0]
-
-Finally, we can use this argument resolver during the setup and use our HTTP interface.
-
-include-code::./CustomHttpServiceArgumentResolver[tag=usage,indent=0]
-
 [[rest-http-interface-return-values]]
 === Return Values
 

framework-docs/modules/ROOT/pages/testing/annotations/integration-spring/annotation-mockitobean.adoc

@@ -1,62 +1,34 @@
 [[spring-testing-annotation-beanoverriding-mockitobean]]
 = `@MockitoBean` and `@MockitoSpyBean`
 
-{spring-framework-api}/test/context/bean/override/mockito/MockitoBean.html[`@MockitoBean`] and
-{spring-framework-api}/test/context/bean/override/mockito/MockitoSpyBean.html[`@MockitoSpyBean`]
-can be used in test classes to override a bean in the test's `ApplicationContext` with a
-Mockito _mock_ or _spy_, respectively. In the latter case, an early instance of the
-original bean is captured and wrapped by the spy.
+`@MockitoBean` and `@MockitoSpyBean` are used on non-static fields in test classes to
+override beans in the test's `ApplicationContext` with a Mockito _mock_ or _spy_,
+respectively. In the latter case, an early instance of the original bean is captured and
+wrapped by the spy.
 
-The annotations can be applied in the following ways.
-
-* On a non-static field in a test class or any of its superclasses.
-* On a non-static field in an enclosing class for a `@Nested` test class or in any class
-  in the type hierarchy or enclosing class hierarchy above the `@Nested` test class.
-* At the type level on a test class or any superclass or implemented interface in the
-  type hierarchy above the test class.
-* At the type level on an enclosing class for a `@Nested` test class or on any class or
-  interface in the type hierarchy or enclosing class hierarchy above the `@Nested` test
-  class.
-
-When `@MockitoBean` or `@MockitoSpyBean` is declared on a field, the bean to mock or spy
-is inferred from the type of the annotated field. If multiple candidates exist in the
-`ApplicationContext`, a `@Qualifier` annotation can be declared on the field to help
-disambiguate. In the absence of a `@Qualifier` annotation, the name of the annotated
-field will be used as a _fallback qualifier_. Alternatively, you can explicitly specify a
-bean name to mock or spy by setting the `value` or `name` attribute in the annotation.
-
-When `@MockitoBean` or `@MockitoSpyBean` is declared at the type level, the type of bean
-(or beans) to mock or spy must be supplied via the `types` attribute in the annotation –
-for example, `@MockitoBean(types = {OrderService.class, UserService.class})`. If multiple
-candidates exist in the `ApplicationContext`, you can explicitly specify a bean name to
-mock or spy by setting the `name` attribute. Note, however, that the `types` attribute
-must contain a single type if an explicit bean `name` is configured – for example,
-`@MockitoBean(name = "ps1", types = PrintingService.class)`.
-
-To support reuse of mock configuration, `@MockitoBean` and `@MockitoSpyBean` may be used
-as meta-annotations to create custom _composed annotations_ – for example, to define
-common mock or spy configuration in a single annotation that can be reused across a test
-suite. `@MockitoBean` and `@MockitoSpyBean` can also be used as repeatable annotations at
-the type level — for example, to mock or spy several beans by name.
+By default, the annotated field's type is used to search for candidate beans to override.
+If multiple candidates match, `@Qualifier` can be provided to narrow the candidate to
+override. Alternatively, a candidate whose bean name matches the name of the field will
+match.
 
 [WARNING]
 ====
-Qualifiers, including the name of a field, are used to determine if a separate
+Qualifiers, including the name of the field, are used to determine if a separate
 `ApplicationContext` needs to be created. If you are using this feature to mock or spy
-the same bean in several test classes, make sure to name the fields consistently to avoid
+the same bean in several test classes, make sure to name the field consistently to avoid
 creating unnecessary contexts.
 ====
 
 Each annotation also defines Mockito-specific attributes to fine-tune the mocking behavior.
 
 The `@MockitoBean` annotation uses the `REPLACE_OR_CREATE`
-xref:testing/testcontext-framework/bean-overriding.adoc#testcontext-bean-overriding-strategy[strategy for bean overrides].
-If a corresponding bean does not exist, a new bean will be created. However, you can
-switch to the `REPLACE` strategy by setting the `enforceOverride` attribute to `true` –
-for example, `@MockitoBean(enforceOverride = true)`.
+xref:testing/testcontext-framework/bean-overriding.adoc#testcontext-bean-overriding-custom[strategy for test bean overriding].
+If no existing bean matches, a new bean is created on the fly. However, you can switch to
+the `REPLACE` strategy by setting the `enforceOverride` attribute to `true`. See the
+following section for an example.
 
 The `@MockitoSpyBean` annotation uses the `WRAP`
-xref:testing/testcontext-framework/bean-overriding.adoc#testcontext-bean-overriding-strategy[strategy],
+xref:testing/testcontext-framework/bean-overriding.adoc#testcontext-bean-overriding-custom[strategy],
 and the original instance is wrapped in a Mockito spy. This strategy requires that
 exactly one candidate bean exists.
 
@@ -84,8 +56,15 @@ or `private` depending on the needs or coding practices of the project.
 [[spring-testing-annotation-beanoverriding-mockitobean-examples]]
 == `@MockitoBean` Examples
 
-The following example shows how to use the default behavior of the `@MockitoBean`
-annotation.
+When using `@MockitoBean`, a new bean will be created if a corresponding bean does not
+exist. However, if you would like for the test to fail when a corresponding bean does not
+exist, you can set the `enforceOverride` attribute to `true` – for example,
+`@MockitoBean(enforceOverride = true)`.
+
+To use a by-name override rather than a by-type override, specify the `name` (or `value`)
+attribute of the annotation.
+
+The following example shows how to use the default behavior of the `@MockitoBean` annotation:
 
 [tabs]
 ======
@@ -102,7 +81,7 @@ Java::
 		// tests...
 	}
 ----
-<1> Replace the bean with type `CustomService` with a Mockito mock.
+<1> Replace the bean with type `CustomService` with a Mockito `mock`.
 ======
 
 In the example above, we are creating a mock for `CustomService`. If more than one bean
@@ -111,8 +90,7 @@ will fail, and you will need to provide a qualifier of some sort to identify whi
 `CustomService` beans you want to override. If no such bean exists, a bean will be
 created with an auto-generated bean name.
 
-The following example uses a by-name lookup, rather than a by-type lookup. If no bean
-named `service` exists, one is created.
+The following example uses a by-name lookup, rather than a by-type lookup:
 
 [tabs]
 ======
@@ -130,9 +108,32 @@ Java::
 
 	}
 ----
-<1> Replace the bean named `service` with a Mockito mock.
+<1> Replace the bean named `service` with a Mockito `mock`.
 ======
 
+If no bean named `service` exists, one is created.
+
+`@MockitoBean` can also be used at the type level:
+
+- on a test class or any superclass or implemented interface in the type hierarchy above
+  the test class
+- on an enclosing class for a `@Nested` test class or on any class or interface in the
+  type hierarchy or enclosing class hierarchy above the `@Nested` test class
+
+When `@MockitoBean` is declared at the type level, the type of bean (or beans) to mock
+must be supplied via the `types` attribute – for example,
+`@MockitoBean(types = {OrderService.class, UserService.class})`. If multiple candidates
+exist in the application context, you can explicitly specify a bean name to mock by
+setting the `name` attribute. Note, however, that the `types` attribute must contain a
+single type if an explicit bean `name` is configured – for example,
+`@MockitoBean(name = "ps1", types = PrintingService.class)`.
+
+To support reuse of mock configuration, `@MockitoBean` may be used as a meta-annotation
+to create custom _composed annotations_ — for example, to define common mock
+configuration in a single annotation that can be reused across a test suite.
+`@MockitoBean` can also be used as a repeatable annotation at the type level — for
+example, to mock several beans by name.
+
 The following `@SharedMocks` annotation registers two mocks by-type and one mock by-name.
 
 [tabs]
@@ -190,7 +191,7 @@ APIs.
 == `@MockitoSpyBean` Examples
 
 The following example shows how to use the default behavior of the `@MockitoSpyBean`
-annotation.
+annotation:
 
 [tabs]
 ======
@@ -207,7 +208,7 @@ Java::
 		// tests...
 	}
 ----
-<1> Wrap the bean with type `CustomService` with a Mockito spy.
+<1> Wrap the bean with type `CustomService` with a Mockito `spy`.
 ======
 
 In the example above, we are wrapping the bean with type `CustomService`. If more than
@@ -215,7 +216,7 @@ one bean of that type exists, the bean named `customService` is considered. Othe
 the test will fail, and you will need to provide a qualifier of some sort to identify
 which of the `CustomService` beans you want to spy.
 
-The following example uses a by-name lookup, rather than a by-type lookup.
+The following example uses a by-name lookup, rather than a by-type lookup:
 
 [tabs]
 ======
@@ -232,58 +233,5 @@ Java::
 		// tests...
 	}
 ----
-<1> Wrap the bean named `service` with a Mockito spy.
+<1> Wrap the bean named `service` with a Mockito `spy`.
 ======
-
-The following `@SharedSpies` annotation registers two spies by-type and one spy by-name.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Target(ElementType.TYPE)
-	@Retention(RetentionPolicy.RUNTIME)
-	@MockitoSpyBean(types = {OrderService.class, UserService.class}) // <1>
-	@MockitoSpyBean(name = "ps1", types = PrintingService.class) // <2>
-	public @interface SharedSpies {
-	}
-----
-<1> Register `OrderService` and `UserService` spies by-type.
-<2> Register `PrintingService` spy by-name.
-======
-
-The following demonstrates how `@SharedSpies` can be used on a test class.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@SpringJUnitConfig(TestConfig.class)
-	@SharedSpies // <1>
-	class BeanOverrideTests {
-
-		@Autowired OrderService orderService; // <2>
-
-		@Autowired UserService userService; // <2>
-
-		@Autowired PrintingService ps1; // <2>
-
-		// Inject other components that rely on the spies.
-
-		@Test
-		void testThatDependsOnMocks() {
-			// ...
-		}
-	}
-----
-<1> Register common spies via the custom `@SharedSpies` annotation.
-<2> Optionally inject spies to _stub_ or _verify_ them.
-======
-
-TIP: The spies can also be injected into `@Configuration` classes or other test-related
-components in the `ApplicationContext` in order to configure them with Mockito's stubbing
-APIs.

framework-docs/modules/ROOT/pages/testing/annotations/integration-spring/annotation-testbean.adoc

@@ -1,9 +1,8 @@
 [[spring-testing-annotation-beanoverriding-testbean]]
 = `@TestBean`
 
-{spring-framework-api}/test/context/bean/override/convention/TestBean.html[`@TestBean`]
-is used on a non-static field in a test class to override a specific bean in the test's
-`ApplicationContext` with an instance provided by a factory method.
+`@TestBean` is used on a non-static field in a test class to override a specific bean in
+the test's `ApplicationContext` with an instance provided by a factory method.
 
 The associated factory method name is derived from the annotated field's name, or the
 bean name if specified. The factory method must be `static`, accept no arguments, and

framework-docs/modules/ROOT/pages/testing/testcontext-framework/bean-overriding.adoc

@@ -2,8 +2,8 @@
 = Bean Overriding in Tests
 
 Bean overriding in tests refers to the ability to override specific beans in the
-`ApplicationContext` for a test class, by annotating the test class or one or more
-non-static fields in the test class.
+`ApplicationContext` for a test class, by annotating one or more non-static fields in the
+test class.
 
 NOTE: This feature is intended as a less risky alternative to the practice of registering
 a bean via `@Bean` with the `DefaultListableBeanFactory`
@@ -42,16 +42,15 @@ The `spring-test` module registers implementations of the latter two
 {spring-framework-code}/spring-test/src/main/resources/META-INF/spring.factories[`META-INF/spring.factories`
 properties file].
 
-The bean overriding infrastructure searches for annotations on test classes as well as
-annotations on non-static fields in test classes that are meta-annotated with
-`@BeanOverride` and instantiates the corresponding `BeanOverrideProcessor` which is
-responsible for creating an appropriate `BeanOverrideHandler`.
+The bean overriding infrastructure searches in test classes for any non-static field that
+is meta-annotated with `@BeanOverride` and instantiates the corresponding
+`BeanOverrideProcessor` which is responsible for creating an appropriate
+`BeanOverrideHandler`.
 
 The internal `BeanOverrideBeanFactoryPostProcessor` then uses bean override handlers to
 alter the test's `ApplicationContext` by creating, replacing, or wrapping beans as
 defined by the corresponding `BeanOverrideStrategy`:
 
-[[testcontext-bean-overriding-strategy]]
 `REPLACE`::
   Replaces the bean. Throws an exception if a corresponding bean does not exist.
 `REPLACE_OR_CREATE`::

framework-docs/modules/ROOT/pages/web/websocket/stomp/ordered-messages.adoc

@@ -19,6 +19,6 @@ from where they are handled according to their destination prefix. As the channe
 a `ThreadPoolExecutor`, messages are processed in different threads, and the resulting sequence
 of handling may not match the exact order in which they were received.
 
-To enable ordered receiving, set the `setPreserveReceiveOrder` flag as follows:
+To enable ordered publishing, set the `setPreserveReceiveOrder` flag as follows:
 
 include-code::./ReceiveOrderWebSocketConfiguration[tag=snippet,indent=0]

framework-docs/src/main/java/org/springframework/docs/integration/resthttpinterface/customresolver/CustomHttpServiceArgumentResolver.java

@@ -1,105 +0,0 @@
-/*
- * Copyright 2002-2025 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.docs.integration.resthttpinterface.customresolver;
-
-import java.util.List;
-
-import org.springframework.core.MethodParameter;
-import org.springframework.web.client.RestClient;
-import org.springframework.web.client.support.RestClientAdapter;
-import org.springframework.web.service.annotation.GetExchange;
-import org.springframework.web.service.invoker.HttpRequestValues;
-import org.springframework.web.service.invoker.HttpServiceArgumentResolver;
-import org.springframework.web.service.invoker.HttpServiceProxyFactory;
-
-public class CustomHttpServiceArgumentResolver {
-
-	// tag::httpinterface[]
-	interface RepositoryService {
-
-		@GetExchange("/repos/search")
-		List<Repository> searchRepository(Search search);
-
-	}
-	// end::httpinterface[]
-
-	class Sample {
-
-		void sample() {
-			// tag::usage[]
-			RestClient restClient = RestClient.builder().baseUrl("https://api.github.com/").build();
-			RestClientAdapter adapter = RestClientAdapter.create(restClient);
-			HttpServiceProxyFactory factory = HttpServiceProxyFactory
-					.builderFor(adapter)
-					.customArgumentResolver(new SearchQueryArgumentResolver())
-					.build();
-			RepositoryService repositoryService = factory.createClient(RepositoryService.class);
-
-			Search search = Search.create()
-					.owner("spring-projects")
-					.language("java")
-					.query("rest")
-					.build();
-			List<Repository> repositories = repositoryService.searchRepository(search);
-			// end::usage[]
-		}
-
-	}
-
-	// tag::argumentresolver[]
-	static class SearchQueryArgumentResolver implements HttpServiceArgumentResolver {
-		@Override
-		public boolean resolve(Object argument, MethodParameter parameter, HttpRequestValues.Builder requestValues) {
-			if (parameter.getParameterType().equals(Search.class)) {
-				Search search = (Search) argument;
-				requestValues.addRequestParameter("owner", search.owner());
-				requestValues.addRequestParameter("language", search.language());
-				requestValues.addRequestParameter("query", search.query());
-				return true;
-			}
-			return false;
-		}
-	}
-	// end::argumentresolver[]
-
-
-	record Search (String query, String owner, String language) {
-
-		static Builder create() {
-			return new Builder();
-		}
-
-		static class Builder {
-
-			Builder query(String query) { return this;}
-
-			Builder owner(String owner) { return this;}
-
-			Builder language(String language) { return this;}
-
-			Search build() {
-				return new Search(null, null, null);
-			}
-		}
-
-	}
-
-	record Repository(String name) {
-
-	}
-
-}

framework-docs/src/main/kotlin/org/springframework/docs/integration/resthttpinterface/customresolver/CustomHttpServiceArgumentResolver.kt

@@ -1,78 +0,0 @@
-/*
- * Copyright 2002-2025 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.docs.integration.resthttpinterface.customresolver
-
-import org.springframework.core.MethodParameter
-import org.springframework.web.client.RestClient
-import org.springframework.web.client.support.RestClientAdapter
-import org.springframework.web.service.annotation.GetExchange
-import org.springframework.web.service.invoker.HttpRequestValues
-import org.springframework.web.service.invoker.HttpServiceArgumentResolver
-import org.springframework.web.service.invoker.HttpServiceProxyFactory
-
-class CustomHttpServiceArgumentResolver {
-
-	// tag::httpinterface[]
-	interface RepositoryService {
-
-		@GetExchange("/repos/search")
-		fun searchRepository(search: Search): List<Repository>
-
-	}
-	// end::httpinterface[]
-
-	class Sample {
-		fun sample() {
-			// tag::usage[]
-			val restClient = RestClient.builder().baseUrl("https://api.github.com/").build()
-			val adapter = RestClientAdapter.create(restClient)
-			val factory = HttpServiceProxyFactory
-				.builderFor(adapter)
-				.customArgumentResolver(SearchQueryArgumentResolver())
-				.build()
-			val repositoryService = factory.createClient<RepositoryService>(RepositoryService::class.java)
-
-			val search = Search(owner = "spring-projects", language = "java", query = "rest")
-			val repositories = repositoryService.searchRepository(search)
-			// end::usage[]
-			repositories.size
-		}
-	}
-
-	// tag::argumentresolver[]
-	class SearchQueryArgumentResolver : HttpServiceArgumentResolver {
-		override fun resolve(
-			argument: Any?,
-			parameter: MethodParameter,
-			requestValues: HttpRequestValues.Builder
-		): Boolean {
-			if (parameter.getParameterType() == Search::class.java) {
-				val search = argument as Search
-				requestValues.addRequestParameter("owner", search.owner)
-					.addRequestParameter("language", search.language)
-					.addRequestParameter("query", search.query)
-				return true
-			}
-			return false
-		}
-	}
-	// end::argumentresolver[]
-
-	data class Search(val query: String, val owner: String, val language: String)
-
-	data class Repository(val name: String)
-}

framework-platform/framework-platform.gradle

@@ -8,14 +8,14 @@ javaPlatform {
 
 dependencies {
 	api(platform("com.fasterxml.jackson:jackson-bom:2.18.2"))
-	api(platform("io.micrometer:micrometer-bom:1.14.4"))
-	api(platform("io.netty:netty-bom:4.1.118.Final"))
+	api(platform("io.micrometer:micrometer-bom:1.14.3"))
+	api(platform("io.netty:netty-bom:4.1.117.Final"))
 	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2024.0.3"))
-	api(platform("io.rsocket:rsocket-bom:1.1.5"))
+	api(platform("io.projectreactor:reactor-bom:2024.0.2"))
+	api(platform("io.rsocket:rsocket-bom:1.1.4"))
 	api(platform("org.apache.groovy:groovy-bom:4.0.24"))
 	api(platform("org.apache.logging.log4j:log4j-bom:2.21.1"))
-	api(platform("org.assertj:assertj-bom:3.27.3"))
+	api(platform("org.assertj:assertj-bom:3.27.2"))
 	api(platform("org.eclipse.jetty:jetty-bom:12.0.16"))
 	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.16"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.8.1"))
@@ -142,7 +142,7 @@ dependencies {
 		api("org.seleniumhq.selenium:selenium-java:4.26.0")
 		api("org.skyscreamer:jsonassert:1.5.3")
 		api("org.slf4j:slf4j-api:2.0.16")
-		api("org.testng:testng:7.11.0")
+		api("org.testng:testng:7.10.2")
 		api("org.webjars:underscorejs:1.8.3")
 		api("org.webjars:webjars-locator-core:0.55")
 		api("org.webjars:webjars-locator-lite:1.0.0")

gradle.properties

@@ -1,4 +1,4 @@
-version=6.2.3
+version=6.2.2
 
 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m

settings.gradle

@@ -1,5 +1,5 @@
 plugins {
-	id "com.gradle.develocity" version "3.19"
+	id "com.gradle.develocity" version "3.17.2"
 	id "io.spring.ge.conventions" version "0.0.17"
 	id "org.gradle.toolchains.foojay-resolver-convention" version "0.7.0"
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/AbstractAspectJAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -276,18 +276,14 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 		if (this.aspectJAdviceMethod.getParameterCount() == this.argumentNames.length + 1) {
 			// May need to add implicit join point arg name...
-			for (int i = 0; i < this.aspectJAdviceMethod.getParameterCount(); i++) {
-				Class<?> argType = this.aspectJAdviceMethod.getParameterTypes()[i];
-				if (argType == JoinPoint.class ||
-						argType == ProceedingJoinPoint.class ||
-						argType == JoinPoint.StaticPart.class) {
-					String[] oldNames = this.argumentNames;
-					this.argumentNames = new String[oldNames.length + 1];
-					System.arraycopy(oldNames, 0, this.argumentNames, 0, i);
-					this.argumentNames[i] = "THIS_JOIN_POINT";
-					System.arraycopy(oldNames, i, this.argumentNames, i + 1, oldNames.length - i);
-					break;
-				}
+			Class<?> firstArgType = this.aspectJAdviceMethod.getParameterTypes()[0];
+			if (firstArgType == JoinPoint.class ||
+					firstArgType == ProceedingJoinPoint.class ||
+					firstArgType == JoinPoint.StaticPart.class) {
+				String[] oldNames = this.argumentNames;
+				this.argumentNames = new String[oldNames.length + 1];
+				this.argumentNames[0] = "THIS_JOIN_POINT";
+				System.arraycopy(oldNames, 0, this.argumentNames, 1, oldNames.length);
 			}
 		}
 	}

spring-aop/src/main/java/org/springframework/aop/interceptor/AsyncExecutionInterceptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -125,7 +125,7 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport imple
 			return null;
 		};
 
-		return doSubmit(task, executor, userMethod.getReturnType());
+		return doSubmit(task, executor, invocation.getMethod().getReturnType());
 	}
 
 	/**

spring-aop/src/test/java/org/springframework/aop/aspectj/AbstractAspectJAdviceTests.java

@@ -1,135 +0,0 @@
-/*
- * Copyright 2002-2025 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.aop.aspectj;
-
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.function.Consumer;
-
-import org.aspectj.lang.JoinPoint;
-import org.aspectj.lang.ProceedingJoinPoint;
-import org.assertj.core.api.InstanceOfAssertFactories;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-
-/**
- * Tests for {@link AbstractAspectJAdvice}.
- *
- * @author Joshua Chen
- * @author Stephane Nicoll
- */
-class AbstractAspectJAdviceTests {
-
-	@Test
-	void setArgumentNamesFromStringArray_withoutJoinPointParameter() {
-		AbstractAspectJAdvice advice = getAspectJAdvice("methodWithNoJoinPoint");
-		assertThat(advice).satisfies(hasArgumentNames("arg1", "arg2"));
-	}
-
-	@Test
-	void setArgumentNamesFromStringArray_withJoinPointAsFirstParameter() {
-		AbstractAspectJAdvice advice = getAspectJAdvice("methodWithJoinPointAsFirstParameter");
-		assertThat(advice).satisfies(hasArgumentNames("THIS_JOIN_POINT", "arg1", "arg2"));
-	}
-
-	@Test
-	void setArgumentNamesFromStringArray_withJoinPointAsLastParameter() {
-		AbstractAspectJAdvice advice = getAspectJAdvice("methodWithJoinPointAsLastParameter");
-		assertThat(advice).satisfies(hasArgumentNames("arg1", "arg2", "THIS_JOIN_POINT"));
-	}
-
-	@Test
-	void setArgumentNamesFromStringArray_withJoinPointAsMiddleParameter() {
-		AbstractAspectJAdvice advice = getAspectJAdvice("methodWithJoinPointAsMiddleParameter");
-		assertThat(advice).satisfies(hasArgumentNames("arg1", "THIS_JOIN_POINT", "arg2"));
-	}
-
-	@Test
-	void setArgumentNamesFromStringArray_withProceedingJoinPoint() {
-		AbstractAspectJAdvice advice = getAspectJAdvice("methodWithProceedingJoinPoint");
-		assertThat(advice).satisfies(hasArgumentNames("THIS_JOIN_POINT", "arg1", "arg2"));
-	}
-
-	@Test
-	void setArgumentNamesFromStringArray_withStaticPart() {
-		AbstractAspectJAdvice advice = getAspectJAdvice("methodWithStaticPart");
-		assertThat(advice).satisfies(hasArgumentNames("THIS_JOIN_POINT", "arg1", "arg2"));
-	}
-
-	private Consumer<AbstractAspectJAdvice> hasArgumentNames(String... argumentNames) {
-		return advice -> assertThat(advice).extracting("argumentNames")
-				.asInstanceOf(InstanceOfAssertFactories.array(String[].class))
-				.containsExactly(argumentNames);
-	}
-
-	private AbstractAspectJAdvice getAspectJAdvice(final String methodName) {
-		AbstractAspectJAdvice advice = new TestAspectJAdvice(getMethod(methodName),
-				mock(AspectJExpressionPointcut.class), mock(AspectInstanceFactory.class));
-		advice.setArgumentNamesFromStringArray("arg1", "arg2");
-		return advice;
-	}
-
-	private Method getMethod(final String methodName) {
-		return Arrays.stream(Sample.class.getDeclaredMethods())
-				.filter(method -> method.getName().equals(methodName)).findFirst()
-				.orElseThrow();
-	}
-
-	@SuppressWarnings("serial")
-	public static class TestAspectJAdvice extends AbstractAspectJAdvice {
-
-		public TestAspectJAdvice(Method aspectJAdviceMethod, AspectJExpressionPointcut pointcut,
-				AspectInstanceFactory aspectInstanceFactory) {
-			super(aspectJAdviceMethod, pointcut, aspectInstanceFactory);
-		}
-
-		@Override
-		public boolean isBeforeAdvice() {
-			return false;
-		}
-
-		@Override
-		public boolean isAfterAdvice() {
-			return false;
-		}
-	}
-
-	@SuppressWarnings("unused")
-	static class Sample {
-
-		void methodWithNoJoinPoint(String arg1, String arg2) {
-		}
-
-		void methodWithJoinPointAsFirstParameter(JoinPoint joinPoint, String arg1, String arg2) {
-		}
-
-		void methodWithJoinPointAsLastParameter(String arg1, String arg2, JoinPoint joinPoint) {
-		}
-
-		void methodWithJoinPointAsMiddleParameter(String arg1, JoinPoint joinPoint, String arg2) {
-		}
-
-		void methodWithProceedingJoinPoint(ProceedingJoinPoint joinPoint, String arg1, String arg2) {
-		}
-
-		void methodWithStaticPart(JoinPoint.StaticPart staticPart, String arg1, String arg2) {
-		}
-	}
-
-}

spring-aop/src/test/java/org/springframework/aop/interceptor/AsyncExecutionInterceptorTests.java

@@ -1,73 +0,0 @@
-/*
- * Copyright 2002-2025 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.aop.interceptor;
-
-import java.util.concurrent.Callable;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Future;
-
-import org.aopalliance.intercept.MethodInvocation;
-import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentCaptor;
-
-import org.springframework.core.task.AsyncTaskExecutor;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
-
-/**
- * Tests for {@link AsyncExecutionInterceptor}.
- *
- * @author Bao Ngo
- * @since 7.0
- */
-class AsyncExecutionInterceptorTests {
-
-	@Test
-	@SuppressWarnings("unchecked")
-	void invokeOnInterfaceWithGeneric() throws Throwable {
-		AsyncExecutionInterceptor interceptor = spy(new AsyncExecutionInterceptor(null));
-		FutureRunner impl = new FutureRunner();
-		MethodInvocation mi = mock();
-		given(mi.getThis()).willReturn(impl);
-		given(mi.getMethod()).willReturn(GenericRunner.class.getMethod("run"));
-
-		interceptor.invoke(mi);
-		ArgumentCaptor<Class<?>> classArgumentCaptor = ArgumentCaptor.forClass(Class.class);
-		verify(interceptor).doSubmit(any(Callable.class), any(AsyncTaskExecutor.class), classArgumentCaptor.capture());
-		assertThat(classArgumentCaptor.getValue()).isEqualTo(Future.class);
-	}
-
-
-	interface GenericRunner<O> {
-
-		O run();
-	}
-
-	static class FutureRunner implements GenericRunner<Future<Void>> {
-		@Override
-		public Future<Void> run() {
-			return CompletableFuture.runAsync(() -> {
-			});
-		}
-	}
-}

spring-beans/src/main/java/org/springframework/beans/AbstractNestablePropertyAccessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -658,14 +658,6 @@ public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyA
 						growCollectionIfNecessary(list, index, indexedPropertyName.toString(), ph, i + 1);
 						value = list.get(index);
 					}
-					else if (value instanceof Map map) {
-						Class<?> mapKeyType = ph.getResolvableType().getNested(i + 1).asMap().resolveGeneric(0);
-						// IMPORTANT: Do not pass full property name in here - property editors
-						// must not kick in for map keys but rather only for map values.
-						TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(mapKeyType);
-						Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType, typeDescriptor);
-						value = map.get(convertedMapKey);
-					}
 					else if (value instanceof Iterable iterable) {
 						// Apply index to Iterator in case of a Set/Collection/Iterable.
 						int index = Integer.parseInt(key);
@@ -693,6 +685,14 @@ public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyA
 											currIndex + ", accessed using property path '" + propertyName + "'");
 						}
 					}
+					else if (value instanceof Map map) {
+						Class<?> mapKeyType = ph.getResolvableType().getNested(i + 1).asMap().resolveGeneric(0);
+						// IMPORTANT: Do not pass full property name in here - property editors
+						// must not kick in for map keys but rather only for map values.
+						TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(mapKeyType);
+						Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType, typeDescriptor);
+						value = map.get(convertedMapKey);
+					}
 					else {
 						throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
 								"Property referenced in indexed property path '" + propertyName +
@@ -904,7 +904,16 @@ public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyA
 	private Object newValue(Class<?> type, @Nullable TypeDescriptor desc, String name) {
 		try {
 			if (type.isArray()) {
-				return createArray(type);
+				Class<?> componentType = type.componentType();
+				// TODO - only handles 2-dimensional arrays
+				if (componentType.isArray()) {
+					Object array = Array.newInstance(componentType, 1);
+					Array.set(array, 0, Array.newInstance(componentType.componentType(), 0));
+					return array;
+				}
+				else {
+					return Array.newInstance(componentType, 0);
+				}
 			}
 			else if (Collection.class.isAssignableFrom(type)) {
 				TypeDescriptor elementDesc = (desc != null ? desc.getElementTypeDescriptor() : null);
@@ -928,24 +937,6 @@ public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyA
 		}
 	}
 
-	/**
-	 * Create the array for the given array type.
-	 * @param arrayType the desired type of the target array
-	 * @return a new array instance
-	 */
-	private static Object createArray(Class<?> arrayType) {
-		Assert.notNull(arrayType, "Array type must not be null");
-		Class<?> componentType = arrayType.componentType();
-		if (componentType.isArray()) {
-			Object array = Array.newInstance(componentType, 1);
-			Array.set(array, 0, createArray(componentType));
-			return array;
-		}
-		else {
-			return Array.newInstance(componentType, 0);
-		}
-	}
-
 	/**
 	 * Parse the given property name into the corresponding property name tokens.
 	 * @param propertyName the property name to parse

spring-beans/src/main/java/org/springframework/beans/PropertyEditorRegistrar.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -45,18 +45,4 @@ public interface PropertyEditorRegistrar {
 	 */
 	void registerCustomEditors(PropertyEditorRegistry registry);
 
-	/**
-	 * Indicate whether this registrar exclusively overrides default editors
-	 * rather than registering custom editors, intended to be applied lazily.
-	 * <p>This has an impact on registrar handling in a bean factory: see
-	 * {@link org.springframework.beans.factory.config.ConfigurableBeanFactory#addPropertyEditorRegistrar}.
-	 * @since 6.2.3
-	 * @see PropertyEditorRegistry#registerCustomEditor
-	 * @see PropertyEditorRegistrySupport#overrideDefaultEditor
-	 * @see PropertyEditorRegistrySupport#setDefaultEditorRegistrar
-	 */
-	default boolean overridesDefaultEditors() {
-		return false;
-	}
-
 }

spring-beans/src/main/java/org/springframework/beans/PropertyEditorRegistrySupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -99,9 +99,6 @@ public class PropertyEditorRegistrySupport implements PropertyEditorRegistry {
 
 	private boolean configValueEditorsActive = false;
 
-	@Nullable
-	private PropertyEditorRegistrar defaultEditorRegistrar;
-
 	@Nullable
 	private Map<Class<?>, PropertyEditor> defaultEditors;
 
@@ -158,19 +155,6 @@ public class PropertyEditorRegistrySupport implements PropertyEditorRegistry {
 		this.configValueEditorsActive = true;
 	}
 
-	/**
-	 * Set a registrar for default editors, as a lazy way of overriding default editors.
-	 * <p>This is expected to be a collaborator with {@link PropertyEditorRegistrySupport},
-	 * downcasting the given {@link PropertyEditorRegistry} accordingly and calling
-	 * {@link #overrideDefaultEditor} for registering additional default editors on it.
-	 * @param registrar the registrar to call when default editors are actually needed
-	 * @since 6.2.3
-	 * @see #overrideDefaultEditor
-	 */
-	public void setDefaultEditorRegistrar(PropertyEditorRegistrar registrar) {
-		this.defaultEditorRegistrar = registrar;
-	}
-
 	/**
 	 * Override the default editor for the specified type with the given property editor.
 	 * <p>Note that this is different from registering a custom editor in that the editor
@@ -200,9 +184,6 @@ public class PropertyEditorRegistrySupport implements PropertyEditorRegistry {
 		if (!this.defaultEditorsActive) {
 			return null;
 		}
-		if (this.overriddenDefaultEditors == null && this.defaultEditorRegistrar != null) {
-			this.defaultEditorRegistrar.registerCustomEditors(this);
-		}
 		if (this.overriddenDefaultEditors != null) {
 			PropertyEditor editor = this.overriddenDefaultEditors.get(requiredType);
 			if (editor != null) {

spring-beans/src/main/java/org/springframework/beans/factory/BeanFactoryUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -39,14 +39,10 @@ import org.springframework.util.StringUtils;
  * (which the methods defined on the ListableBeanFactory interface don't,
  * in contrast to the methods defined on the BeanFactory interface).
  *
- * <p><b>NOTE:</b> It is generally preferable to use {@link ObjectProvider#stream()}
- * via {@link BeanFactory#getBeanProvider} instead of this utility class.
- *
  * @author Rod Johnson
  * @author Juergen Hoeller
  * @author Chris Beams
  * @since 04.07.2003
- * @see BeanFactory#getBeanProvider
  */
 public abstract class BeanFactoryUtils {
 
@@ -312,7 +308,7 @@ public abstract class BeanFactoryUtils {
 	 * 'replacing' beans by explicitly choosing the same bean name in a child factory;
 	 * the bean in the ancestor factory won't be visible then, not even for by-type lookups.
 	 * @param lbf the bean factory
-	 * @param type the type of bean to match
+	 * @param type type of bean to match
 	 * @return the Map of matching bean instances, or an empty Map if none
 	 * @throws BeansException if a bean could not be created
 	 * @see ListableBeanFactory#getBeansOfType(Class)
@@ -351,7 +347,7 @@ public abstract class BeanFactoryUtils {
 	 * 'replacing' beans by explicitly choosing the same bean name in a child factory;
 	 * the bean in the ancestor factory won't be visible then, not even for by-type lookups.
 	 * @param lbf the bean factory
-	 * @param type the type of bean to match
+	 * @param type type of bean to match
 	 * @param includeNonSingletons whether to include prototype or scoped beans too
 	 * or just singletons (also applies to FactoryBeans)
 	 * @param allowEagerInit whether to initialize <i>lazy-init singletons</i> and
@@ -399,7 +395,7 @@ public abstract class BeanFactoryUtils {
 	 * 'replacing' beans by explicitly choosing the same bean name in a child factory;
 	 * the bean in the ancestor factory won't be visible then, not even for by-type lookups.
 	 * @param lbf the bean factory
-	 * @param type the type of bean to match
+	 * @param type type of bean to match
 	 * @return the matching bean instance
 	 * @throws NoSuchBeanDefinitionException if no bean of the given type was found
 	 * @throws NoUniqueBeanDefinitionException if more than one bean of the given type was found
@@ -429,7 +425,7 @@ public abstract class BeanFactoryUtils {
 	 * 'replacing' beans by explicitly choosing the same bean name in a child factory;
 	 * the bean in the ancestor factory won't be visible then, not even for by-type lookups.
 	 * @param lbf the bean factory
-	 * @param type the type of bean to match
+	 * @param type type of bean to match
 	 * @param includeNonSingletons whether to include prototype or scoped beans too
 	 * or just singletons (also applies to FactoryBeans)
 	 * @param allowEagerInit whether to initialize <i>lazy-init singletons</i> and
@@ -461,7 +457,7 @@ public abstract class BeanFactoryUtils {
 	 * <p>This version of {@code beanOfType} automatically includes
 	 * prototypes and FactoryBeans.
 	 * @param lbf the bean factory
-	 * @param type the type of bean to match
+	 * @param type type of bean to match
 	 * @return the matching bean instance
 	 * @throws NoSuchBeanDefinitionException if no bean of the given type was found
 	 * @throws NoUniqueBeanDefinitionException if more than one bean of the given type was found
@@ -485,7 +481,7 @@ public abstract class BeanFactoryUtils {
 	 * only raw FactoryBeans will be checked (which doesn't require initialization
 	 * of each FactoryBean).
 	 * @param lbf the bean factory
-	 * @param type the type of bean to match
+	 * @param type type of bean to match
 	 * @param includeNonSingletons whether to include prototype or scoped beans too
 	 * or just singletons (also applies to FactoryBeans)
 	 * @param allowEagerInit whether to initialize <i>lazy-init singletons</i> and
@@ -533,7 +529,7 @@ public abstract class BeanFactoryUtils {
 
 	/**
 	 * Extract a unique bean for the given type from the given Map of matching beans.
-	 * @param type the type of bean to match
+	 * @param type type of bean to match
 	 * @param matchingBeans all matching beans found
 	 * @return the unique bean instance
 	 * @throws NoSuchBeanDefinitionException if no bean of the given type was found

spring-beans/src/main/java/org/springframework/beans/factory/ObjectProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -18,7 +18,6 @@ package org.springframework.beans.factory;
 
 import java.util.Iterator;
 import java.util.function.Consumer;
-import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
 
@@ -54,18 +53,6 @@ import org.springframework.lang.Nullable;
  */
 public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {
 
-	/**
-	 * A predicate for unfiltered type matches, including non-default candidates
-	 * but still excluding non-autowire candidates when used on injection points.
-	 * @since 6.2.3
-	 * @see #stream(Predicate)
-	 * @see #orderedStream(Predicate)
-	 * @see org.springframework.beans.factory.config.BeanDefinition#isAutowireCandidate()
-	 * @see org.springframework.beans.factory.support.AbstractBeanDefinition#isDefaultCandidate()
-	 */
-	Predicate<Class<?>> UNFILTERED = (clazz -> true);
-
-
 	@Override
 	default T getObject() throws BeansException {
 		Iterator<T> it = iterator();
@@ -211,10 +198,6 @@ public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {
 	/**
 	 * Return a sequential {@link Stream} over all matching object instances,
 	 * without specific ordering guarantees (but typically in registration order).
-	 * <p>Note: The result may be filtered by default according to qualifiers on the
-	 * injection point versus target beans and the general autowire candidate status
-	 * of matching beans. For custom filtering against type-matching candidates, use
-	 * {@link #stream(Predicate)} instead (potentially with {@link #UNFILTERED}).
 	 * @since 5.1
 	 * @see #iterator()
 	 * @see #orderedStream()
@@ -236,10 +219,6 @@ public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {
 	 * {@link #stream()} method. You may override this to apply an
 	 * {@link org.springframework.core.annotation.AnnotationAwareOrderComparator}
 	 * if necessary.
-	 * <p>Note: The result may be filtered by default according to qualifiers on the
-	 * injection point versus target beans and the general autowire candidate status
-	 * of matching beans. For custom filtering against type-matching candidates, use
-	 * {@link #stream(Predicate)} instead (potentially with {@link #UNFILTERED}).
 	 * @since 5.1
 	 * @see #stream()
 	 * @see org.springframework.core.OrderComparator
@@ -248,32 +227,4 @@ public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {
 		return stream().sorted(OrderComparator.INSTANCE);
 	}
 
-	/**
-	 * Return a custom-filtered {@link Stream} over all matching object instances,
-	 * without specific ordering guarantees (but typically in registration order).
-	 * @param customFilter a custom type filter for selecting beans among the raw
-	 * bean type matches (or {@link #UNFILTERED} for all raw type matches without
-	 * any default filtering)
-	 * @since 6.2.3
-	 * @see #stream()
-	 * @see #orderedStream(Predicate)
-	 */
-	default Stream<T> stream(Predicate<Class<?>> customFilter) {
-		return stream().filter(obj -> customFilter.test(obj.getClass()));
-	}
-
-	/**
-	 * Return a custom-filtered {@link Stream} over all matching object instances,
-	 * pre-ordered according to the factory's common order comparator.
-	 * @param customFilter a custom type filter for selecting beans among the raw
-	 * bean type matches (or {@link #UNFILTERED} for all raw type matches without
-	 * any default filtering)
-	 * @since 6.2.3
-	 * @see #orderedStream()
-	 * @see #stream(Predicate)
-	 */
-	default Stream<T> orderedStream(Predicate<Class<?>> customFilter) {
-		return orderedStream().filter(obj -> customFilter.test(obj.getClass()));
-	}
-
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -183,11 +183,7 @@ public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, Single
 	 * on the given registry, fresh for each bean creation attempt. This avoids
 	 * the need for synchronization on custom editors; hence, it is generally
 	 * preferable to use this method instead of {@link #registerCustomEditor}.
-	 * <p>If the given registrar implements
-	 * {@link PropertyEditorRegistrar#overridesDefaultEditors()} to return {@code true},
-	 * it will be applied lazily (only when default editors are actually needed).
 	 * @param registrar the PropertyEditorRegistrar to register
-	 * @see PropertyEditorRegistrar#overridesDefaultEditors()
 	 */
 	void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -137,9 +137,6 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	@Nullable
 	private ConversionService conversionService;
 
-	/** Default PropertyEditorRegistrars to apply to the beans of this factory. */
-	private final Set<PropertyEditorRegistrar> defaultEditorRegistrars = new LinkedHashSet<>(4);
-
 	/** Custom PropertyEditorRegistrars to apply to the beans of this factory. */
 	private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4);
 
@@ -886,12 +883,7 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	@Override
 	public void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar) {
 		Assert.notNull(registrar, "PropertyEditorRegistrar must not be null");
-		if (registrar.overridesDefaultEditors()) {
-			this.defaultEditorRegistrars.add(registrar);
-		}
-		else {
-			this.propertyEditorRegistrars.add(registrar);
-		}
+		this.propertyEditorRegistrars.add(registrar);
 	}
 
 	/**
@@ -1122,7 +1114,6 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 		setBeanExpressionResolver(otherFactory.getBeanExpressionResolver());
 		setConversionService(otherFactory.getConversionService());
 		if (otherFactory instanceof AbstractBeanFactory otherAbstractFactory) {
-			this.defaultEditorRegistrars.addAll(otherAbstractFactory.defaultEditorRegistrars);
 			this.propertyEditorRegistrars.addAll(otherAbstractFactory.propertyEditorRegistrars);
 			this.customEditors.putAll(otherAbstractFactory.customEditors);
 			this.typeConverter = otherAbstractFactory.typeConverter;
@@ -1322,18 +1313,29 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	protected void registerCustomEditors(PropertyEditorRegistry registry) {
 		if (registry instanceof PropertyEditorRegistrySupport registrySupport) {
 			registrySupport.useConfigValueEditors();
-			if (!this.defaultEditorRegistrars.isEmpty()) {
-				// Optimization: lazy overriding of default editors only when needed
-				registrySupport.setDefaultEditorRegistrar(new BeanFactoryDefaultEditorRegistrar());
-			}
 		}
-		else if (!this.defaultEditorRegistrars.isEmpty()) {
-			// Fallback: proactive overriding of default editors
-			applyEditorRegistrars(registry, this.defaultEditorRegistrars);
-		}
-
 		if (!this.propertyEditorRegistrars.isEmpty()) {
-			applyEditorRegistrars(registry, this.propertyEditorRegistrars);
+			for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {
+				try {
+					registrar.registerCustomEditors(registry);
+				}
+				catch (BeanCreationException ex) {
+					Throwable rootCause = ex.getMostSpecificCause();
+					if (rootCause instanceof BeanCurrentlyInCreationException bce) {
+						String bceBeanName = bce.getBeanName();
+						if (bceBeanName != null && isCurrentlyInCreation(bceBeanName)) {
+							if (logger.isDebugEnabled()) {
+								logger.debug("PropertyEditorRegistrar [" + registrar.getClass().getName() +
+										"] failed because it tried to obtain currently created bean '" +
+										ex.getBeanName() + "': " + ex.getMessage());
+							}
+							onSuppressedException(ex);
+							continue;
+						}
+					}
+					throw ex;
+				}
+			}
 		}
 		if (!this.customEditors.isEmpty()) {
 			this.customEditors.forEach((requiredType, editorClass) ->
@@ -1341,29 +1343,6 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 		}
 	}
 
-	private void applyEditorRegistrars(PropertyEditorRegistry registry, Set<PropertyEditorRegistrar> registrars) {
-		for (PropertyEditorRegistrar registrar : registrars) {
-			try {
-				registrar.registerCustomEditors(registry);
-			}
-			catch (BeanCreationException ex) {
-				Throwable rootCause = ex.getMostSpecificCause();
-				if (rootCause instanceof BeanCurrentlyInCreationException bce) {
-					String bceBeanName = bce.getBeanName();
-					if (bceBeanName != null && isCurrentlyInCreation(bceBeanName)) {
-						if (logger.isDebugEnabled()) {
-							logger.debug("PropertyEditorRegistrar [" + registrar.getClass().getName() +
-									"] failed because it tried to obtain currently created bean '" +
-									ex.getBeanName() + "': " + ex.getMessage());
-						}
-						onSuppressedException(ex);
-						return;
-					}
-				}
-				throw ex;
-			}
-		}
-	}
 
 	/**
 	 * Return a merged RootBeanDefinition, traversing the parent bean definition
@@ -2116,20 +2095,4 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 		final List<MergedBeanDefinitionPostProcessor> mergedDefinition = new ArrayList<>();
 	}
 
-
-	/**
-	 * {@link PropertyEditorRegistrar} that delegates to the bean factory's
-	 * default registrars, adding exception handling for circular reference
-	 * scenarios where an editor tries to refer back to the currently created bean.
-	 *
-	 * @since 6.2.3
-	 */
-	class BeanFactoryDefaultEditorRegistrar implements PropertyEditorRegistrar {
-
-		@Override
-		public void registerCustomEditors(PropertyEditorRegistry registry) {
-			applyEditorRegistrars(registry, defaultEditorRegistrars);
-		}
-	}
-
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -33,9 +33,7 @@ import java.util.Comparator;
 import java.util.Set;
 
 import org.springframework.beans.BeanMetadataElement;
-import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.ObjectFactory;
-import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.beans.factory.config.TypedStringValue;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -261,24 +259,6 @@ abstract class AutowireUtils {
 		return method.getReturnType();
 	}
 
-	/**
-	 * Check the autowire-candidate status for the specified bean.
-	 * @param beanFactory the bean factory
-	 * @param beanName the name of the bean to check
-	 * @return whether the specified bean qualifies as an autowire candidate
-	 * @since 6.2.3
-	 * @see org.springframework.beans.factory.config.BeanDefinition#isAutowireCandidate()
-	 */
-	public static boolean isAutowireCandidate(ConfigurableBeanFactory beanFactory, String beanName) {
-		try {
-			return beanFactory.getMergedBeanDefinition(beanName).isAutowireCandidate();
-		}
-		catch (NoSuchBeanDefinitionException ex) {
-			// A manually registered singleton instance not backed by a BeanDefinition.
-			return true;
-		}
-	}
-
 
 	/**
 	 * Reflective {@link InvocationHandler} for lazy access to the current target object.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -508,32 +508,6 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 				Stream<T> stream = matchingBeans.values().stream();
 				return stream.sorted(adaptOrderComparator(matchingBeans));
 			}
-			@SuppressWarnings("unchecked")
-			@Override
-			public Stream<T> stream(Predicate<Class<?>> customFilter) {
-				return Arrays.stream(getBeanNamesForTypedStream(requiredType, allowEagerInit))
-						.filter(name -> customFilter.test(getType(name)))
-						.map(name -> (T) getBean(name))
-						.filter(bean -> !(bean instanceof NullBean));
-			}
-			@SuppressWarnings("unchecked")
-			@Override
-			public Stream<T> orderedStream(Predicate<Class<?>> customFilter) {
-				String[] beanNames = getBeanNamesForTypedStream(requiredType, allowEagerInit);
-				if (beanNames.length == 0) {
-					return Stream.empty();
-				}
-				Map<String, T> matchingBeans = CollectionUtils.newLinkedHashMap(beanNames.length);
-				for (String beanName : beanNames) {
-					if (customFilter.test(getType(beanName))) {
-						Object beanInstance = getBean(beanName);
-						if (!(beanInstance instanceof NullBean)) {
-							matchingBeans.put(beanName, (T) beanInstance);
-						}
-					}
-				}
-				return matchingBeans.values().stream().sorted(adaptOrderComparator(matchingBeans));
-			}
 		};
 	}
 
@@ -1115,15 +1089,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 						"without bootstrap executor configured - falling back to mainline initialization");
 			}
 		}
-
 		if (!mbd.isLazyInit()) {
-			try {
-				instantiateSingleton(beanName);
-			}
-			catch (BeanCurrentlyInCreationException ex) {
-				logger.info("Bean '" + beanName + "' marked for pre-instantiation (not lazy-init) " +
-						"but currently initialized by other thread - skipping it in mainline thread");
-			}
+			instantiateSingleton(beanName);
 		}
 		return null;
 	}
@@ -1918,8 +1885,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 				candidates.put(candidateName, beanInstance);
 			}
 		}
-		else if (containsSingleton(candidateName) ||
-				(descriptor instanceof StreamDependencyDescriptor streamDescriptor && streamDescriptor.isOrdered())) {
+		else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor streamDescriptor &&
+				streamDescriptor.isOrdered())) {
 			Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
 			candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
 		}
@@ -2512,34 +2479,6 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 			Object result = doResolveDependency(descriptorToUse, this.beanName, null, null);
 			return (result instanceof Stream stream ? stream : Stream.of(result));
 		}
-
-		@Override
-		public Stream<Object> stream(Predicate<Class<?>> customFilter) {
-			return Arrays.stream(getBeanNamesForTypedStream(this.descriptor.getResolvableType(), true))
-					.filter(name -> AutowireUtils.isAutowireCandidate(DefaultListableBeanFactory.this, name))
-					.filter(name -> customFilter.test(getType(name)))
-					.map(name -> getBean(name))
-					.filter(bean -> !(bean instanceof NullBean));
-		}
-
-		@Override
-		public Stream<Object> orderedStream(Predicate<Class<?>> customFilter) {
-			String[] beanNames = getBeanNamesForTypedStream(this.descriptor.getResolvableType(), true);
-			if (beanNames.length == 0) {
-				return Stream.empty();
-			}
-			Map<String, Object> matchingBeans = CollectionUtils.newLinkedHashMap(beanNames.length);
-			for (String beanName : beanNames) {
-				if (AutowireUtils.isAutowireCandidate(DefaultListableBeanFactory.this, beanName) &&
-						customFilter.test(getType(beanName))) {
-					Object beanInstance = getBean(beanName);
-					if (!(beanInstance instanceof NullBean)) {
-						matchingBeans.put(beanName, beanInstance);
-					}
-				}
-			}
-			return matchingBeans.values().stream().sorted(adaptOrderComparator(matchingBeans));
-		}
 	}
 
 

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

@@ -24,7 +24,6 @@ import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
@@ -101,15 +100,6 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	/** Names of beans currently excluded from in creation checks. */
 	private final Set<String> inCreationCheckExclusions = ConcurrentHashMap.newKeySet(16);
 
-	/** Specific lock for lenient creation tracking. */
-	private final Lock lenientCreationLock = new ReentrantLock();
-
-	/** Specific lock condition for lenient creation tracking. */
-	private final Condition lenientCreationFinished = this.lenientCreationLock.newCondition();
-
-	/** Names of beans that are currently in lenient creation. */
-	private final Set<String> singletonsInLenientCreation = new HashSet<>();
-
 	/** Flag that indicates whether we're currently within destroySingletons. */
 	private volatile boolean singletonsCurrentlyInDestruction = false;
 
@@ -253,7 +243,6 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 		Boolean lockFlag = isCurrentThreadAllowedToHoldSingletonLock();
 		boolean acquireLock = !Boolean.FALSE.equals(lockFlag);
 		boolean locked = (acquireLock && this.singletonLock.tryLock());
-		boolean lenient = false;
 		try {
 			Object singletonObject = this.singletonObjects.get(beanName);
 			if (singletonObject == null) {
@@ -268,14 +257,6 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 									Thread.currentThread().getName() + "\" while other thread holds " +
 									"singleton lock for other beans " + this.singletonsCurrentlyInCreation);
 						}
-						lenient = true;
-						this.lenientCreationLock.lock();
-						try {
-							this.singletonsInLenientCreation.add(beanName);
-						}
-						finally {
-							this.lenientCreationLock.unlock();
-						}
 					}
 					else {
 						// No specific locking indication (outside a coordinated bootstrap) and
@@ -303,26 +284,6 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 					beforeSingletonCreation(beanName);
 				}
 				catch (BeanCurrentlyInCreationException ex) {
-					this.lenientCreationLock.lock();
-					try {
-						while ((singletonObject = this.singletonObjects.get(beanName)) == null) {
-							if (!this.singletonsInLenientCreation.contains(beanName)) {
-								break;
-							}
-							try {
-								this.lenientCreationFinished.await();
-							}
-							catch (InterruptedException ie) {
-								Thread.currentThread().interrupt();
-							}
-						}
-					}
-					finally {
-						this.lenientCreationLock.unlock();
-					}
-					if (singletonObject != null) {
-						return singletonObject;
-					}
 					if (locked) {
 						throw ex;
 					}
@@ -378,16 +339,6 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 			if (locked) {
 				this.singletonLock.unlock();
 			}
-			if (lenient) {
-				this.lenientCreationLock.lock();
-				try {
-					this.singletonsInLenientCreation.remove(beanName);
-					this.lenientCreationFinished.signalAll();
-				}
-				finally {
-					this.lenientCreationLock.unlock();
-				}
-			}
 		}
 	}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -16,13 +16,9 @@
 
 package org.springframework.beans.factory.support;
 
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.BeanFactoryUtils;
-import org.springframework.beans.factory.ListableBeanFactory;
-import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.config.DependencyDescriptor;
+import org.springframework.lang.Nullable;
 
 /**
  * {@link AutowireCandidateResolver} implementation to use when no annotation
@@ -40,6 +36,46 @@ public class SimpleAutowireCandidateResolver implements AutowireCandidateResolve
 	 */
 	public static final SimpleAutowireCandidateResolver INSTANCE = new SimpleAutowireCandidateResolver();
 
+
+	@Override
+	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
+		return bdHolder.getBeanDefinition().isAutowireCandidate();
+	}
+
+	@Override
+	public boolean isRequired(DependencyDescriptor descriptor) {
+		return descriptor.isRequired();
+	}
+
+	@Override
+	public boolean hasQualifier(DependencyDescriptor descriptor) {
+		return false;
+	}
+
+	@Override
+	@Nullable
+	public String getSuggestedName(DependencyDescriptor descriptor) {
+		return null;
+	}
+
+	@Override
+	@Nullable
+	public Object getSuggestedValue(DependencyDescriptor descriptor) {
+		return null;
+	}
+
+	@Override
+	@Nullable
+	public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
+		return null;
+	}
+
+	@Override
+	@Nullable
+	public Class<?> getLazyResolutionProxyClass(DependencyDescriptor descriptor, @Nullable String beanName) {
+		return null;
+	}
+
 	/**
 	 * This implementation returns {@code this} as-is.
 	 * @see #INSTANCE
@@ -49,31 +85,4 @@ public class SimpleAutowireCandidateResolver implements AutowireCandidateResolve
 		return this;
 	}
 
-
-	/**
-	 * Resolve a map of all beans of the given type, also picking up beans defined in
-	 * ancestor bean factories, with the specific condition that each bean actually
-	 * has autowire candidate status. This matches simple injection point resolution
-	 * as implemented by this {@link AutowireCandidateResolver} strategy, including
-	 * beans which are not marked as default candidates but excluding beans which
-	 * are not even marked as autowire candidates.
-	 * @param lbf the bean factory
-	 * @param type the type of bean to match
-	 * @return the Map of matching bean instances, or an empty Map if none
-	 * @throws BeansException if a bean could not be created
-	 * @since 6.2.3
-	 * @see BeanFactoryUtils#beansOfTypeIncludingAncestors(ListableBeanFactory, Class)
-	 * @see org.springframework.beans.factory.config.BeanDefinition#isAutowireCandidate()
-	 * @see AbstractBeanDefinition#isDefaultCandidate()
-	 */
-	public static <T> Map<String, T> resolveAutowireCandidates(ConfigurableListableBeanFactory lbf, Class<T> type) {
-		Map<String, T> candidates = new LinkedHashMap<>();
-		for (String beanName : BeanFactoryUtils.beanNamesForTypeIncludingAncestors(lbf, type)) {
-			if (AutowireUtils.isAutowireCandidate(lbf, beanName)) {
-				candidates.put(beanName, lbf.getBean(beanName, type));
-			}
-		}
-		return candidates;
-	}
-
 }

spring-beans/src/main/java/org/springframework/beans/support/ResourceEditorRegistrar.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -135,12 +135,4 @@ public class ResourceEditorRegistrar implements PropertyEditorRegistrar {
 		}
 	}
 
-	/**
-	 * Indicate the use of {@link PropertyEditorRegistrySupport#overrideDefaultEditor} above.
-	 */
-	@Override
-	public boolean overridesDefaultEditors() {
-		return true;
-	}
-
 }

spring-beans/src/test/java/org/springframework/beans/AbstractPropertyAccessorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -139,7 +139,6 @@ abstract class AbstractPropertyAccessorTests {
 		assertThat(accessor.isReadableProperty("list")).isTrue();
 		assertThat(accessor.isReadableProperty("set")).isTrue();
 		assertThat(accessor.isReadableProperty("map")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap")).isTrue();
 		assertThat(accessor.isReadableProperty("myTestBeans")).isTrue();
 		assertThat(accessor.isReadableProperty("xxx")).isFalse();
 
@@ -147,7 +146,6 @@ abstract class AbstractPropertyAccessorTests {
 		assertThat(accessor.isWritableProperty("list")).isTrue();
 		assertThat(accessor.isWritableProperty("set")).isTrue();
 		assertThat(accessor.isWritableProperty("map")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap")).isTrue();
 		assertThat(accessor.isWritableProperty("myTestBeans")).isTrue();
 		assertThat(accessor.isWritableProperty("xxx")).isFalse();
 
@@ -163,14 +161,6 @@ abstract class AbstractPropertyAccessorTests {
 		assertThat(accessor.isReadableProperty("map[key4][0].name")).isTrue();
 		assertThat(accessor.isReadableProperty("map[key4][1]")).isTrue();
 		assertThat(accessor.isReadableProperty("map[key4][1].name")).isTrue();
-		assertThat(accessor.isReadableProperty("map[key999]")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap[key1]")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap[key1].name")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap[key2][0]")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap[key2][0].name")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap[key2][1]")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap[key2][1].name")).isTrue();
-		assertThat(accessor.isReadableProperty("iterableMap[key999]")).isTrue();
 		assertThat(accessor.isReadableProperty("myTestBeans[0]")).isTrue();
 		assertThat(accessor.isReadableProperty("myTestBeans[1]")).isFalse();
 		assertThat(accessor.isReadableProperty("array[key1]")).isFalse();
@@ -187,14 +177,6 @@ abstract class AbstractPropertyAccessorTests {
 		assertThat(accessor.isWritableProperty("map[key4][0].name")).isTrue();
 		assertThat(accessor.isWritableProperty("map[key4][1]")).isTrue();
 		assertThat(accessor.isWritableProperty("map[key4][1].name")).isTrue();
-		assertThat(accessor.isWritableProperty("map[key999]")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap[key1]")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap[key1].name")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap[key2][0]")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap[key2][0].name")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap[key2][1]")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap[key2][1].name")).isTrue();
-		assertThat(accessor.isWritableProperty("iterableMap[key999]")).isTrue();
 		assertThat(accessor.isReadableProperty("myTestBeans[0]")).isTrue();
 		assertThat(accessor.isReadableProperty("myTestBeans[1]")).isFalse();
 		assertThat(accessor.isWritableProperty("array[key1]")).isFalse();
@@ -1413,9 +1395,6 @@ abstract class AbstractPropertyAccessorTests {
 		assertThat(accessor.getPropertyValue("map[key5[foo]].name")).isEqualTo("name8");
 		assertThat(accessor.getPropertyValue("map['key5[foo]'].name")).isEqualTo("name8");
 		assertThat(accessor.getPropertyValue("map[\"key5[foo]\"].name")).isEqualTo("name8");
-		assertThat(accessor.getPropertyValue("iterableMap[key1].name")).isEqualTo("nameC");
-		assertThat(accessor.getPropertyValue("iterableMap[key2][0].name")).isEqualTo("nameA");
-		assertThat(accessor.getPropertyValue("iterableMap[key2][1].name")).isEqualTo("nameB");
 		assertThat(accessor.getPropertyValue("myTestBeans[0].name")).isEqualTo("nameZ");
 
 		MutablePropertyValues pvs = new MutablePropertyValues();
@@ -1430,9 +1409,6 @@ abstract class AbstractPropertyAccessorTests {
 		pvs.add("map[key4][0].name", "nameA");
 		pvs.add("map[key4][1].name", "nameB");
 		pvs.add("map[key5[foo]].name", "name10");
-		pvs.add("iterableMap[key1].name", "newName1");
-		pvs.add("iterableMap[key2][0].name", "newName2A");
-		pvs.add("iterableMap[key2][1].name", "newName2B");
 		pvs.add("myTestBeans[0].name", "nameZZ");
 		accessor.setPropertyValues(pvs);
 		assertThat(tb0.getName()).isEqualTo("name5");
@@ -1452,9 +1428,6 @@ abstract class AbstractPropertyAccessorTests {
 		assertThat(accessor.getPropertyValue("map[key4][0].name")).isEqualTo("nameA");
 		assertThat(accessor.getPropertyValue("map[key4][1].name")).isEqualTo("nameB");
 		assertThat(accessor.getPropertyValue("map[key5[foo]].name")).isEqualTo("name10");
-		assertThat(accessor.getPropertyValue("iterableMap[key1].name")).isEqualTo("newName1");
-		assertThat(accessor.getPropertyValue("iterableMap[key2][0].name")).isEqualTo("newName2A");
-		assertThat(accessor.getPropertyValue("iterableMap[key2][1].name")).isEqualTo("newName2B");
 		assertThat(accessor.getPropertyValue("myTestBeans[0].name")).isEqualTo("nameZZ");
 	}
 

spring-beans/src/test/java/org/springframework/beans/BeanWrapperAutoGrowingTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -103,27 +103,6 @@ class BeanWrapperAutoGrowingTests {
 		assertThat(bean.getThreeDimensionalArray()[1][2][3]).isInstanceOf(Bean.class);
 	}
 
-	@Test
-	void getPropertyValueAutoGrow3dArrayList() {
-		assertThat(wrapper.getPropertyValue("threeDimensionalArrayList[1][2][3][4]")).isNotNull();
-		assertThat(bean.getThreeDimensionalArrayList()).hasSize(2);
-		assertThat(bean.getThreeDimensionalArrayList().get(1)).hasNumberOfRows(3);
-		assertThat(bean.getThreeDimensionalArrayList().get(1)[2]).hasNumberOfRows(4);
-		assertThat(bean.getThreeDimensionalArrayList().get(1)[2][3]).hasSize(5);
-		assertThat(bean.getThreeDimensionalArrayList().get(1)[2][3][4]).isInstanceOf(Bean.class);
-	}
-
-	@Test
-	void getPropertyValueAutoGrow3dArrayListForDefault3dArray() {
-		assertThat(wrapper.getPropertyValue("threeDimensionalArrayList[0]")).isNotNull();
-		assertThat(bean.getThreeDimensionalArrayList()).hasSize(1);
-
-		// Default 3-dimensional array should be [[[]]]
-		assertThat(bean.getThreeDimensionalArrayList().get(0)).hasNumberOfRows(1);
-		assertThat(bean.getThreeDimensionalArrayList().get(0)[0]).hasNumberOfRows(1);
-		assertThat(bean.getThreeDimensionalArrayList().get(0)[0][0]).isEmpty();
-	}
-
 	@Test
 	void setPropertyValueAutoGrow2dArray() {
 		Bean newBean = new Bean();
@@ -144,16 +123,6 @@ class BeanWrapperAutoGrowingTests {
 			.extracting(Bean::getProp).isEqualTo("enigma");
 	}
 
-	@Test
-	void setPropertyValueAutoGrow3dArrayList() {
-		Bean newBean = new Bean();
-		newBean.setProp("enigma");
-		wrapper.setPropertyValue("threeDimensionalArrayList[0][1][2][3]", newBean);
-		assertThat(bean.getThreeDimensionalArrayList().get(0)[1][2][3])
-				.isInstanceOf(Bean.class)
-				.extracting(Bean::getProp).isEqualTo("enigma");
-	}
-
 	@Test
 	void getPropertyValueAutoGrowList() {
 		assertThat(wrapper.getPropertyValue("list[0]")).isNotNull();
@@ -246,8 +215,6 @@ class BeanWrapperAutoGrowingTests {
 
 		private Bean[][][] threeDimensionalArray;
 
-		private List<Bean[][][]> threeDimensionalArrayList;
-
 		private List<Bean> list;
 
 		private List<List<Bean>> nestedList;
@@ -302,14 +269,6 @@ class BeanWrapperAutoGrowingTests {
 			this.threeDimensionalArray = threeDimensionalArray;
 		}
 
-		public List<Bean[][][]> getThreeDimensionalArrayList() {
-			return threeDimensionalArrayList;
-		}
-
-		public void setThreeDimensionalArrayList(List<Bean[][][]> threeDimensionalArrayList) {
-			this.threeDimensionalArrayList = threeDimensionalArrayList;
-		}
-
 		public List<Bean> getList() {
 			return list;
 		}

spring-beans/src/test/java/org/springframework/beans/factory/DefaultListableBeanFactoryTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -1515,16 +1515,12 @@ class DefaultListableBeanFactoryTests {
 		bd1.setAttribute(AbstractBeanDefinition.ORDER_ATTRIBUTE, Ordered.LOWEST_PRECEDENCE);
 		lbf.registerBeanDefinition("bean1", bd1);
 		GenericBeanDefinition bd2 = new GenericBeanDefinition();
-		bd2.setBeanClass(DerivedTestBean.class);
+		bd2.setBeanClass(TestBean.class);
 		bd2.setPropertyValues(new MutablePropertyValues(List.of(new PropertyValue("name", "highest"))));
 		bd2.setAttribute(AbstractBeanDefinition.ORDER_ATTRIBUTE, Ordered.HIGHEST_PRECEDENCE);
 		lbf.registerBeanDefinition("bean2", bd2);
 		assertThat(lbf.getBeanProvider(TestBean.class).orderedStream().map(TestBean::getName))
 				.containsExactly("highest", "lowest");
-		assertThat(lbf.getBeanProvider(TestBean.class).orderedStream(ObjectProvider.UNFILTERED).map(TestBean::getName))
-				.containsExactly("highest", "lowest");
-		assertThat(lbf.getBeanProvider(TestBean.class).orderedStream(clazz -> !DerivedTestBean.class.isAssignableFrom(clazz))
-				.map(TestBean::getName)).containsExactly("lowest");
 	}
 
 	@Test
@@ -1544,8 +1540,6 @@ class DefaultListableBeanFactoryTests {
 		lbf.registerBeanDefinition("bean2", bd2);
 		assertThat(lbf.getBeanProvider(TestBean.class).orderedStream().map(TestBean::getName))
 				.containsExactly("fromLowestPrecedenceTestBeanFactoryBean", "fromHighestPrecedenceTestBeanFactoryBean");
-		assertThat(lbf.getBeanProvider(TestBean.class).orderedStream(ObjectProvider.UNFILTERED).map(TestBean::getName))
-				.containsExactly("fromLowestPrecedenceTestBeanFactoryBean", "fromHighestPrecedenceTestBeanFactoryBean");
 	}
 
 	@Test
@@ -1940,11 +1934,6 @@ class DefaultListableBeanFactoryTests {
 		assertThat(resolved).hasSize(2);
 		assertThat(resolved).contains(lbf.getBean("bd1"));
 		assertThat(resolved).contains(lbf.getBean("bd2"));
-
-		resolved = provider.stream(ObjectProvider.UNFILTERED).collect(Collectors.toSet());
-		assertThat(resolved).hasSize(2);
-		assertThat(resolved).contains(lbf.getBean("bd1"));
-		assertThat(resolved).contains(lbf.getBean("bd2"));
 	}
 
 	@Test
@@ -1994,11 +1983,6 @@ class DefaultListableBeanFactoryTests {
 		assertThat(resolved).hasSize(2);
 		assertThat(resolved).contains(lbf.getBean("bd1"));
 		assertThat(resolved).contains(lbf.getBean("bd2"));
-
-		resolved = provider.stream(ObjectProvider.UNFILTERED).collect(Collectors.toSet());
-		assertThat(resolved).hasSize(2);
-		assertThat(resolved).contains(lbf.getBean("bd1"));
-		assertThat(resolved).contains(lbf.getBean("bd2"));
 	}
 
 	@Test
@@ -2394,20 +2378,11 @@ class DefaultListableBeanFactoryTests {
 		parentBf.registerBeanDefinition("highPriorityTestBean", bd2);
 
 		ObjectProvider<TestBean> testBeanProvider = lbf.getBeanProvider(ResolvableType.forClass(TestBean.class));
-		assertThat(testBeanProvider.orderedStream()).containsExactly(
+		List<TestBean> resolved = testBeanProvider.orderedStream().toList();
+		assertThat(resolved).containsExactly(
 				lbf.getBean("highPriorityTestBean", TestBean.class),
 				lbf.getBean("lowPriorityTestBean", TestBean.class),
 				lbf.getBean("plainTestBean", TestBean.class));
-		assertThat(testBeanProvider.orderedStream(clazz -> clazz != TestBean.class).toList()).containsExactly(
-				lbf.getBean("highPriorityTestBean", TestBean.class),
-				lbf.getBean("lowPriorityTestBean", TestBean.class));
-		assertThat(testBeanProvider.stream()).containsExactly(
-				lbf.getBean("plainTestBean", TestBean.class),
-				lbf.getBean("lowPriorityTestBean", TestBean.class),
-				lbf.getBean("highPriorityTestBean", TestBean.class));
-		assertThat(testBeanProvider.orderedStream(clazz -> clazz != TestBean.class).toList()).containsExactly(
-				lbf.getBean("lowPriorityTestBean", TestBean.class),
-				lbf.getBean("highPriorityTestBean", TestBean.class));
 	}
 
 	@Test

spring-beans/src/test/java/org/springframework/beans/factory/annotation/AutowiredAnnotationBeanPostProcessorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -48,7 +48,6 @@ import org.mockito.Mockito;
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.BeanNameAware;
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.beans.factory.FactoryBean;
@@ -65,8 +64,6 @@ import org.springframework.beans.factory.support.AutowireCandidateQualifier;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.support.GenericBeanDefinition;
 import org.springframework.beans.factory.support.RootBeanDefinition;
-import org.springframework.beans.factory.support.SimpleAutowireCandidateResolver;
-import org.springframework.beans.testfixture.beans.DerivedTestBean;
 import org.springframework.beans.testfixture.beans.ITestBean;
 import org.springframework.beans.testfixture.beans.IndexedTestBean;
 import org.springframework.beans.testfixture.beans.NestedTestBean;
@@ -1608,11 +1605,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(testBeans).containsExactly(bf.getBean("testBean1", TestBean.class), bf.getBean("testBean2", TestBean.class));
 		testBeans = bean.streamTestBeans();
 		assertThat(testBeans).containsExactly(bf.getBean("testBean1", TestBean.class), bf.getBean("testBean2", TestBean.class));
-		testBeans = bean.streamTestBeansInOrder();
-		assertThat(testBeans).containsExactly(bf.getBean("testBean1", TestBean.class), bf.getBean("testBean2", TestBean.class));
-		testBeans = bean.allTestBeans();
-		assertThat(testBeans).containsExactly(bf.getBean("testBean1", TestBean.class), bf.getBean("testBean2", TestBean.class));
-		testBeans = bean.allTestBeansInOrder();
+		testBeans = bean.sortedTestBeans();
 		assertThat(testBeans).containsExactly(bf.getBean("testBean1", TestBean.class), bf.getBean("testBean2", TestBean.class));
 	}
 
@@ -1639,13 +1632,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		testBeans = bean.streamTestBeans();
 		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans).contains(bf.getBean("testBean", TestBean.class));
-		testBeans = bean.streamTestBeansInOrder();
-		assertThat(testBeans).hasSize(1);
-		assertThat(testBeans).contains(bf.getBean("testBean", TestBean.class));
-		testBeans = bean.allTestBeans();
-		assertThat(testBeans).hasSize(1);
-		assertThat(testBeans).contains(bf.getBean("testBean", TestBean.class));
-		testBeans = bean.allTestBeansInOrder();
+		testBeans = bean.sortedTestBeans();
 		assertThat(testBeans).hasSize(1);
 		assertThat(testBeans).contains(bf.getBean("testBean", TestBean.class));
 	}
@@ -1669,11 +1656,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(testBeans).isEmpty();
 		testBeans = bean.streamTestBeans();
 		assertThat(testBeans).isEmpty();
-		testBeans = bean.streamTestBeansInOrder();
-		assertThat(testBeans).isEmpty();
-		testBeans = bean.allTestBeans();
-		assertThat(testBeans).isEmpty();
-		testBeans = bean.allTestBeansInOrder();
+		testBeans = bean.sortedTestBeans();
 		assertThat(testBeans).isEmpty();
 	}
 
@@ -1695,9 +1678,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.iterateTestBeans()).containsExactly(testBean1, testBean2);
 		assertThat(bean.forEachTestBeans()).containsExactly(testBean1, testBean2);
 		assertThat(bean.streamTestBeans()).containsExactly(testBean1, testBean2);
-		assertThat(bean.streamTestBeansInOrder()).containsExactly(testBean1, testBean2);
-		assertThat(bean.allTestBeans()).containsExactly(testBean1, testBean2);
-		assertThat(bean.allTestBeansInOrder()).containsExactly(testBean1, testBean2);
+		assertThat(bean.sortedTestBeans()).containsExactly(testBean1, testBean2);
 	}
 
 	@Test
@@ -1725,9 +1706,7 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.iterateTestBeans()).containsExactly(testBean1, testBean2);
 		assertThat(bean.forEachTestBeans()).containsExactly(testBean1, testBean2);
 		assertThat(bean.streamTestBeans()).containsExactly(testBean1, testBean2);
-		assertThat(bean.streamTestBeansInOrder()).containsExactly(testBean2, testBean1);
-		assertThat(bean.allTestBeans()).containsExactly(testBean1, testBean2);
-		assertThat(bean.allTestBeansInOrder()).containsExactly(testBean2, testBean1);
+		assertThat(bean.sortedTestBeans()).containsExactly(testBean2, testBean1);
 	}
 
 	@Test
@@ -1743,53 +1722,8 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		bf.registerBeanDefinition("testBean2", tb2);
 
 		ObjectProviderInjectionBean bean = bf.getBean("annotatedBean", ObjectProviderInjectionBean.class);
-		assertThat(bean.streamTestBeansInOrder()).containsExactly(bf.getBean("testBean2", TestBean.class),
+		assertThat(bean.sortedTestBeans()).containsExactly(bf.getBean("testBean2", TestBean.class),
 				bf.getBean("testBean1", TestBean.class));
-		assertThat(bean.allTestBeansInOrder()).containsExactly(bf.getBean("testBean2", TestBean.class),
-				bf.getBean("testBean1", TestBean.class));
-	}
-
-	@Test
-	void objectProviderInjectionWithNonCandidatesInStream() {
-		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(ObjectProviderInjectionBean.class));
-		RootBeanDefinition tb1 = new RootBeanDefinition(TestBeanFactory.class);
-		tb1.setFactoryMethodName("newTestBean1");
-		bf.registerBeanDefinition("testBean1", tb1);
-		RootBeanDefinition tb2 = new RootBeanDefinition(TestBeanFactory.class);
-		tb2.setFactoryMethodName("newTestBean2");
-		bf.registerBeanDefinition("testBean2", tb2);
-
-		DefaultListableBeanFactory parent = new DefaultListableBeanFactory();
-		RootBeanDefinition tb3 = new RootBeanDefinition(TestBean.class);
-		tb3.setAutowireCandidate(false);
-		tb3.setLazyInit(true);
-		parent.registerBeanDefinition("testBean3", tb3);
-		RootBeanDefinition tb4 = new RootBeanDefinition(DerivedTestBean.class);
-		tb4.setDefaultCandidate(false);
-		tb4.setLazyInit(true);
-		parent.registerBeanDefinition("testBean4", tb4);
-		bf.setParentBeanFactory(parent);
-
-		ObjectProviderInjectionBean bean = bf.getBean("annotatedBean", ObjectProviderInjectionBean.class);
-		assertThat(bean.streamTestBeans()).containsExactly(bf.getBean("testBean1", TestBean.class),
-				bf.getBean("testBean2", TestBean.class));
-		assertThat(bean.streamTestBeansInOrder()).containsExactly(bf.getBean("testBean2", TestBean.class),
-				bf.getBean("testBean1", TestBean.class));
-		assertThat(bf.containsSingleton("testBean3")).isFalse();
-		assertThat(bean.plainTestBeans()).containsExactly(bf.getBean("testBean1", TestBean.class),
-				bf.getBean("testBean2", TestBean.class));
-		assertThat(bean.plainTestBeansInOrder()).containsExactly(bf.getBean("testBean2", TestBean.class),
-				bf.getBean("testBean1", TestBean.class));
-		assertThat(bf.containsSingleton("testBean4")).isFalse();
-		assertThat(bean.allTestBeans()).containsExactly(bf.getBean("testBean1", TestBean.class),
-				bf.getBean("testBean2", TestBean.class), bf.getBean("testBean4", TestBean.class));
-		assertThat(bean.allTestBeansInOrder()).containsExactly(bf.getBean("testBean2", TestBean.class),
-				bf.getBean("testBean1", TestBean.class), bf.getBean("testBean4", TestBean.class));
-
-		Map<String, TestBean> typeMatches = BeanFactoryUtils.beansOfTypeIncludingAncestors(bf, TestBean.class);
-		assertThat(typeMatches.remove("testBean3")).isNotNull();
-		Map<String, TestBean> candidates = SimpleAutowireCandidateResolver.resolveAutowireCandidates(bf, TestBean.class);
-		assertThat(candidates).containsExactlyEntriesOf(candidates);
 	}
 
 	@Test
@@ -3370,25 +3304,9 @@ class AutowiredAnnotationBeanPostProcessorTests {
 			return this.testBean.stream().toList();
 		}
 
-		public List<TestBean> streamTestBeansInOrder() {
+		public List<TestBean> sortedTestBeans() {
 			return this.testBean.orderedStream().toList();
 		}
-
-		public List<TestBean> plainTestBeans() {
-			return this.testBean.stream(clazz -> !DerivedTestBean.class.isAssignableFrom(clazz)).toList();
-		}
-
-		public List<TestBean> plainTestBeansInOrder() {
-			return this.testBean.orderedStream(clazz -> !DerivedTestBean.class.isAssignableFrom(clazz)).toList();
-		}
-
-		public List<TestBean> allTestBeans() {
-			return this.testBean.stream(ObjectProvider.UNFILTERED).toList();
-		}
-
-		public List<TestBean> allTestBeansInOrder() {
-			return this.testBean.orderedStream(ObjectProvider.UNFILTERED).toList();
-		}
 	}
 
 

spring-beans/src/testFixtures/java/org/springframework/beans/testfixture/beans/IndexedTestBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -21,7 +21,6 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -50,8 +49,6 @@ public class IndexedTestBean {
 
 	private SortedMap sortedMap;
 
-	private IterableMap iterableMap;
-
 	private MyTestBeans myTestBeans;
 
 
@@ -76,9 +73,6 @@ public class IndexedTestBean {
 		TestBean tb6 = new TestBean("name6", 0);
 		TestBean tb7 = new TestBean("name7", 0);
 		TestBean tb8 = new TestBean("name8", 0);
-		TestBean tbA = new TestBean("nameA", 0);
-		TestBean tbB = new TestBean("nameB", 0);
-		TestBean tbC = new TestBean("nameC", 0);
 		TestBean tbX = new TestBean("nameX", 0);
 		TestBean tbY = new TestBean("nameY", 0);
 		TestBean tbZ = new TestBean("nameZ", 0);
@@ -94,12 +88,6 @@ public class IndexedTestBean {
 		this.map.put("key2", tb5);
 		this.map.put("key.3", tb5);
 		List list = new ArrayList();
-		list.add(tbA);
-		list.add(tbB);
-		this.iterableMap = new IterableMap<>();
-		this.iterableMap.put("key1", tbC);
-		this.iterableMap.put("key2", list);
-		list = new ArrayList();
 		list.add(tbX);
 		list.add(tbY);
 		this.map.put("key4", list);
@@ -164,14 +152,6 @@ public class IndexedTestBean {
 		this.sortedMap = sortedMap;
 	}
 
-	public IterableMap getIterableMap() {
-		return this.iterableMap;
-	}
-
-	public void setIterableMap(IterableMap iterableMap) {
-		this.iterableMap = iterableMap;
-	}
-
 	public MyTestBeans getMyTestBeans() {
 		return myTestBeans;
 	}
@@ -181,15 +161,6 @@ public class IndexedTestBean {
 	}
 
 
-	@SuppressWarnings("serial")
-	public static class IterableMap<K,V> extends LinkedHashMap<K,V> implements Iterable<V> {
-
-		@Override
-		public Iterator<V> iterator() {
-			return values().iterator();
-		}
-	}
-
 	public static class MyTestBeans implements Iterable<TestBean> {
 
 		private final Collection<TestBean> testBeans;

spring-context/src/main/java/org/springframework/context/annotation/AnnotationBeanNameGenerator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -17,7 +17,6 @@
 package org.springframework.context.annotation;
 
 import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
@@ -34,7 +33,6 @@ import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.BeanNameGenerator;
-import org.springframework.core.annotation.AliasFor;
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.core.annotation.MergedAnnotation.Adapt;
@@ -43,7 +41,6 @@ import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
-import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
 
 /**
@@ -150,26 +147,16 @@ public class AnnotationBeanNameGenerator implements BeanNameGenerator {
 				Set<String> metaAnnotationTypes = this.metaAnnotationTypesCache.computeIfAbsent(annotationType,
 						key -> getMetaAnnotationTypes(mergedAnnotation));
 				if (isStereotypeWithNameValue(annotationType, metaAnnotationTypes, attributes)) {
-					Object value = attributes.get(MergedAnnotation.VALUE);
+					Object value = attributes.get("value");
 					if (value instanceof String currentName && !currentName.isBlank()) {
 						if (conventionBasedStereotypeCheckCache.add(annotationType) &&
 								metaAnnotationTypes.contains(COMPONENT_ANNOTATION_CLASSNAME) && logger.isWarnEnabled()) {
-							if (hasExplicitlyAliasedValueAttribute(mergedAnnotation.getType())) {
-								logger.warn("""
-										Although the 'value' attribute in @%s declares @AliasFor for an attribute \
-										other than @Component's 'value' attribute, the value is still used as the \
-										@Component name based on convention. As of Spring Framework 7.0, such a \
-										'value' attribute will no longer be used as the @Component name."""
-											.formatted(annotationType));
-							}
-							else {
-								logger.warn("""
-										Support for convention-based @Component names is deprecated and will \
-										be removed in a future version of the framework. Please annotate the \
-										'value' attribute in @%s with @AliasFor(annotation=Component.class) \
-										to declare an explicit alias for @Component's 'value' attribute."""
-											.formatted(annotationType));
-							}
+							logger.warn("""
+									Support for convention-based stereotype names is deprecated and will \
+									be removed in a future version of the framework. Please annotate the \
+									'value' attribute in @%s with @AliasFor(annotation=Component.class) \
+									to declare an explicit alias for @Component's 'value' attribute."""
+										.formatted(annotationType));
 						}
 						if (beanName != null && !currentName.equals(beanName)) {
 							throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
@@ -237,7 +224,7 @@ public class AnnotationBeanNameGenerator implements BeanNameGenerator {
 				annotationType.equals("jakarta.inject.Named") ||
 				annotationType.equals("javax.inject.Named");
 
-		return (isStereotype && attributes.containsKey(MergedAnnotation.VALUE));
+		return (isStereotype && attributes.containsKey("value"));
 	}
 
 	/**
@@ -268,14 +255,4 @@ public class AnnotationBeanNameGenerator implements BeanNameGenerator {
 		return StringUtils.uncapitalizeAsProperty(shortClassName);
 	}
 
-	/**
-	 * Determine if the supplied annotation type declares a {@code value()} attribute
-	 * with an explicit alias configured via {@link AliasFor @AliasFor}.
-	 * @since 6.2.3
-	 */
-	private static boolean hasExplicitlyAliasedValueAttribute(Class<? extends Annotation> annotationType) {
-		Method valueAttribute = ReflectionUtils.findMethod(annotationType, MergedAnnotation.VALUE);
-		return (valueAttribute != null && valueAttribute.isAnnotationPresent(AliasFor.class));
-	}
-
 }

spring-context/src/main/java/org/springframework/context/annotation/ClassPathScanningCandidateComponentProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -565,10 +565,9 @@ public class ClassPathScanningCandidateComponentProvider implements EnvironmentC
 	}
 
 	/**
-	 * Determine whether the given bean definition qualifies as a candidate component.
-	 * <p>The default implementation checks whether the class is not dependent on an
-	 * enclosing class as well as whether the class is either concrete (and therefore
-	 * not an interface) or has {@link Lookup @Lookup} methods.
+	 * Determine whether the given bean definition qualifies as candidate.
+	 * <p>The default implementation checks whether the class is not an interface
+	 * and not dependent on an enclosing class.
 	 * <p>Can be overridden in subclasses.
 	 * @param beanDefinition the bean definition to check
 	 * @return whether the bean definition qualifies as a candidate component

spring-context/src/main/java/org/springframework/context/annotation/ConfigurationClassEnhancer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -109,16 +109,8 @@ class ConfigurationClassEnhancer {
 			}
 			return configClass;
 		}
-
 		try {
-			// Use original ClassLoader if config class not locally loaded in overriding class loader
-			if (classLoader instanceof SmartClassLoader smartClassLoader &&
-					classLoader != configClass.getClassLoader()) {
-				classLoader = smartClassLoader.getOriginalClassLoader();
-			}
-			Enhancer enhancer = newEnhancer(configClass, classLoader);
-			boolean classLoaderMismatch = (classLoader != null && classLoader != configClass.getClassLoader());
-			Class<?> enhancedClass = createClass(enhancer, classLoaderMismatch);
+			Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
 			if (logger.isTraceEnabled()) {
 				logger.trace(String.format("Successfully enhanced %s; enhanced class name is: %s",
 						configClass.getName(), enhancedClass.getName()));
@@ -137,9 +129,6 @@ class ConfigurationClassEnhancer {
 	 */
 	private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
 		Enhancer enhancer = new Enhancer();
-		if (classLoader != null) {
-			enhancer.setClassLoader(classLoader);
-		}
 		enhancer.setSuperclass(configSuperClass);
 		enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
 		enhancer.setUseFactory(false);
@@ -163,21 +152,8 @@ class ConfigurationClassEnhancer {
 	 * Uses enhancer to generate a subclass of superclass,
 	 * ensuring that callbacks are registered for the new subclass.
 	 */
-	private Class<?> createClass(Enhancer enhancer, boolean fallback) {
-		Class<?> subclass;
-		try {
-			subclass = enhancer.createClass();
-		}
-		catch (CodeGenerationException ex) {
-			if (!fallback) {
-				throw ex;
-			}
-			// Possibly a package-visible @Bean method declaration not accessible
-			// in the given ClassLoader -> retry with original ClassLoader
-			enhancer.setClassLoader(null);
-			subclass = enhancer.createClass();
-		}
-
+	private Class<?> createClass(Enhancer enhancer) {
+		Class<?> subclass = enhancer.createClass();
 		// Registering callbacks statically (as opposed to thread-local)
 		// is critical for usage in an OSGi environment (SPR-5932)...
 		Enhancer.registerStaticCallbacks(subclass, CALLBACKS);

spring-context/src/main/java/org/springframework/scheduling/support/QuartzCronField.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -317,16 +317,8 @@ final class QuartzCronField extends CronField {
 	private static TemporalAdjuster dayOfWeekInMonth(int ordinal, DayOfWeek dayOfWeek) {
 		TemporalAdjuster adjuster = TemporalAdjusters.dayOfWeekInMonth(ordinal, dayOfWeek);
 		return temporal -> {
-			// TemporalAdjusters can overflow to a different month
-			// in this case, attempt the same adjustment with the next/previous month
-			for (int i = 0; i < 12; i++) {
-				Temporal result = adjuster.adjustInto(temporal);
-				if (result.get(ChronoField.MONTH_OF_YEAR) == temporal.get(ChronoField.MONTH_OF_YEAR)) {
-					return rollbackToMidnight(temporal, result);
-				}
-				temporal = result;
-			}
-			return null;
+			Temporal result = adjuster.adjustInto(temporal);
+			return rollbackToMidnight(temporal, result);
 		};
 	}
 

spring-context/src/main/java/org/springframework/validation/DataBinder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -142,10 +142,6 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 	 */
 	protected static final Log logger = LogFactory.getLog(DataBinder.class);
 
-	/** Internal constant for constructor binding via "[]". */
-	private static final int NO_INDEX = -1;
-
-
 	@Nullable
 	private Object target;
 
@@ -968,7 +964,7 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 						value = createMap(paramPath, paramType, resolvableType, valueResolver);
 					}
 					else if (paramType.isArray()) {
-						value = createArray(paramPath, paramType, resolvableType, valueResolver);
+						value = createArray(paramPath, resolvableType, valueResolver);
 					}
 				}
 
@@ -985,9 +981,11 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 						}
 					}
 					catch (TypeMismatchException ex) {
+						ex.initPropertyName(paramPath);
 						args[i] = null;
 						failedParamNames.add(paramPath);
-						handleTypeMismatchException(ex, paramPath, paramType, value);
+						getBindingResult().recordFieldValue(paramPath, paramType, value);
+						getBindingErrorProcessor().processPropertyAccessException(ex, getBindingResult());
 					}
 				}
 			}
@@ -1050,8 +1048,9 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 		return false;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Nullable
-	private List<?> createList(
+	private <V> List<V> createList(
 			String paramPath, Class<?> paramType, ResolvableType type, ValueResolver valueResolver) {
 
 		ResolvableType elementType = type.getNested(2);
@@ -1059,23 +1058,18 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 		if (indexes == null) {
 			return null;
 		}
-
-		int lastIndex = Math.max(indexes.last(), 0);
-		int size = (lastIndex < this.autoGrowCollectionLimit ? lastIndex + 1 : 0);
-		List<?> list = (List<?>) CollectionFactory.createCollection(paramType, size);
+		int size = (indexes.last() < this.autoGrowCollectionLimit ? indexes.last() + 1 : 0);
+		List<V> list = (List<V>) CollectionFactory.createCollection(paramType, size);
 		for (int i = 0; i < size; i++) {
 			list.add(null);
 		}
-
 		for (int index : indexes) {
-			String indexedPath = paramPath + "[" + (index != NO_INDEX ? index : "") + "]";
-			list.set(Math.max(index, 0),
-					createIndexedValue(paramPath, paramType, elementType, indexedPath, valueResolver));
+			list.set(index, (V) createObject(elementType, paramPath + "[" + index + "].", valueResolver));
 		}
-
 		return list;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Nullable
 	private <V> Map<String, V> createMap(
 			String paramPath, Class<?> paramType, ResolvableType type, ValueResolver valueResolver) {
@@ -1086,44 +1080,34 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 			if (!name.startsWith(paramPath + "[")) {
 				continue;
 			}
-
 			int startIdx = paramPath.length() + 1;
 			int endIdx = name.indexOf(']', startIdx);
+			String nestedPath = ((name.length() > endIdx + 1) ? name.substring(0, endIdx + 2) : "");
 			boolean quoted = (endIdx - startIdx > 2 && name.charAt(startIdx) == '\'' && name.charAt(endIdx - 1) == '\'');
 			String key = (quoted ? name.substring(startIdx + 1, endIdx - 1) : name.substring(startIdx, endIdx));
-
 			if (map == null) {
 				map = CollectionFactory.createMap(paramType, 16);
 			}
-
-			String indexedPath = name.substring(0, endIdx + 1);
-			map.put(key, createIndexedValue(paramPath, paramType, elementType, indexedPath, valueResolver));
+			if (!map.containsKey(key)) {
+				map.put(key, (V) createObject(elementType, nestedPath, valueResolver));
+			}
 		}
-
 		return map;
 	}
 
 	@SuppressWarnings("unchecked")
 	@Nullable
-	private <V> V[] createArray(
-			String paramPath, Class<?> paramType, ResolvableType type, ValueResolver valueResolver) {
-
+	private <V> V[] createArray(String paramPath, ResolvableType type, ValueResolver valueResolver) {
 		ResolvableType elementType = type.getNested(2);
 		SortedSet<Integer> indexes = getIndexes(paramPath, valueResolver);
 		if (indexes == null) {
 			return null;
 		}
-
-		int lastIndex = Math.max(indexes.last(), 0);
-		int size = (lastIndex < this.autoGrowCollectionLimit ? lastIndex + 1: 0);
+		int size = (indexes.last() < this.autoGrowCollectionLimit ? indexes.last() + 1: 0);
 		V[] array = (V[]) Array.newInstance(elementType.resolve(), size);
-
 		for (int index : indexes) {
-			String indexedPath = paramPath + "[" + (index != NO_INDEX ? index : "") + "]";
-			array[Math.max(index, 0)] =
-					createIndexedValue(paramPath, paramType, elementType, indexedPath, valueResolver);
+			array[index] = (V) createObject(elementType, paramPath + "[" + index + "].", valueResolver);
 		}
-
 		return array;
 	}
 
@@ -1132,18 +1116,9 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 		SortedSet<Integer> indexes = null;
 		for (String name : valueResolver.getNames()) {
 			if (name.startsWith(paramPath + "[")) {
-				int index;
-				if (paramPath.length() + 2 == name.length()) {
-					if (!name.endsWith("[]")) {
-						continue;
-					}
-					index = NO_INDEX;
-				}
-				else {
-					int endIndex = name.indexOf(']', paramPath.length() + 2);
-					String indexValue = name.substring(paramPath.length() + 1, endIndex);
-					index = Integer.parseInt(indexValue);
-				}
+				int endIndex = name.indexOf(']', paramPath.length() + 1);
+				String rawIndex = name.substring(paramPath.length() + 1, endIndex);
+				int index = Integer.parseInt(rawIndex);
 				indexes = (indexes != null ? indexes : new TreeSet<>());
 				indexes.add(index);
 			}
@@ -1151,50 +1126,6 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 		return indexes;
 	}
 
-	@SuppressWarnings("unchecked")
-	@Nullable
-	private <V> V createIndexedValue(
-			String paramPath, Class<?> containerType, ResolvableType elementType,
-			String indexedPath, ValueResolver valueResolver) {
-
-		Object value = null;
-		Class<?> elementClass = elementType.resolve(Object.class);
-
-		if (List.class.isAssignableFrom(elementClass)) {
-			value = createList(indexedPath, elementClass, elementType, valueResolver);
-		}
-		else if (Map.class.isAssignableFrom(elementClass)) {
-			value = createMap(indexedPath, elementClass, elementType, valueResolver);
-		}
-		else if (elementClass.isArray()) {
-			value = createArray(indexedPath, elementClass, elementType, valueResolver);
-		}
-		else {
-			Object rawValue = valueResolver.resolveValue(indexedPath, elementClass);
-			if (rawValue != null) {
-				try {
-					value = convertIfNecessary(rawValue, elementClass);
-				}
-				catch (TypeMismatchException ex) {
-					handleTypeMismatchException(ex, paramPath, containerType, rawValue);
-				}
-			}
-			else {
-				value = createObject(elementType, indexedPath + ".", valueResolver);
-			}
-		}
-
-		return (V) value;
-	}
-
-	private void handleTypeMismatchException(
-			TypeMismatchException ex, String paramPath, Class<?> paramType, @Nullable Object value) {
-
-		ex.initPropertyName(paramPath);
-		getBindingResult().recordFieldValue(paramPath, paramType, value);
-		getBindingErrorProcessor().processPropertyAccessException(ex, getBindingResult());
-	}
-
 	private void validateConstructorArgument(
 			Class<?> constructorClass, String nestedPath, String name, @Nullable Object value) {
 
@@ -1481,9 +1412,6 @@ public class DataBinder implements PropertyEditorRegistry, TypeConverter {
 
 		/**
 		 * Return the names of all property values.
-		 * <p>Useful for proactive checks whether there are property values nested
-		 * further below the path for a constructor arg. If not then the
-		 * constructor arg can be considered missing and not to be instantiated.
 		 * @since 6.1.2
 		 */
 		Set<String> getNames();

spring-context/src/test/java/org/springframework/aop/framework/CglibProxyTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -422,7 +422,6 @@ class CglibProxyTests extends AbstractAopProxyTests {
 	}
 
 	@Test  // SPR-13328
-	@SuppressWarnings("unchecked")
 	void varargsWithEnumArray() {
 		ProxyFactory proxyFactory = new ProxyFactory(new MyBean());
 		MyBean proxy = (MyBean) proxyFactory.getProxy();

spring-context/src/test/java/org/springframework/aop/framework/JdkDynamicProxyTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -141,7 +141,6 @@ class JdkDynamicProxyTests extends AbstractAopProxyTests {
 	}
 
 	@Test  // SPR-13328
-	@SuppressWarnings("unchecked")
 	void varargsWithEnumArray() {
 		ProxyFactory proxyFactory = new ProxyFactory(new VarargTestBean());
 		VarargTestInterface proxy = (VarargTestInterface) proxyFactory.getProxy();

spring-context/src/test/java/org/springframework/context/annotation/AnnotationBeanNameGeneratorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -168,25 +168,6 @@ class AnnotationBeanNameGeneratorTests {
 		assertGeneratedName(RestControllerAdviceClass.class, "myRestControllerAdvice");
 	}
 
-	@Test  // gh-34317
-	void generateBeanNameFromStereotypeAnnotationWithStringValueAsExplicitAliasForMetaAnnotationOtherThanComponent() {
-		// As of Spring Framework 6.2, "enigma" is incorrectly used as the @Component name.
-		// As of Spring Framework 7.0, the generated name will be "annotationBeanNameGeneratorTests.StereotypeWithoutExplicitName".
-		assertGeneratedName(StereotypeWithoutExplicitName.class, "enigma");
-	}
-
-	@Test  // gh-34317
-	void generateBeanNameFromStereotypeAnnotationWithStringValueAndExplicitAliasForComponentNameWithBlankName() {
-		// As of Spring Framework 6.2, "enigma" is incorrectly used as the @Component name.
-		// As of Spring Framework 7.0, the generated name will be "annotationBeanNameGeneratorTests.StereotypeWithGeneratedName".
-		assertGeneratedName(StereotypeWithGeneratedName.class, "enigma");
-	}
-
-	@Test  // gh-34317
-	void generateBeanNameFromStereotypeAnnotationWithStringValueAndExplicitAliasForComponentName() {
-		assertGeneratedName(StereotypeWithExplicitName.class, "explicitName");
-	}
-
 
 	private void assertGeneratedName(Class<?> clazz, String expectedName) {
 		BeanDefinition bd = annotatedBeanDef(clazz);
@@ -229,7 +210,7 @@ class AnnotationBeanNameGeneratorTests {
 	@Retention(RetentionPolicy.RUNTIME)
 	@Component
 	@interface ConventionBasedComponent1 {
-		// This is intentionally convention-based. Please do not add @AliasFor.
+		// This intentionally convention-based. Please do not add @AliasFor.
 		// See gh-31093.
 		String value() default "";
 	}
@@ -237,7 +218,7 @@ class AnnotationBeanNameGeneratorTests {
 	@Retention(RetentionPolicy.RUNTIME)
 	@Component
 	@interface ConventionBasedComponent2 {
-		// This is intentionally convention-based. Please do not add @AliasFor.
+		// This intentionally convention-based. Please do not add @AliasFor.
 		// See gh-31093.
 		String value() default "";
 	}
@@ -279,7 +260,7 @@ class AnnotationBeanNameGeneratorTests {
 	@Target(ElementType.TYPE)
 	@Controller
 	@interface TestRestController {
-		// This is intentionally convention-based. Please do not add @AliasFor.
+		// This intentionally convention-based. Please do not add @AliasFor.
 		// See gh-31093.
 		String value() default "";
 	}
@@ -338,6 +319,7 @@ class AnnotationBeanNameGeneratorTests {
 		String[] basePackages() default {};
 	}
 
+
 	@TestControllerAdvice(basePackages = "com.example", name = "myControllerAdvice")
 	static class ControllerAdviceClass {
 	}
@@ -346,56 +328,4 @@ class AnnotationBeanNameGeneratorTests {
 	static class RestControllerAdviceClass {
 	}
 
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.ANNOTATION_TYPE)
-	@interface MetaAnnotationWithStringAttribute {
-
-		String attribute() default "";
-	}
-
-	/**
-	 * Custom stereotype annotation which has a {@code String value} attribute that
-	 * is explicitly declared as an alias for an attribute in a meta-annotation
-	 * other than {@link Component @Component}.
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.TYPE)
-	@Component
-	@MetaAnnotationWithStringAttribute
-	@interface MyStereotype {
-
-		@AliasFor(annotation = MetaAnnotationWithStringAttribute.class, attribute = "attribute")
-		String value() default "";
-	}
-
-	@MyStereotype("enigma")
-	static class StereotypeWithoutExplicitName {
-	}
-
-	/**
-	 * Custom stereotype annotation which is identical to {@link MyStereotype @MyStereotype}
-	 * except that it has a {@link #name} attribute that is an explicit alias for
-	 * {@link Component#value}.
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.TYPE)
-	@Component
-	@MetaAnnotationWithStringAttribute
-	@interface MyNamedStereotype {
-
-		@AliasFor(annotation = MetaAnnotationWithStringAttribute.class, attribute = "attribute")
-		String value() default "";
-
-		@AliasFor(annotation = Component.class, attribute = "value")
-		String name() default "";
-	}
-
-	@MyNamedStereotype(value = "enigma", name ="explicitName")
-	static class StereotypeWithExplicitName {
-	}
-
-	@MyNamedStereotype(value = "enigma")
-	static class StereotypeWithGeneratedName {
-	}
-
 }

spring-context/src/test/java/org/springframework/context/annotation/BackgroundBootstrapTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -19,7 +19,6 @@ package org.springframework.context.annotation;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
-import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.beans.testfixture.beans.TestBean;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.testfixture.EnabledForTestGroups;
@@ -34,28 +33,6 @@ import static org.springframework.core.testfixture.TestGroup.LONG_RUNNING;
  */
 class BackgroundBootstrapTests {
 
-	@Test
-	@Timeout(5)
-	@EnabledForTestGroups(LONG_RUNNING)
-	void bootstrapWithUnmanagedThread() {
-		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(UnmanagedThreadBeanConfig.class);
-		ctx.getBean("testBean1", TestBean.class);
-		ctx.getBean("testBean2", TestBean.class);
-		ctx.close();
-	}
-
-	@Test
-	@Timeout(5)
-	@EnabledForTestGroups(LONG_RUNNING)
-	void bootstrapWithUnmanagedThreads() {
-		ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(UnmanagedThreadsBeanConfig.class);
-		ctx.getBean("testBean1", TestBean.class);
-		ctx.getBean("testBean2", TestBean.class);
-		ctx.getBean("testBean3", TestBean.class);
-		ctx.getBean("testBean4", TestBean.class);
-		ctx.close();
-	}
-
 	@Test
 	@Timeout(5)
 	@EnabledForTestGroups(LONG_RUNNING)
@@ -64,81 +41,11 @@ class BackgroundBootstrapTests {
 		ctx.getBean("testBean1", TestBean.class);
 		ctx.getBean("testBean2", TestBean.class);
 		ctx.getBean("testBean3", TestBean.class);
-		ctx.getBean("testBean4", TestBean.class);
 		ctx.close();
 	}
 
 
-	@Configuration(proxyBeanMethods = false)
-	static class UnmanagedThreadBeanConfig {
-
-		@Bean
-		public TestBean testBean1(ObjectProvider<TestBean> testBean2) {
-			new Thread(testBean2::getObject).start();
-			try {
-				Thread.sleep(1000);
-			}
-			catch (InterruptedException ex) {
-				throw new RuntimeException(ex);
-			}
-			return new TestBean();
-		}
-
-		@Bean
-		public TestBean testBean2() {
-			try {
-				Thread.sleep(2000);
-			}
-			catch (InterruptedException ex) {
-				throw new RuntimeException(ex);
-			}
-			return new TestBean();
-		}
-	}
-
-
-	@Configuration(proxyBeanMethods = false)
-	static class UnmanagedThreadsBeanConfig {
-
-		@Bean
-		public TestBean testBean1(ObjectProvider<TestBean> testBean3, ObjectProvider<TestBean> testBean4) {
-			new Thread(testBean3::getObject).start();
-			new Thread(testBean4::getObject).start();
-			new Thread(testBean3::getObject).start();
-			new Thread(testBean4::getObject).start();
-			try {
-				Thread.sleep(1000);
-			}
-			catch (InterruptedException ex) {
-				throw new RuntimeException(ex);
-			}
-			return new TestBean();
-		}
-
-		@Bean
-		public TestBean testBean2(TestBean testBean4) {
-			return new TestBean(testBean4);
-		}
-
-		@Bean
-		public TestBean testBean3(TestBean testBean4) {
-			return new TestBean(testBean4);
-		}
-
-		@Bean
-		public TestBean testBean4() {
-			try {
-				Thread.sleep(2000);
-			}
-			catch (InterruptedException ex) {
-				throw new RuntimeException(ex);
-			}
-			return new TestBean();
-		}
-	}
-
-
-	@Configuration(proxyBeanMethods = false)
+	@Configuration
 	static class CustomExecutorBeanConfig {
 
 		@Bean
@@ -151,7 +58,7 @@ class BackgroundBootstrapTests {
 		}
 
 		@Bean(bootstrap = BACKGROUND) @DependsOn("testBean3")
-		public TestBean testBean1(TestBean testBean3) throws InterruptedException {
+		public TestBean testBean1(TestBean testBean3) throws InterruptedException{
 			Thread.sleep(3000);
 			return new TestBean();
 		}
@@ -168,8 +75,8 @@ class BackgroundBootstrapTests {
 		}
 
 		@Bean
-		public TestBean testBean4(@Lazy TestBean testBean1, @Lazy TestBean testBean2, @Lazy TestBean testBean3) {
-			return new TestBean();
+		public String dependent(@Lazy TestBean testBean1, @Lazy TestBean testBean2, @Lazy TestBean testBean3) {
+			return "";
 		}
 	}
 

spring-context/src/test/java/org/springframework/context/annotation/ConfigurationClassEnhancerTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -18,16 +18,11 @@ package org.springframework.context.annotation;
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.security.ProtectionDomain;
 import java.security.SecureClassLoader;
 
 import org.junit.jupiter.api.Test;
 
-import org.springframework.core.OverridingClassLoader;
 import org.springframework.core.SmartClassLoader;
-import org.springframework.lang.Nullable;
 import org.springframework.util.StreamUtils;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -41,108 +36,19 @@ class ConfigurationClassEnhancerTests {
 	@Test
 	void enhanceReloadedClass() throws Exception {
 		ConfigurationClassEnhancer configurationClassEnhancer = new ConfigurationClassEnhancer();
-
 		ClassLoader parentClassLoader = getClass().getClassLoader();
-		ClassLoader classLoader = new CustomSmartClassLoader(parentClassLoader);
+		CustomClassLoader classLoader = new CustomClassLoader(parentClassLoader);
 		Class<?> myClass = parentClassLoader.loadClass(MyConfig.class.getName());
-		Class<?> enhancedClass = configurationClassEnhancer.enhance(myClass, parentClassLoader);
-		assertThat(myClass).isAssignableFrom(enhancedClass);
-
-		myClass = classLoader.loadClass(MyConfig.class.getName());
-		enhancedClass = configurationClassEnhancer.enhance(myClass, classLoader);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader);
-		assertThat(myClass).isAssignableFrom(enhancedClass);
-	}
-
-	@Test
-	void withPublicClass() {
-		ConfigurationClassEnhancer configurationClassEnhancer = new ConfigurationClassEnhancer();
-
-		ClassLoader classLoader = new URLClassLoader(new URL[0], getClass().getClassLoader());
-		Class<?> enhancedClass = configurationClassEnhancer.enhance(MyConfigWithPublicClass.class, classLoader);
-		assertThat(MyConfigWithPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader);
-
-		classLoader = new OverridingClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithPublicClass.class, classLoader);
-		assertThat(MyConfigWithPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-
-		classLoader = new CustomSmartClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithPublicClass.class, classLoader);
-		assertThat(MyConfigWithPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-
-		classLoader = new BasicSmartClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithPublicClass.class, classLoader);
-		assertThat(MyConfigWithPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-	}
-
-	@Test
-	void withNonPublicClass() {
-		ConfigurationClassEnhancer configurationClassEnhancer = new ConfigurationClassEnhancer();
-
-		ClassLoader classLoader = new URLClassLoader(new URL[0], getClass().getClassLoader());
-		Class<?> enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicClass.class, classLoader);
-		assertThat(MyConfigWithNonPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-
-		classLoader = new OverridingClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicClass.class, classLoader);
-		assertThat(MyConfigWithNonPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-
-		classLoader = new CustomSmartClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicClass.class, classLoader);
-		assertThat(MyConfigWithNonPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-
-		classLoader = new BasicSmartClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicClass.class, classLoader);
-		assertThat(MyConfigWithNonPublicClass.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-	}
-
-	@Test
-	void withNonPublicMethod() {
-		ConfigurationClassEnhancer configurationClassEnhancer = new ConfigurationClassEnhancer();
-
-		ClassLoader classLoader = new URLClassLoader(new URL[0], getClass().getClassLoader());
-		Class<?> enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicMethod.class, classLoader);
-		assertThat(MyConfigWithNonPublicMethod.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader);
-
-		classLoader = new OverridingClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicMethod.class, classLoader);
-		assertThat(MyConfigWithNonPublicMethod.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-
-		classLoader = new CustomSmartClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicMethod.class, classLoader);
-		assertThat(MyConfigWithNonPublicMethod.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
-
-		classLoader = new BasicSmartClassLoader(getClass().getClassLoader());
-		enhancedClass = configurationClassEnhancer.enhance(MyConfigWithNonPublicMethod.class, classLoader);
-		assertThat(MyConfigWithNonPublicMethod.class).isAssignableFrom(enhancedClass);
-		assertThat(enhancedClass.getClassLoader()).isEqualTo(classLoader.getParent());
+		configurationClassEnhancer.enhance(myClass, parentClassLoader);
+		Class<?> myReloadedClass = classLoader.loadClass(MyConfig.class.getName());
+		Class<?> enhancedReloadedClass = configurationClassEnhancer.enhance(myReloadedClass, classLoader);
+		assertThat(enhancedReloadedClass.getClassLoader()).isEqualTo(classLoader);
 	}
 
 
 	@Configuration
 	static class MyConfig {
 
-		@Bean
-		String myBean() {
-			return "bean";
-		}
-	}
-
-
-	@Configuration
-	public static class MyConfigWithPublicClass {
-
 		@Bean
 		public String myBean() {
 			return "bean";
@@ -150,29 +56,9 @@ class ConfigurationClassEnhancerTests {
 	}
 
 
-	@Configuration
-	static class MyConfigWithNonPublicClass {
+	static class CustomClassLoader extends SecureClassLoader implements SmartClassLoader {
 
-		@Bean
-		public String myBean() {
-			return "bean";
-		}
-	}
-
-
-	@Configuration
-	public static class MyConfigWithNonPublicMethod {
-
-		@Bean
-		String myBean() {
-			return "bean";
-		}
-	}
-
-
-	static class CustomSmartClassLoader extends SecureClassLoader implements SmartClassLoader {
-
-		CustomSmartClassLoader(ClassLoader parent) {
+		CustomClassLoader(ClassLoader parent) {
 			super(parent);
 		}
 
@@ -196,29 +82,6 @@ class ConfigurationClassEnhancerTests {
 		public boolean isClassReloadable(Class<?> clazz) {
 			return clazz.getName().contains("MyConfig");
 		}
-
-		@Override
-		public ClassLoader getOriginalClassLoader() {
-			return getParent();
-		}
-
-		@Override
-		public Class<?> publicDefineClass(String name, byte[] b, @Nullable ProtectionDomain protectionDomain) {
-			return defineClass(name, b, 0, b.length, protectionDomain);
-		}
-	}
-
-
-	static class BasicSmartClassLoader extends SecureClassLoader implements SmartClassLoader {
-
-		BasicSmartClassLoader(ClassLoader parent) {
-			super(parent);
-		}
-
-		@Override
-		public Class<?> publicDefineClass(String name, byte[] b, @Nullable ProtectionDomain protectionDomain) {
-			return defineClass(name, b, 0, b.length, protectionDomain);
-		}
 	}
 
 }

spring-context/src/test/java/org/springframework/scheduling/concurrent/AbstractSchedulingTaskExecutorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -125,7 +125,7 @@ abstract class AbstractSchedulingTaskExecutorTests {
 	}
 
 	@Test
-	@SuppressWarnings({ "removal", "deprecation" })
+	@SuppressWarnings("removal")
 	void submitListenableRunnable() {
 		TestTask task = new TestTask(this.testName, 1);
 		// Act
@@ -156,7 +156,7 @@ abstract class AbstractSchedulingTaskExecutorTests {
 	}
 
 	@Test
-	@SuppressWarnings({ "removal", "deprecation" })
+	@SuppressWarnings("removal")
 	void submitFailingListenableRunnable() {
 		TestTask task = new TestTask(this.testName, 0);
 		org.springframework.util.concurrent.ListenableFuture<?> future = executor.submitListenable(task);
@@ -185,7 +185,7 @@ abstract class AbstractSchedulingTaskExecutorTests {
 	}
 
 	@Test
-	@SuppressWarnings({ "removal", "deprecation" })
+	@SuppressWarnings("removal")
 	void submitListenableRunnableWithGetAfterShutdown() throws Exception {
 		org.springframework.util.concurrent.ListenableFuture<?> future1 = executor.submitListenable(new TestTask(this.testName, -1));
 		org.springframework.util.concurrent.ListenableFuture<?> future2 = executor.submitListenable(new TestTask(this.testName, -1));
@@ -252,7 +252,7 @@ abstract class AbstractSchedulingTaskExecutorTests {
 	}
 
 	@Test
-	@SuppressWarnings({ "removal", "deprecation" })
+	@SuppressWarnings("removal")
 	void submitListenableCallable() {
 		TestCallable task = new TestCallable(this.testName, 1);
 		// Act
@@ -267,7 +267,7 @@ abstract class AbstractSchedulingTaskExecutorTests {
 	}
 
 	@Test
-	@SuppressWarnings({ "removal", "deprecation" })
+	@SuppressWarnings("removal")
 	void submitFailingListenableCallable() {
 		TestCallable task = new TestCallable(this.testName, 0);
 		// Act
@@ -283,7 +283,7 @@ abstract class AbstractSchedulingTaskExecutorTests {
 	}
 
 	@Test
-	@SuppressWarnings({ "removal", "deprecation" })
+	@SuppressWarnings("removal")
 	void submitListenableCallableWithGetAfterShutdown() throws Exception {
 		org.springframework.util.concurrent.ListenableFuture<?> future1 = executor.submitListenable(new TestCallable(this.testName, -1));
 		org.springframework.util.concurrent.ListenableFuture<?> future2 = executor.submitListenable(new TestCallable(this.testName, -1));

spring-context/src/test/java/org/springframework/scheduling/support/CronExpressionTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -39,7 +39,6 @@ import static java.time.temporal.TemporalAdjusters.next;
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Tests for {@link CronExpression}.
  * @author Arjen Poutsma
  */
 class CronExpressionTests {
@@ -1093,20 +1092,6 @@ class CronExpressionTests {
 		assertThat(actual.getDayOfWeek()).isEqualTo(FRIDAY);
 	}
 
-	@Test
-	void quartz5thMondayOfTheMonthDayName() {
-		CronExpression expression = CronExpression.parse("0 0 0 ? * MON#5");
-
-		LocalDateTime last = LocalDateTime.of(2025, 1, 1, 0, 0, 0);
-
-		// first occurrence of 5 mondays in a month from last
-		LocalDateTime expected = LocalDateTime.of(2025, 3, 31, 0, 0, 0);
-		LocalDateTime actual = expression.next(last);
-		assertThat(actual).isNotNull();
-		assertThat(actual).isEqualTo(expected);
-		assertThat(actual.getDayOfWeek()).isEqualTo(MONDAY);
-	}
-
 	@Test
 	void quartzFifthWednesdayOfTheMonth() {
 		CronExpression expression = CronExpression.parse("0 0 0 ? * 3#5");

spring-context/src/test/java/org/springframework/validation/DataBinderConstructTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -103,17 +103,17 @@ class DataBinderConstructTests {
 	}
 
 	@Test
-	void dataClassWithListBinding() {
+	void listBinding() {
 		MapValueResolver valueResolver = new MapValueResolver(Map.of(
 				"dataClassList[0].param1", "value1", "dataClassList[0].param2", "true",
 				"dataClassList[1].param1", "value2", "dataClassList[1].param2", "true",
 				"dataClassList[2].param1", "value3", "dataClassList[2].param2", "true"));
 
-		DataBinder binder = initDataBinder(DataClassListRecord.class);
+		DataBinder binder = initDataBinder(ListDataClass.class);
 		binder.construct(valueResolver);
 
-		DataClassListRecord target = getTarget(binder);
-		List<DataClass> list = target.dataClassList();
+		ListDataClass dataClass = getTarget(binder);
+		List<DataClass> list = dataClass.dataClassList();
 
 		assertThat(list).hasSize(3);
 		assertThat(list.get(0).param1()).isEqualTo("value1");
@@ -122,17 +122,17 @@ class DataBinderConstructTests {
 	}
 
 	@Test // gh-34145
-	void dataClassWithListBindingWithNonconsecutiveIndices() {
+	void listBindingWithNonconsecutiveIndices() {
 		MapValueResolver valueResolver = new MapValueResolver(Map.of(
 				"dataClassList[0].param1", "value1", "dataClassList[0].param2", "true",
 				"dataClassList[1].param1", "value2", "dataClassList[1].param2", "true",
 				"dataClassList[3].param1", "value3", "dataClassList[3].param2", "true"));
 
-		DataBinder binder = initDataBinder(DataClassListRecord.class);
+		DataBinder binder = initDataBinder(ListDataClass.class);
 		binder.construct(valueResolver);
 
-		DataClassListRecord target = getTarget(binder);
-		List<DataClass> list = target.dataClassList();
+		ListDataClass dataClass = getTarget(binder);
+		List<DataClass> list = dataClass.dataClassList();
 
 		assertThat(list.get(0).param1()).isEqualTo("value1");
 		assertThat(list.get(1).param1()).isEqualTo("value2");
@@ -140,17 +140,17 @@ class DataBinderConstructTests {
 	}
 
 	@Test
-	void dataClassWithMapBinding() {
+	void mapBinding() {
 		MapValueResolver valueResolver = new MapValueResolver(Map.of(
 				"dataClassMap[a].param1", "value1", "dataClassMap[a].param2", "true",
 				"dataClassMap[b].param1", "value2", "dataClassMap[b].param2", "true",
 				"dataClassMap['c'].param1", "value3", "dataClassMap['c'].param2", "true"));
 
-		DataBinder binder = initDataBinder(DataClassMapRecord.class);
+		DataBinder binder = initDataBinder(MapDataClass.class);
 		binder.construct(valueResolver);
 
-		DataClassMapRecord target = getTarget(binder);
-		Map<String, DataClass> map = target.dataClassMap();
+		MapDataClass dataClass = getTarget(binder);
+		Map<String, DataClass> map = dataClass.dataClassMap();
 
 		assertThat(map).hasSize(3);
 		assertThat(map.get("a").param1()).isEqualTo("value1");
@@ -159,17 +159,17 @@ class DataBinderConstructTests {
 	}
 
 	@Test
-	void dataClassWithArrayBinding() {
+	void arrayBinding() {
 		MapValueResolver valueResolver = new MapValueResolver(Map.of(
 				"dataClassArray[0].param1", "value1", "dataClassArray[0].param2", "true",
 				"dataClassArray[1].param1", "value2", "dataClassArray[1].param2", "true",
 				"dataClassArray[2].param1", "value3", "dataClassArray[2].param2", "true"));
 
-		DataBinder binder = initDataBinder(DataClassArrayRecord.class);
+		DataBinder binder = initDataBinder(ArrayDataClass.class);
 		binder.construct(valueResolver);
 
-		DataClassArrayRecord target = getTarget(binder);
-		DataClass[] array = target.dataClassArray();
+		ArrayDataClass dataClass = getTarget(binder);
+		DataClass[] array = dataClass.dataClassArray();
 
 		assertThat(array).hasSize(3);
 		assertThat(array[0].param1()).isEqualTo("value1");
@@ -177,79 +177,6 @@ class DataBinderConstructTests {
 		assertThat(array[2].param1()).isEqualTo("value3");
 	}
 
-	@Test
-	void simpleListBinding() {
-		MapValueResolver valueResolver = new MapValueResolver(Map.of("integerList[0]", "1", "integerList[1]", "2"));
-
-		DataBinder binder = initDataBinder(IntegerListRecord.class);
-		binder.construct(valueResolver);
-
-		IntegerListRecord target = getTarget(binder);
-		assertThat(target.integerList()).containsExactly(1, 2);
-	}
-
-	@Test
-	void simpleListBindingEmptyBrackets() {
-		MapValueResolver valueResolver = new MapValueResolver(Map.of("integerList[]", "1"));
-
-		DataBinder binder = initDataBinder(IntegerListRecord.class);
-		binder.construct(valueResolver);
-
-		IntegerListRecord target = getTarget(binder);
-		assertThat(target.integerList()).containsExactly(1);
-	}
-
-	@Test
-	void simpleMapBinding() {
-		MapValueResolver valueResolver = new MapValueResolver(Map.of("integerMap[a]", "1", "integerMap[b]", "2"));
-
-		DataBinder binder = initDataBinder(IntegerMapRecord.class);
-		binder.construct(valueResolver);
-
-		IntegerMapRecord target = getTarget(binder);
-		assertThat(target.integerMap()).hasSize(2).containsEntry("a", 1).containsEntry("b", 2);
-	}
-
-	@Test
-	void simpleArrayBinding() {
-		MapValueResolver valueResolver = new MapValueResolver(Map.of("integerArray[0]", "1", "integerArray[1]", "2"));
-
-		DataBinder binder = initDataBinder(IntegerArrayRecord.class);
-		binder.construct(valueResolver);
-
-		IntegerArrayRecord target = getTarget(binder);
-		assertThat(target.integerArray()).containsExactly(1, 2);
-	}
-
-	@Test
-	void nestedListWithinMap() {
-		MapValueResolver valueResolver = new MapValueResolver(Map.of(
-				"integerListMap[a][0]", "1", "integerListMap[a][1]", "2",
-				"integerListMap[b][0]", "3", "integerListMap[b][1]", "4"));
-
-		DataBinder binder = initDataBinder(IntegerListMapRecord.class);
-		binder.construct(valueResolver);
-
-		IntegerListMapRecord target = getTarget(binder);
-		assertThat(target.integerListMap().get("a")).containsExactly(1, 2);
-		assertThat(target.integerListMap().get("b")).containsExactly(3, 4);
-	}
-
-	@Test
-	void nestedMapWithinList() {
-		MapValueResolver valueResolver = new MapValueResolver(Map.of(
-				"integerMapList[0][a]", "1", "integerMapList[0][b]", "2",
-				"integerMapList[1][a]", "3", "integerMapList[1][b]", "4"));
-
-		DataBinder binder = initDataBinder(IntegerMapListRecord.class);
-		binder.construct(valueResolver);
-
-		IntegerMapListRecord target = getTarget(binder);
-		assertThat(target.integerMapList().get(0)).containsOnly(Map.entry("a", 1), Map.entry("b", 2));
-		assertThat(target.integerMapList().get(1)).containsOnly(Map.entry("a", 3), Map.entry("b", 4));
-	}
-
-
 	@SuppressWarnings("SameParameterValue")
 	private static DataBinder initDataBinder(Class<?> targetType) {
 		DataBinder binder = new DataBinder(null);
@@ -298,7 +225,7 @@ class DataBinderConstructTests {
 	}
 
 
-	static class NestedDataClass {
+	private static class NestedDataClass {
 
 		private final String param1;
 
@@ -321,35 +248,15 @@ class DataBinderConstructTests {
 	}
 
 
-	private record DataClassListRecord(List<DataClass> dataClassList) {
+	private record ListDataClass(List<DataClass> dataClassList) {
 	}
 
 
-	private record DataClassMapRecord(Map<String, DataClass> dataClassMap) {
+	private record MapDataClass(Map<String, DataClass> dataClassMap) {
 	}
 
 
-	private record DataClassArrayRecord(DataClass[] dataClassArray) {
-	}
-
-
-	private record IntegerListRecord(List<Integer> integerList) {
-	}
-
-
-	private record IntegerMapRecord(Map<String, Integer> integerMap) {
-	}
-
-
-	private record IntegerArrayRecord(Integer[] integerArray) {
-	}
-
-
-	private record IntegerMapListRecord(List<Map<String, Integer>> integerMapList) {
-	}
-
-
-	private record IntegerListMapRecord(Map<String, List<Integer>> integerListMap) {
+	private record ArrayDataClass(DataClass[] dataClassArray) {
 	}
 
 

spring-core/src/main/java/org/springframework/aot/hint/MemberCategory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -32,19 +32,15 @@ import java.lang.reflect.Method;
 public enum MemberCategory {
 
 	/**
-	 * A category that represents reflective field access on public {@linkplain Field fields}.
-	 * @see Field#get(Object)
-	 * @see Field#set(Object, Object)
+	 * A category that represents public {@linkplain Field fields}.
+	 * @see Class#getFields()
 	 */
 	PUBLIC_FIELDS,
 
 	/**
-	 * A category that represents reflective field access on
-	 * {@linkplain Class#getDeclaredFields() declared fields}: all fields defined by the
-	 * class but not inherited fields.
+	 * A category that represents {@linkplain Class#getDeclaredFields() declared
+	 * fields}: all fields defined by the class but not inherited fields.
 	 * @see Class#getDeclaredFields()
-	 * @see Field#get(Object)
-	 * @see Field#set(Object, Object)
 	 */
 	DECLARED_FIELDS,
 

spring-core/src/main/java/org/springframework/aot/hint/ReflectionHints.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -199,8 +199,8 @@ public class ReflectionHints {
 	}
 
 	/**
-	 * Register the need for reflective field access on the specified {@link Field}.
-	 * @param field the field that requires reflective access
+	 * Register the need for reflection on the specified {@link Field}.
+	 * @param field the field that requires reflection
 	 * @return {@code this}, to facilitate method chaining
 	 */
 	public ReflectionHints registerField(Field field) {

spring-core/src/main/java/org/springframework/aot/hint/TypeHint.java

@@ -182,11 +182,9 @@ public final class TypeHint implements ConditionalHint {
 		}
 
 		/**
-		 * Register the need for reflective access on the field with the specified name.
+		 * Register the need for reflection on the field with the specified name.
 		 * @param name the name of the field
 		 * @return {@code this}, to facilitate method chaining
-		 * @see java.lang.reflect.Field#get(Object)
-		 * @see java.lang.reflect.Field#set(Object, Object)
 		 */
 		public Builder withField(String name) {
 			this.fields.add(name);

spring-core/src/main/java/org/springframework/aot/hint/predicate/ReflectionHintsPredicates.java

@@ -183,7 +183,9 @@ public class ReflectionHintsPredicates {
 	}
 
 	/**
-	 * Return a predicate that checks whether a reflective field access hint is registered for the given field.
+	 * Return a predicate that checks whether a reflection hint is registered for the given field.
+	 * By default, unsafe or write access is not considered.
+	 * <p>The returned type exposes additional methods that refine the predicate behavior.
 	 * @param field the field
 	 * @return the {@link RuntimeHints} predicate
 	 */

spring-core/src/main/java/org/springframework/cglib/core/AbstractClassGenerator.java

@@ -360,7 +360,7 @@ abstract public class AbstractClassGenerator<T> implements ClassGenerator {
 			// SPRING PATCH BEGIN
 			if (inNativeImage) {
 				throw new UnsupportedOperationException("CGLIB runtime enhancement not supported on native image. " +
-						"Make sure to enable Spring AOT processing to pre-generate '" + getClassName() + "' at build time.");
+						"Make sure to include a pre-generated class on the classpath instead: " + getClassName());
 			}
 			// SPRING PATCH END
 			byte[] b = strategy.generate(this);

spring-core/src/main/java/org/springframework/core/GenericTypeResolver.java

@@ -169,8 +169,8 @@ public final class GenericTypeResolver {
 			else if (genericType instanceof ParameterizedType parameterizedType) {
 				ResolvableType resolvedType = ResolvableType.forType(genericType);
 				if (resolvedType.hasUnresolvableGenerics()) {
+					ResolvableType[] generics = new ResolvableType[parameterizedType.getActualTypeArguments().length];
 					Type[] typeArguments = parameterizedType.getActualTypeArguments();
-					ResolvableType[] generics = new ResolvableType[typeArguments.length];
 					ResolvableType contextType = ResolvableType.forClass(contextClass);
 					for (int i = 0; i < typeArguments.length; i++) {
 						Type typeArgument = typeArguments[i];
@@ -180,7 +180,7 @@ public final class GenericTypeResolver {
 								generics[i] = resolvedTypeArgument;
 							}
 							else {
-								generics[i] = ResolvableType.forType(typeArgument);
+								generics[i] = ResolvableType.forType(typeArgument).resolveType();
 							}
 						}
 						else if (typeArgument instanceof ParameterizedType) {
@@ -209,9 +209,6 @@ public final class GenericTypeResolver {
 			}
 			resolvedType = variableResolver.resolveVariable(typeVariable);
 			if (resolvedType != null) {
-				while (resolvedType.getType() instanceof TypeVariable<?>) {
-					resolvedType = resolvedType.resolveType();
-				}
 				return resolvedType;
 			}
 		}
@@ -229,7 +226,7 @@ public final class GenericTypeResolver {
 				return resolvedType;
 			}
 		}
-		return ResolvableType.forVariableBounds(typeVariable);
+		return ResolvableType.NONE;
 	}
 
 	/**

spring-core/src/main/java/org/springframework/core/ResolvableType.java

@@ -329,6 +329,9 @@ public class ResolvableType implements Serializable {
 					other.getComponentType(), true, matchedBefore, upUntilUnresolvable));
 		}
 
+		// We're checking nested generic variables now...
+		boolean exactMatch = (strict && matchedBefore != null);
+
 		// Deal with wildcard bounds
 		WildcardBounds ourBounds = WildcardBounds.get(this);
 		WildcardBounds otherBounds = WildcardBounds.get(other);
@@ -342,9 +345,8 @@ public class ResolvableType implements Serializable {
 			else if (upUntilUnresolvable) {
 				return otherBounds.isAssignableFrom(this, matchedBefore);
 			}
-			else if (!strict) {
-				return (matchedBefore != null ? otherBounds.equalsType(this) :
-						otherBounds.isAssignableTo(this, matchedBefore));
+			else if (!exactMatch) {
+				return otherBounds.isAssignableTo(this, matchedBefore);
 			}
 			else {
 				return false;
@@ -357,7 +359,6 @@ public class ResolvableType implements Serializable {
 		}
 
 		// Main assignability check about to follow
-		boolean exactMatch = (strict && matchedBefore != null);
 		boolean checkGenerics = true;
 		Class<?> ourResolved = null;
 		if (this.type instanceof TypeVariable<?> variable) {
@@ -953,6 +954,14 @@ public class ResolvableType implements Serializable {
 		return NONE;
 	}
 
+	@Nullable
+	private Type resolveBounds(Type[] bounds) {
+		if (bounds.length == 0 || bounds[0] == Object.class) {
+			return null;
+		}
+		return bounds[0];
+	}
+
 	@Nullable
 	private ResolvableType resolveVariable(TypeVariable<?> variable) {
 		if (this.type instanceof TypeVariable) {
@@ -964,10 +973,10 @@ public class ResolvableType implements Serializable {
 				return null;
 			}
 			TypeVariable<?>[] variables = resolved.getTypeParameters();
-			Type[] typeArguments = parameterizedType.getActualTypeArguments();
 			for (int i = 0; i < variables.length; i++) {
 				if (ObjectUtils.nullSafeEquals(variables[i].getName(), variable.getName())) {
-					return forType(typeArguments[i], this.variableResolver);
+					Type actualType = parameterizedType.getActualTypeArguments()[i];
+					return forType(actualType, this.variableResolver);
 				}
 			}
 			Type ownerType = parameterizedType.getOwnerType();
@@ -1455,24 +1464,6 @@ public class ResolvableType implements Serializable {
 		return new ResolvableType(arrayType, componentType, null, null);
 	}
 
-	/**
-	 * Return a {@code ResolvableType} for the bounds of the specified {@link TypeVariable}.
-	 * @param typeVariable the type variable
-	 * @return a {@code ResolvableType} for the specified bounds
-	 * @since 6.2.3
-	 */
-	static ResolvableType forVariableBounds(TypeVariable<?> typeVariable) {
-		return forType(resolveBounds(typeVariable.getBounds()));
-	}
-
-	@Nullable
-	private static Type resolveBounds(Type[] bounds) {
-		if (bounds.length == 0 || bounds[0] == Object.class) {
-			return null;
-		}
-		return bounds[0];
-	}
-
 	/**
 	 * Return a {@code ResolvableType} for the specified {@link Type}.
 	 * <p>Note: The resulting {@code ResolvableType} instance may not be {@link Serializable}.
@@ -1501,6 +1492,7 @@ public class ResolvableType implements Serializable {
 		return forType(type, variableResolver);
 	}
 
+
 	/**
 	 * Return a {@code ResolvableType} for the specified {@link ParameterizedTypeReference}.
 	 * <p>Note: The resulting {@code ResolvableType} instance may not be {@link Serializable}.
@@ -1790,21 +1782,6 @@ public class ResolvableType implements Serializable {
 			}
 		}
 
-		/**
-		 * Return {@code true} if these bounds are equal to the specified type.
-		 * @param type the type to test against
-		 * @return {@code true} if these bounds are equal to the type
-		 * @since 6.2.3
-		 */
-		public boolean equalsType(ResolvableType type) {
-			for (ResolvableType bound : this.bounds) {
-				if (!type.equalsType(bound)) {
-					return false;
-				}
-			}
-			return true;
-		}
-
 		/**
 		 * Return the underlying bounds.
 		 */

spring-core/src/main/java/org/springframework/core/SpringProperties.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -123,8 +123,8 @@ public final class SpringProperties {
 	/**
 	 * Retrieve the flag for the given property key.
 	 * @param key the property key
-	 * @return {@code true} if the property is set to the string "true"
-	 * (ignoring case), {@code} false otherwise
+	 * @return {@code true} if the property is set to "true",
+	 * {@code} false otherwise
 	 */
 	public static boolean getFlag(String key) {
 		return Boolean.parseBoolean(getProperty(key));

spring-core/src/main/java/org/springframework/core/annotation/AnnotatedMethod.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -214,8 +214,8 @@ public class AnnotatedMethod {
 
 	@Override
 	public boolean equals(@Nullable Object other) {
-		return (this == other || (other instanceof AnnotatedMethod otherHandlerMethod &&
-				this.method.equals(otherHandlerMethod.method)));
+		return (this == other || (other != null && getClass() == other.getClass() &&
+				this.method.equals(((AnnotatedMethod) other).method)));
 	}
 
 	@Override

spring-core/src/main/java/org/springframework/core/convert/TypeDescriptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -25,7 +25,6 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 import org.springframework.core.MethodParameter;
@@ -71,10 +70,7 @@ public class TypeDescriptor implements Serializable {
 
 	private final ResolvableType resolvableType;
 
-	private final AnnotatedElementSupplier annotatedElementSupplier;
-
-	@Nullable
-	private volatile AnnotatedElementAdapter annotatedElement;
+	private final AnnotatedElementAdapter annotatedElement;
 
 
 	/**
@@ -86,7 +82,7 @@ public class TypeDescriptor implements Serializable {
 	public TypeDescriptor(MethodParameter methodParameter) {
 		this.resolvableType = ResolvableType.forMethodParameter(methodParameter);
 		this.type = this.resolvableType.resolve(methodParameter.getNestedParameterType());
-		this.annotatedElementSupplier = () -> AnnotatedElementAdapter.from(methodParameter.getParameterIndex() == -1 ?
+		this.annotatedElement = AnnotatedElementAdapter.from(methodParameter.getParameterIndex() == -1 ?
 				methodParameter.getMethodAnnotations() : methodParameter.getParameterAnnotations());
 	}
 
@@ -98,7 +94,7 @@ public class TypeDescriptor implements Serializable {
 	public TypeDescriptor(Field field) {
 		this.resolvableType = ResolvableType.forField(field);
 		this.type = this.resolvableType.resolve(field.getType());
-		this.annotatedElementSupplier = () -> AnnotatedElementAdapter.from(field.getAnnotations());
+		this.annotatedElement = AnnotatedElementAdapter.from(field.getAnnotations());
 	}
 
 	/**
@@ -111,7 +107,7 @@ public class TypeDescriptor implements Serializable {
 		Assert.notNull(property, "Property must not be null");
 		this.resolvableType = ResolvableType.forMethodParameter(property.getMethodParameter());
 		this.type = this.resolvableType.resolve(property.getType());
-		this.annotatedElementSupplier = () -> AnnotatedElementAdapter.from(property.getAnnotations());
+		this.annotatedElement = AnnotatedElementAdapter.from(property.getAnnotations());
 	}
 
 	/**
@@ -127,7 +123,7 @@ public class TypeDescriptor implements Serializable {
 	public TypeDescriptor(ResolvableType resolvableType, @Nullable Class<?> type, @Nullable Annotation[] annotations) {
 		this.resolvableType = resolvableType;
 		this.type = (type != null ? type : resolvableType.toClass());
-		this.annotatedElementSupplier = () -> AnnotatedElementAdapter.from(annotations);
+		this.annotatedElement = AnnotatedElementAdapter.from(annotations);
 	}
 
 
@@ -254,21 +250,12 @@ public class TypeDescriptor implements Serializable {
 		return getType().isPrimitive();
 	}
 
-	private AnnotatedElementAdapter getAnnotatedElement() {
-		AnnotatedElementAdapter annotatedElement = this.annotatedElement;
-		if (annotatedElement == null) {
-			annotatedElement = this.annotatedElementSupplier.get();
-			this.annotatedElement = annotatedElement;
-		}
-		return annotatedElement;
-	}
-
 	/**
 	 * Return the annotations associated with this type descriptor, if any.
 	 * @return the annotations, or an empty array if none
 	 */
 	public Annotation[] getAnnotations() {
-		return getAnnotatedElement().getAnnotations();
+		return this.annotatedElement.getAnnotations();
 	}
 
 	/**
@@ -279,13 +266,12 @@ public class TypeDescriptor implements Serializable {
 	 * @return {@code true} if the annotation is present
 	 */
 	public boolean hasAnnotation(Class<? extends Annotation> annotationType) {
-		AnnotatedElementAdapter annotatedElement = getAnnotatedElement();
-		if (annotatedElement.isEmpty()) {
+		if (this.annotatedElement.isEmpty()) {
 			// Shortcut: AnnotatedElementUtils would have to expect AnnotatedElement.getAnnotations()
 			// to return a copy of the array, whereas we can do it more efficiently here.
 			return false;
 		}
-		return AnnotatedElementUtils.isAnnotated(annotatedElement, annotationType);
+		return AnnotatedElementUtils.isAnnotated(this.annotatedElement, annotationType);
 	}
 
 	/**
@@ -296,13 +282,12 @@ public class TypeDescriptor implements Serializable {
 	 */
 	@Nullable
 	public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
-		AnnotatedElementAdapter annotatedElement = getAnnotatedElement();
-		if (annotatedElement.isEmpty()) {
+		if (this.annotatedElement.isEmpty()) {
 			// Shortcut: AnnotatedElementUtils would have to expect AnnotatedElement.getAnnotations()
 			// to return a copy of the array, whereas we can do it more efficiently here.
 			return null;
 		}
-		return AnnotatedElementUtils.getMergedAnnotation(annotatedElement, annotationType);
+		return AnnotatedElementUtils.getMergedAnnotation(this.annotatedElement, annotationType);
 	}
 
 	/**
@@ -823,8 +808,4 @@ public class TypeDescriptor implements Serializable {
 		}
 	}
 
-
-	private interface AnnotatedElementSupplier extends Supplier<AnnotatedElementAdapter>, Serializable {
-	}
-
 }

spring-core/src/main/java/org/springframework/core/convert/support/GenericConversionService.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -341,7 +341,8 @@ public class GenericConversionService implements ConfigurableConversionService {
 			}
 			// Full check for complex generic type match required?
 			ResolvableType rt = targetType.getResolvableType();
-			if (!(rt.getType() instanceof Class) && !rt.isAssignableFromResolvedPart(this.targetType)) {
+			if (!(rt.getType() instanceof Class) && !rt.isAssignableFrom(this.targetType) &&
+					!this.targetType.hasUnresolvableGenerics()) {
 				return false;
 			}
 			return !(this.converter instanceof ConditionalConverter conditionalConverter) ||

spring-core/src/main/java/org/springframework/core/env/CommandLinePropertySource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -25,7 +25,8 @@ import org.springframework.util.StringUtils;
 /**
  * Abstract base class for {@link PropertySource} implementations backed by command line
  * arguments. The parameterized type {@code T} represents the underlying source of command
- * line options.
+ * line options. For instance, {@link SimpleCommandLinePropertySource} uses  a String
+ * array.
  *
  * <h3>Purpose and General Usage</h3>
  *
@@ -258,11 +259,10 @@ public abstract class CommandLinePropertySource<T> extends EnumerablePropertySou
 	 * This implementation first checks to see if the name specified is the special
 	 * {@linkplain #setNonOptionArgsPropertyName(String) "non-option arguments" property},
 	 * and if so delegates to the abstract {@link #getNonOptionArgs()} method. If so
-	 * and the collection of non-option arguments is empty, this method returns
-	 * {@code null}. If not empty, it returns a comma-separated String of all non-option
-	 * arguments. Otherwise, this method delegates to and returns a comma-separated String
-	 * of the results of the abstract {@link #getOptionValues(String)} method or
-	 * {@code null} if there are no such option values.
+	 * and the collection of non-option arguments is empty, this method returns {@code
+	 * null}. If not empty, it returns a comma-separated String of all non-option
+	 * arguments. Otherwise, delegates to and returns the result of the abstract {@link
+	 * #getOptionValues(String)} method.
 	 */
 	@Override
 	@Nullable

spring-core/src/main/java/org/springframework/core/env/SimpleCommandLineArgsParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -28,9 +28,7 @@ package org.springframework.core.env;
  * <p>That is, options must be prefixed with "{@code --}" and may or may not
  * specify a value. If a value is specified, the name and value must be separated
  * <em>without spaces</em> by an equals sign ("="). The value may optionally be
- * an empty string. If an option is present multiple times with different values
- * &mdash; for example, {@code --foo=bar --foo=baz} &mdash; all supplied values
- * will be stored for the option.
+ * an empty string.
  *
  * <h4>Valid examples of option arguments</h4>
  * <pre class="code">
@@ -39,14 +37,14 @@ package org.springframework.core.env;
  * --foo=""
  * --foo=bar
  * --foo="bar then baz"
- * --foo=bar,baz,biz
- * --foo=bar --foo=baz --foo=biz</pre>
+ * --foo=bar,baz,biz</pre>
  *
  * <h4>Invalid examples of option arguments</h4>
  * <pre class="code">
  * -foo
  * --foo bar
- * --foo = bar</pre>
+ * --foo = bar
+ * --foo=bar --foo=baz --foo=biz</pre>
  *
  * <h3>End of option arguments</h3>
  * <p>This parser supports the POSIX "end of options" delimiter, meaning that any

spring-core/src/main/java/org/springframework/core/env/SimpleCommandLinePropertySource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -22,8 +22,7 @@ import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
 /**
- * {@link CommandLinePropertySource} implementation backed by an instance of
- * {@link CommandLineArgs}.
+ * {@link CommandLinePropertySource} implementation backed by a simple String array.
  *
  * <h3>Purpose</h3>
  * <p>This {@code CommandLinePropertySource} implementation aims to provide the simplest
@@ -41,9 +40,7 @@ import org.springframework.util.StringUtils;
  * <p>That is, options must be prefixed with "{@code --}" and may or may not
  * specify a value. If a value is specified, the name and value must be separated
  * <em>without spaces</em> by an equals sign ("="). The value may optionally be
- * an empty string. If an option is present multiple times with different values
- * &mdash; for example, {@code --foo=bar --foo=baz} &mdash; all supplied values
- * will be stored for the option.
+ * an empty string.
  *
  * <h4>Valid examples of option arguments</h4>
  * <pre class="code">
@@ -52,14 +49,14 @@ import org.springframework.util.StringUtils;
  * --foo=""
  * --foo=bar
  * --foo="bar then baz"
- * --foo=bar,baz,biz
- * --foo=bar --foo=baz --foo=biz</pre>
+ * --foo=bar,baz,biz</pre>
  *
  * <h4>Invalid examples of option arguments</h4>
  * <pre class="code">
  * -foo
  * --foo bar
- * --foo = bar</pre>
+ * --foo = bar
+ * --foo=bar --foo=baz --foo=biz</pre>
  *
  * <h3>End of option arguments</h3>
  * <p>The underlying parser supports the POSIX "end of options" delimiter, meaning

spring-core/src/main/java/org/springframework/core/io/AbstractFileResolvingResource.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -66,20 +66,6 @@ public abstract class AbstractFileResolvingResource extends AbstractResource {
 					else if (code == HttpURLConnection.HTTP_NOT_FOUND) {
 						return false;
 					}
-					else if (code == HttpURLConnection.HTTP_BAD_METHOD) {
-						con = url.openConnection();
-						customizeConnection(con);
-						if (con instanceof HttpURLConnection newHttpCon) {
-							code = newHttpCon.getResponseCode();
-							if (code == HttpURLConnection.HTTP_OK) {
-								return true;
-							}
-							else if (code == HttpURLConnection.HTTP_NOT_FOUND) {
-								return false;
-							}
-							httpCon = newHttpCon;
-						}
-					}
 				}
 				if (con.getContentLengthLong() > 0) {
 					return true;
@@ -125,15 +111,6 @@ public abstract class AbstractFileResolvingResource extends AbstractResource {
 				if (con instanceof HttpURLConnection httpCon) {
 					httpCon.setRequestMethod("HEAD");
 					int code = httpCon.getResponseCode();
-					if (code == HttpURLConnection.HTTP_BAD_METHOD) {
-						con = url.openConnection();
-						customizeConnection(con);
-						if (!(con instanceof HttpURLConnection newHttpCon)) {
-							return false;
-						}
-						code = newHttpCon.getResponseCode();
-						httpCon = newHttpCon;
-					}
 					if (code != HttpURLConnection.HTTP_OK) {
 						httpCon.disconnect();
 						return false;
@@ -282,14 +259,7 @@ public abstract class AbstractFileResolvingResource extends AbstractResource {
 			if (con instanceof HttpURLConnection httpCon) {
 				httpCon.setRequestMethod("HEAD");
 			}
-			long length = con.getContentLengthLong();
-			if (length <= 0 && con instanceof HttpURLConnection httpCon &&
-					httpCon.getResponseCode() == HttpURLConnection.HTTP_BAD_METHOD) {
-				con = url.openConnection();
-				customizeConnection(con);
-				length = con.getContentLengthLong();
-			}
-			return length;
+			return con.getContentLengthLong();
 		}
 	}
 
@@ -318,17 +288,9 @@ public abstract class AbstractFileResolvingResource extends AbstractResource {
 			httpCon.setRequestMethod("HEAD");
 		}
 		long lastModified = con.getLastModified();
-		if (lastModified == 0) {
-			if (con instanceof HttpURLConnection httpCon &&
-					httpCon.getResponseCode() == HttpURLConnection.HTTP_BAD_METHOD) {
-				con = url.openConnection();
-				customizeConnection(con);
-				lastModified = con.getLastModified();
-			}
-			if (fileCheck && con.getContentLengthLong() <= 0) {
-				throw new FileNotFoundException(getDescription() +
-						" cannot be resolved in the file system for checking its last-modified timestamp");
-			}
+		if (fileCheck && lastModified == 0 && con.getContentLengthLong() <= 0) {
+			throw new FileNotFoundException(getDescription() +
+					" cannot be resolved in the file system for checking its last-modified timestamp");
 		}
 		return lastModified;
 	}

spring-core/src/main/java/org/springframework/core/io/support/PathMatchingResourcePatternResolver.java

@@ -813,8 +813,6 @@ public class PathMatchingResourcePatternResolver implements ResourcePatternResol
 			NavigableSet<String> entriesCache = this.jarEntriesCache.get(jarFileUrl);
 			if (entriesCache != null) {
 				Set<Resource> result = new LinkedHashSet<>(64);
-				// Clean root entry path to match jar entries format without "!" separators
-				rootEntryPath = rootEntryPath.replace(ResourceUtils.JAR_URL_SEPARATOR, "/");
 				// Search sorted entries from first entry with rootEntryPath prefix
 				for (String entryPath : entriesCache.tailSet(rootEntryPath, false)) {
 					if (!entryPath.startsWith(rootEntryPath)) {
@@ -843,9 +841,8 @@ public class PathMatchingResourcePatternResolver implements ResourcePatternResol
 				rootEntryPath = (jarEntry != null ? jarEntry.getName() : "");
 				closeJarFile = !jarCon.getUseCaches();
 			}
-			catch (ZipException | FileNotFoundException ex) {
-				// Happens in case of a non-jar file or in case of a cached root directory
-				// without specific subdirectory present, respectively.
+			catch (FileNotFoundException ex) {
+				// Happens in case of cached root directory without specific subdirectory present.
 				return Collections.emptySet();
 			}
 		}

spring-core/src/main/java/org/springframework/util/PlaceholderParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -175,8 +175,9 @@ final class PlaceholderParser {
 	}
 
 	private SimplePlaceholderPart createSimplePlaceholderPart(String text) {
-		ParsedSection section = parseSection(text);
-		return new SimplePlaceholderPart(text, section.key(), section.fallback());
+		String[] keyAndDefault = splitKeyAndDefault(text);
+		return ((keyAndDefault != null) ? new SimplePlaceholderPart(text, keyAndDefault[0], keyAndDefault[1]) :
+				new SimplePlaceholderPart(text, text, null));
 	}
 
 	private NestedPlaceholderPart createNestedPlaceholderPart(String text, List<Part> parts) {
@@ -192,32 +193,28 @@ final class PlaceholderParser {
 			}
 			else {
 				String candidate = part.text();
-				ParsedSection section = parseSection(candidate);
-				keyParts.add(new TextPart(section.key()));
-				if (section.fallback() != null) {
-					defaultParts.add(new TextPart(section.fallback()));
+				String[] keyAndDefault = splitKeyAndDefault(candidate);
+				if (keyAndDefault != null) {
+					keyParts.add(new TextPart(keyAndDefault[0]));
+					if (keyAndDefault[1] != null) {
+						defaultParts.add(new TextPart(keyAndDefault[1]));
+					}
 					defaultParts.addAll(parts.subList(i + 1, parts.size()));
 					return new NestedPlaceholderPart(text, keyParts, defaultParts);
 				}
+				else {
+					keyParts.add(part);
+				}
 			}
 		}
-		return new NestedPlaceholderPart(text, keyParts, null);
+		// No separator found
+		return new NestedPlaceholderPart(text, parts, null);
 	}
 
-	/**
-	 * Parse an input value that may contain a separator character and return a
-	 * {@link ParsedValue}. If a valid separator character has been identified, the
-	 * given {@code value} is split between a {@code key} and a {@code fallback}. If not,
-	 * only the {@code key} is set.
-	 * <p>
-	 * The returned key may be different from the original value as escaped
-	 * separators, if any, are resolved.
-	 * @param value the value to parse
-	 * @return the parsed section
-	 */
-	private ParsedSection parseSection(String value) {
+	@Nullable
+	private String[] splitKeyAndDefault(String value) {
 		if (this.separator == null || !value.contains(this.separator)) {
-			return new ParsedSection(value, null);
+			return null;
 		}
 		int position = 0;
 		int index = value.indexOf(this.separator, position);
@@ -234,11 +231,11 @@ final class PlaceholderParser {
 				buffer.append(value, position, index);
 				String key = buffer.toString();
 				String fallback = value.substring(index + this.separator.length());
-				return new ParsedSection(key, fallback);
+				return new String[] { key, fallback };
 			}
 		}
 		buffer.append(value, position, value.length());
-		return new ParsedSection(buffer.toString(), null);
+		return new String[] { buffer.toString(), null };
 	}
 
 	private static void addText(String value, int start, int end, LinkedList<Part> parts) {
@@ -296,10 +293,6 @@ final class PlaceholderParser {
 		return (this.escape != null && index > 0 && value.charAt(index - 1) == this.escape);
 	}
 
-	record ParsedSection(String key, @Nullable String fallback) {
-
-	}
-
 
 	/**
 	 * Provide the necessary context to handle and resolve underlying placeholders.

spring-core/src/test/java/org/springframework/aot/hint/annotation/RegisterReflectionReflectiveProcessorTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -180,7 +180,10 @@ class RegisterReflectionReflectiveProcessorTests {
 	@RegisterReflection(memberCategories = MemberCategory.INVOKE_DECLARED_CONSTRUCTORS)
 	static class AnnotatedSimplePojo {
 
+		private String test;
+
 		AnnotatedSimplePojo(String test) {
+			this.test = test;
 		}
 	}
 

spring-core/src/test/java/org/springframework/core/BridgeMethodResolverTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -405,10 +405,7 @@ class BridgeMethodResolverTests {
 	}
 
 
-	public abstract static class SubBar<T extends StringProducer> extends InterBar<T> {
-	}
-
-	public interface StringProducer extends CharSequence {
+	public abstract static class SubBar<T extends StringBuffer> extends InterBar<T> {
 	}
 
 

spring-core/src/test/java/org/springframework/core/GenericTypeResolverTests.java

@@ -18,25 +18,20 @@ package org.springframework.core;
 
 import java.io.Serializable;
 import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Supplier;
 
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.core.GenericTypeResolver.getTypeVariableMap;
-import static org.springframework.core.GenericTypeResolver.resolveParameterType;
-import static org.springframework.core.GenericTypeResolver.resolveReturnType;
 import static org.springframework.core.GenericTypeResolver.resolveReturnTypeArgument;
 import static org.springframework.core.GenericTypeResolver.resolveType;
 import static org.springframework.core.GenericTypeResolver.resolveTypeArgument;
-import static org.springframework.core.GenericTypeResolver.resolveTypeArguments;
 import static org.springframework.util.ReflectionUtils.findMethod;
 
 /**
@@ -111,25 +106,25 @@ class GenericTypeResolverTests {
 	void testGetTypeVariableMap() {
 		Map<TypeVariable, Type> map;
 
-		map = getTypeVariableMap(MySimpleInterfaceType.class);
+		map = GenericTypeResolver.getTypeVariableMap(MySimpleInterfaceType.class);
 		assertThat(map.toString()).isEqualTo("{T=class java.lang.String}");
 
-		map = getTypeVariableMap(MyCollectionInterfaceType.class);
+		map = GenericTypeResolver.getTypeVariableMap(MyCollectionInterfaceType.class);
 		assertThat(map.toString()).isEqualTo("{T=java.util.Collection<java.lang.String>}");
 
-		map = getTypeVariableMap(MyCollectionSuperclassType.class);
+		map = GenericTypeResolver.getTypeVariableMap(MyCollectionSuperclassType.class);
 		assertThat(map.toString()).isEqualTo("{T=java.util.Collection<java.lang.String>}");
 
-		map = getTypeVariableMap(MySimpleTypeWithMethods.class);
+		map = GenericTypeResolver.getTypeVariableMap(MySimpleTypeWithMethods.class);
 		assertThat(map.toString()).isEqualTo("{T=class java.lang.Integer}");
 
-		map = getTypeVariableMap(TopLevelClass.class);
+		map = GenericTypeResolver.getTypeVariableMap(TopLevelClass.class);
 		assertThat(map.toString()).isEqualTo("{}");
 
-		map = getTypeVariableMap(TypedTopLevelClass.class);
+		map = GenericTypeResolver.getTypeVariableMap(TypedTopLevelClass.class);
 		assertThat(map.toString()).isEqualTo("{T=class java.lang.Integer}");
 
-		map = getTypeVariableMap(TypedTopLevelClass.TypedNested.class);
+		map = GenericTypeResolver.getTypeVariableMap(TypedTopLevelClass.TypedNested.class);
 		assertThat(map).hasSize(2);
 		Type t = null;
 		Type x = null;
@@ -147,19 +142,19 @@ class GenericTypeResolverTests {
 
 	@Test
 	void resolveTypeArgumentsOfAbstractType() {
-		Class<?>[] resolved = resolveTypeArguments(MyConcreteType.class, MyAbstractType.class);
+		Class<?>[] resolved = GenericTypeResolver.resolveTypeArguments(MyConcreteType.class, MyAbstractType.class);
 		assertThat(resolved).containsExactly(Character.class);
 	}
 
 	@Test  // SPR-11030
 	void getGenericsCannotBeResolved() {
-		Class<?>[] resolved = resolveTypeArguments(List.class, Iterable.class);
+		Class<?>[] resolved = GenericTypeResolver.resolveTypeArguments(List.class, Iterable.class);
 		assertThat(resolved).isNull();
 	}
 
 	@Test  // SPR-11052
 	void getRawMapTypeCannotBeResolved() {
-		Class<?>[] resolved = resolveTypeArguments(Map.class, Map.class);
+		Class<?>[] resolved = GenericTypeResolver.resolveTypeArguments(Map.class, Map.class);
 		assertThat(resolved).isNull();
 	}
 
@@ -168,38 +163,26 @@ class GenericTypeResolverTests {
 	void getGenericsOnArrayFromParamCannotBeResolved() throws Exception {
 		MethodParameter methodParameter = MethodParameter.forExecutable(
 				WithArrayBase.class.getDeclaredMethod("array", Object[].class), 0);
-		Class<?> resolved = resolveParameterType(methodParameter, WithArray.class);
+		Class<?> resolved = GenericTypeResolver.resolveParameterType(methodParameter, WithArray.class);
 		assertThat(resolved).isEqualTo(Object[].class);
 	}
 
 	@Test  // SPR-11044
 	void getGenericsOnArrayFromReturnCannotBeResolved() throws Exception {
-		Class<?> resolved = resolveReturnType(
+		Class<?> resolved = GenericTypeResolver.resolveReturnType(
 				WithArrayBase.class.getDeclaredMethod("array", Object[].class), WithArray.class);
 		assertThat(resolved).isEqualTo(Object[].class);
 	}
 
 	@Test  // SPR-11763
 	void resolveIncompleteTypeVariables() {
-		Class<?>[] resolved = resolveTypeArguments(IdFixingRepository.class, Repository.class);
+		Class<?>[] resolved = GenericTypeResolver.resolveTypeArguments(IdFixingRepository.class, Repository.class);
 		assertThat(resolved).isNotNull();
 		assertThat(resolved).hasSize(2);
 		assertThat(resolved[0]).isEqualTo(Object.class);
 		assertThat(resolved[1]).isEqualTo(Long.class);
 	}
 
-	@Test  // gh-34386
-	void resolveVariableNameChange() {
-		Type resolved = resolveType(Repository.class.getTypeParameters()[0], ConcreteRepository.class);
-		assertThat(resolved).isEqualTo(String.class);
-		Method method = method(Repository.class,"store", Supplier.class);
-		resolved = resolveType(method.getGenericParameterTypes()[0], ConcreteRepository.class);
-		assertThat(resolved).isInstanceOf(ParameterizedType.class);
-		ParameterizedType pt = (ParameterizedType) resolved;
-		assertThat(pt.getRawType()).isEqualTo(Supplier.class);
-		assertThat(pt.getActualTypeArguments()[0]).isEqualTo(String.class);
-	}
-
 	@Test
 	void resolvePartiallySpecializedTypeVariables() {
 		Type resolved = resolveType(BiGenericClass.class.getTypeParameters()[0], TypeFixedBiGenericClass.class);
@@ -229,27 +212,19 @@ class GenericTypeResolverTests {
 	}
 
 	@Test
-	void resolveTypeWithElementBounds() {
-		Type type = method(WithElementBounds.class, "get").getGenericReturnType();
-		Type resolvedType = resolveType(type, WithElementBounds.class);
+	void resolvedTypeWithBase() {
+		Type type = method(WithBaseTypes.class, "get").getGenericReturnType();
+		Type resolvedType = resolveType(type, WithBaseTypes.class);
 		ParameterizedTypeReference<List<A>> reference = new ParameterizedTypeReference<>() {};
 		assertThat(resolvedType).isEqualTo(reference.getType());
 	}
 
-	@Test
-	void resolveTypeWithUnresolvableElement() {
-		Type type = method(WithUnresolvableElement.class, "get").getGenericReturnType();
-		Type resolvedType = resolveType(type, WithUnresolvableElement.class);
-		assertThat(resolvedType.toString()).isEqualTo("java.util.List<E>");
-	}
-
 	private static Method method(Class<?> target, String methodName, Class<?>... parameterTypes) {
 		Method method = findMethod(target, methodName, parameterTypes);
 		assertThat(method).describedAs(target.getName() + "#" + methodName).isNotNull();
 		return method;
 	}
 
-
 	public interface MyInterfaceType<T> {
 	}
 
@@ -373,9 +348,9 @@ class GenericTypeResolverTests {
 	static class GenericClass<T> {
 	}
 
-	class A {}
+	class A{}
 
-	class B<T> {}
+	class B<T>{}
 
 	class C extends A {}
 
@@ -383,25 +358,23 @@ class GenericTypeResolverTests {
 
 	class E extends C {}
 
-	class TestIfc<T> {}
+	class TestIfc<T>{}
 
-	class TestImpl<I extends A, T extends B<I>> extends TestIfc<T> {
+	class TestImpl<I extends A, T extends B<I>> extends TestIfc<T>{
 	}
 
 	abstract static class BiGenericClass<T extends B<?>, V extends A> {}
 
-	abstract static class SpecializedBiGenericClass<U extends C> extends BiGenericClass<D, U> {}
+	abstract static class SpecializedBiGenericClass<U extends C> extends BiGenericClass<D, U>{}
 
 	static class TypeFixedBiGenericClass extends SpecializedBiGenericClass<E> {}
 
 	static class TopLevelClass<T> {
-
 		class Nested<X> {
 		}
 	}
 
 	static class TypedTopLevelClass extends TopLevelClass<Integer> {
-
 		class TypedNested extends Nested<Long> {
 		}
 	}
@@ -415,43 +388,30 @@ class GenericTypeResolverTests {
 	}
 
 	interface Repository<T, ID extends Serializable> {
-
-		default void store(Supplier<T> t) {
-		}
 	}
 
-	interface IdFixingRepository<V> extends Repository<V, Long> {
-	}
-
-	static class ConcreteRepository implements IdFixingRepository<String> {
+	interface IdFixingRepository<T> extends Repository<T, Long> {
 	}
 
 	static class WithMethodParameter {
-
 		public void nestedGenerics(List<Map<String, Integer>> input) {
 		}
 	}
 
-	interface ListOfListSupplier<T> {
+	public interface ListOfListSupplier<T> {
 
 		List<List<T>> get();
 	}
 
-	interface StringListOfListSupplier extends ListOfListSupplier<String> {
+	public interface StringListOfListSupplier extends ListOfListSupplier<String> {
 	}
 
-	static class WithElementBounds {
+	static class WithBaseTypes {
 
 		<T extends A> List<T> get() {
 			return List.of();
 		}
-	}
 
-	static class WithUnresolvableElement<T> {
-
-		List<T> get() {
-			return List.of();
-		}
 	}
 
 }

spring-core/src/test/java/org/springframework/core/ResolvableTypeTests.java

@@ -1230,8 +1230,6 @@ class ResolvableTypeTests {
 		ResolvableType consumerUnresolved = ResolvableType.forClass(Consumer.class);
 		ResolvableType consumerObject = ResolvableType.forClassWithGenerics(Consumer.class, Object.class);
 		ResolvableType consumerNestedUnresolved = ResolvableType.forClassWithGenerics(Consumer.class, ResolvableType.forClass(Consumer.class));
-		ResolvableType consumerNumber = ResolvableType.forClassWithGenerics(Consumer.class, Number.class);
-		ResolvableType consumerExtendsNumber = ResolvableType.forClass(SubConsumer.class);
 
 		assertThat(consumerUnresolved.isAssignableFrom(consumerObject)).isTrue();
 		assertThat(consumerUnresolved.isAssignableFromResolvedPart(consumerObject)).isTrue();
@@ -1241,10 +1239,6 @@ class ResolvableTypeTests {
 		assertThat(consumerUnresolved.isAssignableFromResolvedPart(consumerNestedUnresolved)).isTrue();
 		assertThat(consumerObject.isAssignableFrom(consumerNestedUnresolved)).isFalse();
 		assertThat(consumerObject.isAssignableFromResolvedPart(consumerNestedUnresolved)).isFalse();
-		assertThat(consumerObject.isAssignableFrom(consumerNumber)).isFalse();
-		assertThat(consumerObject.isAssignableFromResolvedPart(consumerNumber)).isFalse();
-		assertThat(consumerObject.isAssignableFrom(consumerExtendsNumber)).isFalse();
-		assertThat(consumerObject.isAssignableFromResolvedPart(consumerExtendsNumber)).isTrue();
 	}
 
 	@Test
@@ -1794,9 +1788,6 @@ class ResolvableTypeTests {
 	public interface Consumer<T> {
 	}
 
-	private static class SubConsumer<N extends Number> implements Consumer<N> {
-	}
-
 	public class Wildcard<T extends CharSequence> {
 	}
 

spring-core/src/test/java/org/springframework/core/convert/support/GenericConversionServiceTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -565,22 +565,6 @@ class GenericConversionServiceTests {
 		assertThat(conversionService.convert("test", TypeDescriptor.valueOf(String.class), new TypeDescriptor(getClass().getField("integerCollection")))).isEqualTo(Collections.singleton("testX"));
 	}
 
-	@Test
-	void stringListToListOfSubclassOfUnboundGenericClass() {
-		conversionService.addConverter(new StringListToAListConverter());
-		conversionService.addConverter(new StringListToBListConverter());
-
-		List<?> aList = (List<?>) conversionService.convert(List.of("foo"),
-				TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class)),
-				TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(ARaw.class)));
-		assertThat(aList).allMatch(e -> e instanceof ARaw);
-
-		List<?> bList = (List<?>) conversionService.convert(List.of("foo"),
-				TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(String.class)),
-				TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(BRaw.class)));
-		assertThat(bList).allMatch(e -> e instanceof BRaw);
-	}
-
 
 	@ExampleAnnotation(active = true)
 	public String annotatedString;
@@ -758,7 +742,6 @@ class GenericConversionServiceTests {
 		}
 	}
 
-
 	private interface MyEnumBaseInterface {
 		String getBaseCode();
 	}
@@ -940,35 +923,4 @@ class GenericConversionServiceTests {
 			return Color.decode(source.substring(0, 6));
 		}
 	}
-
-
-	private static class GenericBaseClass<T> {
-	}
-
-	@SuppressWarnings("rawtypes")
-	private static class ARaw extends GenericBaseClass {
-	}
-
-	@SuppressWarnings("rawtypes")
-	private static class BRaw extends GenericBaseClass {
-	}
-
-
-	private static class StringListToAListConverter implements Converter<List<String>, List<ARaw>> {
-
-		@Override
-		public List<ARaw> convert(List<String> source) {
-			return List.of(new ARaw());
-		}
-	}
-
-
-	private static class StringListToBListConverter implements Converter<List<String>, List<BRaw>> {
-
-		@Override
-		public List<BRaw> convert(List<String> source) {
-			return List.of(new BRaw());
-		}
-	}
-
 }

spring-core/src/test/java/org/springframework/core/env/SimpleCommandLineArgsParserTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -46,7 +46,7 @@ class SimpleCommandLineArgsParserTests {
 	void withSingleOptionAndNoValue() {
 		CommandLineArgs args = parser.parse("--o1");
 		assertThat(args.containsOption("o1")).isTrue();
-		assertThat(args.getOptionValues("o1")).isEmpty();
+		assertThat(args.getOptionValues("o1")).isEqualTo(Collections.EMPTY_LIST);
 	}
 
 	@Test
@@ -56,20 +56,6 @@ class SimpleCommandLineArgsParserTests {
 		assertThat(args.getOptionValues("o1")).containsExactly("v1");
 	}
 
-	@Test
-	void withRepeatedOptionAndSameValues() {
-		CommandLineArgs args = parser.parse("--o1=v1", "--o1=v1", "--o1=v1");
-		assertThat(args.containsOption("o1")).isTrue();
-		assertThat(args.getOptionValues("o1")).containsExactly("v1", "v1", "v1");
-	}
-
-	@Test
-	void withRepeatedOptionAndDifferentValues() {
-		CommandLineArgs args = parser.parse("--o1=v1", "--o1=v2", "--o1=v3");
-		assertThat(args.containsOption("o1")).isTrue();
-		assertThat(args.getOptionValues("o1")).containsExactly("v1", "v2", "v3");
-	}
-
 	@Test
 	void withMixOfOptionsHavingValueAndOptionsHavingNoValue() {
 		CommandLineArgs args = parser.parse("--o1=v1", "--o2");
@@ -109,17 +95,17 @@ class SimpleCommandLineArgsParserTests {
 	}
 
 	@Test
-	void optionNamesSetIsUnmodifiable() {
+	void assertOptionNamesIsUnmodifiable() {
 		CommandLineArgs args = new SimpleCommandLineArgsParser().parse();
-		assertThatExceptionOfType(UnsupportedOperationException.class)
-				.isThrownBy(() -> args.getOptionNames().add("bogus"));
+		assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
+				args.getOptionNames().add("bogus"));
 	}
 
 	@Test
-	void nonOptionArgsListIsUnmodifiable() {
+	void assertNonOptionArgsIsUnmodifiable() {
 		CommandLineArgs args = new SimpleCommandLineArgsParser().parse();
-		assertThatExceptionOfType(UnsupportedOperationException.class)
-				.isThrownBy(() -> args.getNonOptionArgs().add("foo"));
+		assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() ->
+				args.getNonOptionArgs().add("foo"));
 	}
 
 	@Test

spring-core/src/test/java/org/springframework/core/env/SimpleCommandLinePropertySourceTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -61,15 +61,6 @@ class SimpleCommandLinePropertySourceTests {
 		assertThat(ps.getProperty("o3")).isNull();
 	}
 
-	@Test  // gh-34282
-	void withRepeatedOptionArgs() {
-		CommandLinePropertySource<?> ps = new SimpleCommandLinePropertySource("--o1=v1", "--o1=v2", "--o1=v3");
-		assertThat(ps.containsProperty("o1")).isTrue();
-		assertThat(ps.containsProperty("o2")).isFalse();
-		assertThat(ps.getProperty("o1")).isEqualTo("v1,v2,v3");
-		assertThat(ps.getProperty("o2")).isNull();
-	}
-
 	@Test // gh-24464
 	void withOptionalArg_andArgIsEmpty() {
 		EnumerablePropertySource<?> ps = new SimpleCommandLinePropertySource("--foo=");

spring-core/src/test/java/org/springframework/core/io/ResourceTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -306,9 +306,7 @@ class ResourceTests {
 	@Nested
 	class UrlResourceTests {
 
-		private static final String LAST_MODIFIED = "Wed, 09 Apr 2014 09:57:42 GMT";
-
-		private final MockWebServer server = new MockWebServer();
+		private MockWebServer server = new MockWebServer();
 
 		@Test
 		void sameResourceWithRelativePathIsEqual() throws Exception {
@@ -387,44 +385,22 @@ class ResourceTests {
 
 		@Test
 		void missingRemoteResourceDoesNotExist() throws Exception {
-			String baseUrl = startServer(true);
+			String baseUrl = startServer();
 			UrlResource resource = new UrlResource(baseUrl + "/missing");
 			assertThat(resource.exists()).isFalse();
 		}
 
 		@Test
 		void remoteResourceExists() throws Exception {
-			String baseUrl = startServer(true);
+			String baseUrl = startServer();
 			UrlResource resource = new UrlResource(baseUrl + "/resource");
 			assertThat(resource.exists()).isTrue();
-			assertThat(resource.isReadable()).isTrue();
 			assertThat(resource.contentLength()).isEqualTo(6);
-			assertThat(resource.lastModified()).isGreaterThan(0);
-		}
-
-		@Test
-		void remoteResourceExistsFallback() throws Exception {
-			String baseUrl = startServer(false);
-			UrlResource resource = new UrlResource(baseUrl + "/resource");
-			assertThat(resource.exists()).isTrue();
-			assertThat(resource.isReadable()).isTrue();
-			assertThat(resource.contentLength()).isEqualTo(6);
-			assertThat(resource.lastModified()).isGreaterThan(0);
 		}
 
 		@Test
 		void canCustomizeHttpUrlConnectionForExists() throws Exception {
-			String baseUrl = startServer(true);
-			CustomResource resource = new CustomResource(baseUrl + "/resource");
-			assertThat(resource.exists()).isTrue();
-			RecordedRequest request = this.server.takeRequest();
-			assertThat(request.getMethod()).isEqualTo("HEAD");
-			assertThat(request.getHeader("Framework-Name")).isEqualTo("Spring");
-		}
-
-		@Test
-		void canCustomizeHttpUrlConnectionForExistsFallback() throws Exception {
-			String baseUrl = startServer(false);
+			String baseUrl = startServer();
 			CustomResource resource = new CustomResource(baseUrl + "/resource");
 			assertThat(resource.exists()).isTrue();
 			RecordedRequest request = this.server.takeRequest();
@@ -434,7 +410,7 @@ class ResourceTests {
 
 		@Test
 		void canCustomizeHttpUrlConnectionForRead() throws Exception {
-			String baseUrl = startServer(true);
+			String baseUrl = startServer();
 			CustomResource resource = new CustomResource(baseUrl + "/resource");
 			assertThat(resource.getInputStream()).hasContent("Spring");
 			RecordedRequest request = this.server.takeRequest();
@@ -444,7 +420,7 @@ class ResourceTests {
 
 		@Test
 		void useUserInfoToSetBasicAuth() throws Exception {
-			startServer(true);
+			startServer();
 			UrlResource resource = new UrlResource(
 					"http://alice:secret@localhost:" + this.server.getPort() + "/resource");
 			assertThat(resource.getInputStream()).hasContent("Spring");
@@ -460,8 +436,8 @@ class ResourceTests {
 			this.server.shutdown();
 		}
 
-		private String startServer(boolean withHeadSupport) throws Exception {
-			this.server.setDispatcher(new ResourceDispatcher(withHeadSupport));
+		private String startServer() throws Exception {
+			this.server.setDispatcher(new ResourceDispatcher());
 			this.server.start();
 			return "http://localhost:" + this.server.getPort();
 		}
@@ -480,26 +456,15 @@ class ResourceTests {
 
 		class ResourceDispatcher extends Dispatcher {
 
-			boolean withHeadSupport;
-
-			public ResourceDispatcher(boolean withHeadSupport) {
-				this.withHeadSupport = withHeadSupport;
-			}
-
 			@Override
 			public MockResponse dispatch(RecordedRequest request) {
 				if (request.getPath().equals("/resource")) {
 					return switch (request.getMethod()) {
-						case "HEAD" -> (this.withHeadSupport ?
-								new MockResponse()
-										.addHeader("Content-Type", "text/plain")
-										.addHeader("Content-Length", "6")
-										.addHeader("Last-Modified", LAST_MODIFIED) :
-								new MockResponse().setResponseCode(405));
+						case "HEAD" -> new MockResponse()
+									.addHeader("Content-Length", "6");
 						case "GET" -> new MockResponse()
-									.addHeader("Content-Type", "text/plain")
 									.addHeader("Content-Length", "6")
-									.addHeader("Last-Modified", LAST_MODIFIED)
+									.addHeader("Content-Type", "text/plain")
 									.setBody("Spring");
 						default -> new MockResponse().setResponseCode(404);
 					};

spring-core/src/test/java/org/springframework/util/PlaceholderParserTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -278,26 +278,6 @@ class PlaceholderParserTests {
 
 		private final PlaceholderParser parser = new PlaceholderParser("${", "}", ":", '\\', true);
 
-		@ParameterizedTest(name = "{0} -> {1}")
-		@MethodSource("escapedInNestedPlaceholders")
-		void escapedSeparatorInNestedPlaceholder(String text, String expected) {
-			Properties properties = new Properties();
-			properties.setProperty("app.environment", "qa");
-			properties.setProperty("app.service", "protocol");
-			properties.setProperty("protocol://host/qa/name", "protocol://example.com/qa/name");
-			properties.setProperty("service/host/qa/name", "https://example.com/qa/name");
-			properties.setProperty("service/host/qa/name:value", "https://example.com/qa/name-value");
-			assertThat(this.parser.replacePlaceholders(text, properties::getProperty)).isEqualTo(expected);
-		}
-
-		static Stream<Arguments> escapedInNestedPlaceholders() {
-			return Stream.of(
-					Arguments.of("${protocol\\://host/${app.environment}/name}", "protocol://example.com/qa/name"),
-					Arguments.of("${${app.service}\\://host/${app.environment}/name}", "protocol://example.com/qa/name"),
-					Arguments.of("${service/host/${app.environment}/name:\\value}", "https://example.com/qa/name"),
-					Arguments.of("${service/host/${name\\:value}/}", "${service/host/${name:value}/}"));
-		}
-
 		@ParameterizedTest(name = "{0} -> {1}")
 		@MethodSource("escapedPlaceholders")
 		void escapedPlaceholderIsNotReplaced(String text, String expected) {

spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectionHelper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -319,8 +319,8 @@ public abstract class ReflectionHelper {
 						(sourceType.isArray() && !sourceType.isAssignableTo(targetType)) ||
 						(argument instanceof List)) {
 
-					TypeDescriptor targetTypeToUse = (sourceType.isArray() || argument instanceof List ||
-							converter.canConvert(sourceType, targetType) ? targetType : componentTypeDesc);
+					TypeDescriptor targetTypeToUse =
+							(sourceType.isArray() || argument instanceof List ? targetType : componentTypeDesc);
 					arguments[varargsPosition] = converter.convertValue(argument, sourceType, targetTypeToUse);
 				}
 				// Possible outcomes of the above if-else block:
@@ -420,8 +420,8 @@ public abstract class ReflectionHelper {
 						(sourceType.isArray() && !sourceType.isAssignableTo(varargsArrayType)) ||
 						(argument instanceof List)) {
 
-					TypeDescriptor targetTypeToUse = (sourceType.isArray() || argument instanceof List ||
-							converter.canConvert(sourceType, varargsArrayType) ? varargsArrayType : varargsComponentType);
+					TypeDescriptor targetTypeToUse =
+							(sourceType.isArray() || argument instanceof List ? varargsArrayType : varargsComponentType);
 					arguments[varargsPosition] = converter.convertValue(argument, sourceType, targetTypeToUse);
 				}
 				// Possible outcomes of the above if-else block:

spring-expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -118,11 +118,6 @@ class TestScenarioCreator {
 				"varargsFunction", MethodType.methodType(String.class, String[].class));
 		testContext.registerFunction("varargsFunctionHandle", varargsFunctionHandle);
 
-		// #varargsObjectFunctionHandle(args...)
-		MethodHandle varargsObjectFunctionHandle = MethodHandles.lookup().findStatic(TestScenarioCreator.class,
-				"varargsObjectFunction", MethodType.methodType(String.class, Object[].class));
-		testContext.registerFunction("varargsObjectFunctionHandle", varargsObjectFunctionHandle);
-
 		// #add(int, int)
 		MethodHandle add = MethodHandles.lookup().findStatic(TestScenarioCreator.class,
 				"add", MethodType.methodType(int.class, int.class, int.class));

spring-expression/src/test/java/org/springframework/expression/spel/VariableAndFunctionTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -16,21 +16,11 @@
 
 package org.springframework.expression.spel;
 
-import java.util.Set;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
-import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.core.convert.converter.GenericConverter;
-import org.springframework.core.convert.support.DefaultConversionService;
-import org.springframework.expression.Expression;
-import org.springframework.expression.spel.standard.SpelExpression;
+import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.expression.spel.support.StandardEvaluationContext;
-import org.springframework.expression.spel.support.StandardTypeConverter;
 import org.springframework.expression.spel.support.StandardTypeLocator;
-import org.springframework.lang.Nullable;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
@@ -276,10 +266,11 @@ class VariableAndFunctionTests extends AbstractExpressionTests {
 
 	@Test
 	void functionMethodMustBeStatic() throws Exception {
-		context.registerFunction("nonStatic", this.getClass().getMethod("nonStatic"));
-		SpelExpression expression = parser.parseRaw("#nonStatic()");
+		SpelExpressionParser parser = new SpelExpressionParser();
+		StandardEvaluationContext ctx = new StandardEvaluationContext();
+		ctx.setVariable("notStatic", this.getClass().getMethod("nonStatic"));
 		assertThatExceptionOfType(SpelEvaluationException.class)
-				.isThrownBy(() -> expression.getValue(context))
+				.isThrownBy(() -> parser.parseRaw("#notStatic()").getValue(ctx))
 				.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(FUNCTION_MUST_BE_STATIC));
 	}
 
@@ -288,75 +279,4 @@ class VariableAndFunctionTests extends AbstractExpressionTests {
 	public void nonStatic() {
 	}
 
-
-	@Nested  // gh-34371
-	class VarargsAndPojoToArrayConversionTests {
-
-		private final StandardEvaluationContext context = TestScenarioCreator.getTestEvaluationContext();
-
-		private final ArrayHolder arrayHolder = new ArrayHolder("a", "b", "c");
-
-
-		@BeforeEach
-		void setUp() {
-			DefaultConversionService conversionService = new DefaultConversionService();
-			conversionService.addConverter(new ArrayHolderConverter());
-			context.setTypeConverter(new StandardTypeConverter(conversionService));
-			context.setVariable("arrayHolder", arrayHolder);
-		}
-
-		@Test
-		void functionWithVarargsAndPojoToArrayConversion() {
-			// #varargsFunction: static String varargsFunction(String... strings) -> Arrays.toString(strings)
-			evaluate("#varargsFunction(#arrayHolder)", "[a, b, c]");
-
-			// #varargsObjectFunction: static String varargsObjectFunction(Object... args) -> Arrays.toString(args)
-			//
-			// Since ArrayHolder is an "instanceof Object" and Object is the varargs component type,
-			// we expect the ArrayHolder not to be converted to an array but rather to be passed
-			// "as is" as a single argument to the varargs method.
-			evaluate("#varargsObjectFunction(#arrayHolder)", "[" + arrayHolder.toString() + "]");
-		}
-
-		@Test
-		void functionWithVarargsAndPojoToArrayConversionViaMethodHandle() {
-			// #varargsFunctionHandle: static String varargsFunction(String... strings) -> Arrays.toString(strings)
-			evaluate("#varargsFunctionHandle(#arrayHolder)", "[a, b, c]");
-
-			// #varargsObjectFunctionHandle: static String varargsObjectFunction(Object... args) -> Arrays.toString(args)
-			//
-			// Since ArrayHolder is an "instanceof Object" and Object is the varargs component type,
-			// we expect the ArrayHolder not to be converted to an array but rather to be passed
-			// "as is" as a single argument to the varargs method.
-			evaluate("#varargsObjectFunctionHandle(#arrayHolder)", "[" + arrayHolder.toString() + "]");
-		}
-
-		private void evaluate(String expression, Object expectedValue) {
-			Expression expr = parser.parseExpression(expression);
-			assertThat(expr).as("expression").isNotNull();
-			Object value = expr.getValue(context);
-			assertThat(value).as("expression '" + expression + "'").isEqualTo(expectedValue);
-		}
-
-
-		record ArrayHolder(String... array) {
-		}
-
-		static class ArrayHolderConverter implements GenericConverter {
-
-			@Nullable
-			@Override
-			public Set<ConvertiblePair> getConvertibleTypes() {
-				return Set.of(new ConvertiblePair(ArrayHolder.class, Object[].class));
-			}
-
-			@Nullable
-			@Override
-			public String[] convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
-				return ((ArrayHolder) source).array();
-			}
-		}
-
-	}
-
 }

spring-messaging/src/main/java/org/springframework/messaging/simp/user/UserDestinationMessageHandler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -20,6 +20,7 @@ import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.apache.commons.logging.Log;
@@ -280,10 +281,12 @@ public class UserDestinationMessageHandler implements MessageHandler, SmartLifec
 			return this.messagingTemplate;
 		}
 
-		public void send(UserDestinationResult result, Message<?> message) throws MessagingException {
-			Iterator<String> itr = result.getSessionIds().iterator();
-			for (String target : result.getTargetDestinations()) {
-				String sessionId = (itr.hasNext() ? itr.next() : null);
+		public void send(UserDestinationResult destinationResult, Message<?> message) throws MessagingException {
+			Set<String> sessionIds = destinationResult.getSessionIds();
+			Iterator<String> itr = (sessionIds != null ? sessionIds.iterator() : null);
+
+			for (String target : destinationResult.getTargetDestinations()) {
+				String sessionId = (itr != null ? itr.next() : null);
 				getTemplateToUse(sessionId).send(target, message);
 			}
 		}

spring-messaging/src/main/java/org/springframework/messaging/simp/user/UserDestinationResult.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -44,11 +44,7 @@ public class UserDestinationResult {
 	private final Set<String> sessionIds;
 
 
-	/**
-	 * Main constructor.
-	 */
-	public UserDestinationResult(
-			String sourceDestination, Set<String> targetDestinations,
+	public UserDestinationResult(String sourceDestination, Set<String> targetDestinations,
 			String subscribeDestination, @Nullable String user) {
 
 		this(sourceDestination, targetDestinations, subscribeDestination, user, null);
@@ -118,6 +114,7 @@ public class UserDestinationResult {
 	/**
 	 * Return the session id for the targetDestination.
 	 */
+	@Nullable
 	public Set<String> getSessionIds() {
 		return this.sessionIds;
 	}

spring-messaging/src/test/java/org/springframework/messaging/simp/user/UserDestinationMessageHandlerTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -17,7 +17,6 @@
 package org.springframework.messaging.simp.user;
 
 import java.nio.charset.StandardCharsets;
-import java.util.Set;
 
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
@@ -99,26 +98,6 @@ class UserDestinationMessageHandlerTests {
 		assertThat(accessor.getFirstNativeHeader(ORIGINAL_DESTINATION)).isEqualTo("/user/queue/foo");
 	}
 
-	@Test
-	@SuppressWarnings("rawtypes")
-	void handleMessageWithoutSessionIds() {
-		UserDestinationResolver resolver = mock();
-		Message message = createWith(SimpMessageType.MESSAGE, "joe", null, "/user/joe/queue/foo");
-		UserDestinationResult result = new UserDestinationResult("/queue/foo-user123", Set.of("/queue/foo-user123"), "/user/queue/foo", "joe");
-		given(resolver.resolveDestination(message)).willReturn(result);
-
-		given(this.brokerChannel.send(Mockito.any(Message.class))).willReturn(true);
-		UserDestinationMessageHandler handler = new UserDestinationMessageHandler(new StubMessageChannel(), this.brokerChannel, resolver);
-		handler.handleMessage(message);
-
-		ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class);
-		Mockito.verify(this.brokerChannel).send(captor.capture());
-
-		SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.wrap(captor.getValue());
-		assertThat(accessor.getDestination()).isEqualTo("/queue/foo-user123");
-		assertThat(accessor.getFirstNativeHeader(ORIGINAL_DESTINATION)).isEqualTo("/user/queue/foo");
-	}
-
 	@Test
 	@SuppressWarnings("rawtypes")
 	void handleMessageWithoutActiveSession() {

spring-test/src/main/java/org/springframework/test/context/TestContextManager.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -389,8 +389,8 @@ public class TestContextManager {
 	 * have executed, the first caught exception will be rethrown with any
 	 * subsequent exceptions {@linkplain Throwable#addSuppressed suppressed} in
 	 * the first exception.
-	 * <p>Note that listeners will be executed in the opposite order in which they
-	 * were registered.
+	 * <p>Note that registered listeners will be executed in the opposite
+	 * order in which they were registered.
 	 * @param testInstance the current test instance
 	 * @param testMethod the test method which has just been executed on the
 	 * test instance
@@ -459,8 +459,7 @@ public class TestContextManager {
 	 * have executed, the first caught exception will be rethrown with any
 	 * subsequent exceptions {@linkplain Throwable#addSuppressed suppressed} in
 	 * the first exception.
-	 * <p>Note that listeners will be executed in the opposite order in which they
-	 * were registered.
+	 * <p>Note that registered listeners will be executed in the opposite
 	 * @param testInstance the current test instance
 	 * @param testMethod the test method which has just been executed on the
 	 * test instance
@@ -518,8 +517,7 @@ public class TestContextManager {
 	 * have executed, the first caught exception will be rethrown with any
 	 * subsequent exceptions {@linkplain Throwable#addSuppressed suppressed} in
 	 * the first exception.
-	 * <p>Note that listeners will be executed in the opposite order in which they
-	 * were registered.
+	 * <p>Note that registered listeners will be executed in the opposite
 	 * @throws Exception if a registered TestExecutionListener throws an exception
 	 * @since 3.0
 	 * @see #getTestExecutionListeners()

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideBeanFactoryPostProcessor.java

@@ -59,7 +59,6 @@ import org.springframework.util.Assert;
  * @author Simon Baslé
  * @author Stephane Nicoll
  * @author Sam Brannen
- * @author Yanming Zhou
  * @since 6.2
  */
 class BeanOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
@@ -169,10 +168,8 @@ class BeanOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor,
 			}
 			else if (requireExistingBean) {
 				Field field = handler.getField();
-				throw new IllegalStateException("""
-						Unable to replace bean: there is no bean with name '%s' and type %s%s. \
-						If the bean is defined in a @Bean method, make sure the return type is the \
-						most specific type possible (for example, the concrete implementation type)."""
+				throw new IllegalStateException(
+						"Unable to replace bean: there is no bean with name '%s' and type %s%s."
 							.formatted(beanName, handler.getBeanType(), requiredByField(field)));
 			}
 			// 4) We are creating a bean by-name with the provided beanName.
@@ -252,25 +249,26 @@ class BeanOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor,
 		if (beanName == null) {
 			// We are wrapping an existing bean by-type.
 			Set<String> candidateNames = getExistingBeanNamesByType(beanFactory, handler, true);
-			String uniqueCandidate = determineUniqueCandidate(beanFactory, candidateNames, beanType, field);
-			if (uniqueCandidate != null) {
-				beanName = uniqueCandidate;
+			int candidateCount = candidateNames.size();
+			if (candidateCount == 1) {
+				beanName = candidateNames.iterator().next();
 			}
 			else {
-				String message = "Unable to select a bean to wrap: ";
-				int candidateCount = candidateNames.size();
-				if (candidateCount == 0) {
-					message += """
-							there are no beans of type %s%s. \
-							If the bean is defined in a @Bean method, make sure the return type is the \
-							most specific type possible (for example, the concrete implementation type)."""
-								.formatted(beanType, requiredByField(field));
+				String primaryCandidate = determinePrimaryCandidate(beanFactory, candidateNames, beanType.toClass());
+				if (primaryCandidate != null) {
+					beanName = primaryCandidate;
 				}
 				else {
-					message += "found %d beans of type %s%s: %s"
-							.formatted(candidateCount, beanType, requiredByField(field), candidateNames);
+					String message = "Unable to select a bean to wrap: ";
+					if (candidateCount == 0) {
+						message += "there are no beans of type %s%s.".formatted(beanType, requiredByField(field));
+					}
+					else {
+						message += "found %d beans of type %s%s: %s"
+								.formatted(candidateCount, beanType, requiredByField(field), candidateNames);
+					}
+					throw new IllegalStateException(message);
 				}
-				throw new IllegalStateException(message);
 			}
 			beanName = BeanFactoryUtils.transformedBeanName(beanName);
 		}
@@ -278,10 +276,8 @@ class BeanOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor,
 			// We are wrapping an existing bean by-name.
 			Set<String> candidates = getExistingBeanNamesByType(beanFactory, handler, false);
 			if (!candidates.contains(beanName)) {
-				throw new IllegalStateException("""
-						Unable to wrap bean: there is no bean with name '%s' and type %s%s. \
-						If the bean is defined in a @Bean method, make sure the return type is the \
-						most specific type possible (for example, the concrete implementation type)."""
+				throw new IllegalStateException(
+						"Unable to wrap bean: there is no bean with name '%s' and type %s%s."
 							.formatted(beanName, beanType, requiredByField(field)));
 			}
 		}
@@ -291,37 +287,38 @@ class BeanOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor,
 	}
 
 	@Nullable
-	private static String getBeanNameForType(ConfigurableListableBeanFactory beanFactory, BeanOverrideHandler handler,
+	private String getBeanNameForType(ConfigurableListableBeanFactory beanFactory, BeanOverrideHandler handler,
 			boolean requireExistingBean) {
 
 		Field field = handler.getField();
 		ResolvableType beanType = handler.getBeanType();
 
 		Set<String> candidateNames = getExistingBeanNamesByType(beanFactory, handler, true);
-		String uniqueCandidate = determineUniqueCandidate(beanFactory, candidateNames, beanType, field);
-		if (uniqueCandidate != null) {
-			return uniqueCandidate;
-		}
-
 		int candidateCount = candidateNames.size();
-		if (candidateCount == 0) {
+		if (candidateCount == 1) {
+			return candidateNames.iterator().next();
+		}
+		else if (candidateCount == 0) {
 			if (requireExistingBean) {
-				throw new IllegalStateException("""
-						Unable to override bean: there are no beans of type %s%s. \
-						If the bean is defined in a @Bean method, make sure the return type is the \
-						most specific type possible (for example, the concrete implementation type)."""
+				throw new IllegalStateException(
+						"Unable to override bean: there are no beans of type %s%s."
 							.formatted(beanType, requiredByField(field)));
 			}
 			return null;
 		}
 
+		String primaryCandidate = determinePrimaryCandidate(beanFactory, candidateNames, beanType.toClass());
+		if (primaryCandidate != null) {
+			return primaryCandidate;
+		}
+
 		throw new IllegalStateException(
 				"Unable to select a bean to override: found %d beans of type %s%s: %s"
 					.formatted(candidateCount, beanType, requiredByField(field), candidateNames));
 	}
 
-	private static Set<String> getExistingBeanNamesByType(ConfigurableListableBeanFactory beanFactory,
-			BeanOverrideHandler handler, boolean checkAutowiredCandidate) {
+	private Set<String> getExistingBeanNamesByType(ConfigurableListableBeanFactory beanFactory, BeanOverrideHandler handler,
+			boolean checkAutowiredCandidate) {
 
 		Field field = handler.getField();
 		ResolvableType resolvableType = handler.getBeanType();
@@ -348,56 +345,25 @@ class BeanOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor,
 		// Filter out scoped proxy targets.
 		beanNames.removeIf(ScopedProxyUtils::isScopedTarget);
 
-		return beanNames;
-	}
-
-	/**
-	 * Determine the unique candidate in the given set of bean names.
-	 * <p>Honors both <em>primary</em> and <em>fallback</em> semantics, and
-	 * otherwise matches against the field name as a <em>fallback qualifier</em>.
-	 * @return the name of the unique candidate, or {@code null} if none found
-	 * @since 6.2.3
-	 * @see org.springframework.beans.factory.support.DefaultListableBeanFactory#determineAutowireCandidate
-	 */
-	@Nullable
-	private static String determineUniqueCandidate(ConfigurableListableBeanFactory beanFactory,
-			Set<String> candidateNames, ResolvableType beanType, @Nullable Field field) {
-
-		// Step 0: none or only one
-		int candidateCount = candidateNames.size();
-		if (candidateCount == 0) {
-			return null;
-		}
-		if (candidateCount == 1) {
-			return candidateNames.iterator().next();
-		}
-
-		// Step 1: check primary candidate
-		String primaryCandidate = determinePrimaryCandidate(beanFactory, candidateNames, beanType.toClass());
-		if (primaryCandidate != null) {
-			return primaryCandidate;
-		}
-
-		// Step 2: use the field name as a fallback qualifier
-		if (field != null) {
+		// In case of multiple matches, fall back on the field's name as a last resort.
+		if (field != null && beanNames.size() > 1) {
 			String fieldName = field.getName();
-			if (candidateNames.contains(fieldName)) {
-				return fieldName;
+			if (beanNames.contains(fieldName)) {
+				return Set.of(fieldName);
 			}
 		}
-
-		return null;
+		return beanNames;
 	}
 
 	/**
 	 * Determine the primary candidate in the given set of bean names.
 	 * <p>Honors both <em>primary</em> and <em>fallback</em> semantics.
 	 * @return the name of the primary candidate, or {@code null} if none found
-	 * @see org.springframework.beans.factory.support.DefaultListableBeanFactory#determinePrimaryCandidate
+	 * @see org.springframework.beans.factory.support.DefaultListableBeanFactory#determinePrimaryCandidate(Map, Class)
 	 */
 	@Nullable
-	private static String determinePrimaryCandidate(ConfigurableListableBeanFactory beanFactory,
-			Set<String> candidateBeanNames, Class<?> beanType) {
+	private static String determinePrimaryCandidate(
+			ConfigurableListableBeanFactory beanFactory, Set<String> candidateBeanNames, Class<?> beanType) {
 
 		if (candidateBeanNames.isEmpty()) {
 			return null;

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideHandler.java

@@ -132,7 +132,7 @@ public abstract class BeanOverrideHandler {
 
 	private static List<BeanOverrideHandler> findHandlers(Class<?> testClass, boolean localFieldsOnly) {
 		List<BeanOverrideHandler> handlers = new ArrayList<>();
-		findHandlers(testClass, testClass, handlers, localFieldsOnly, new HashSet<>());
+		findHandlers(testClass, testClass, handlers, localFieldsOnly);
 		return handlers;
 	}
 
@@ -146,30 +146,26 @@ public abstract class BeanOverrideHandler {
 	 * @param testClass the original test class
 	 * @param handlers the list of handlers found
 	 * @param localFieldsOnly whether to search only on local fields within the type hierarchy
-	 * @param visitedEnclosingClasses the set of enclosing classes already visited
 	 * @since 6.2.2
 	 */
 	private static void findHandlers(Class<?> clazz, Class<?> testClass, List<BeanOverrideHandler> handlers,
-			boolean localFieldsOnly, Set<Class<?>> visitedEnclosingClasses) {
+			boolean localFieldsOnly) {
 
 		// 1) Search enclosing class hierarchy.
 		if (!localFieldsOnly && TestContextAnnotationUtils.searchEnclosingClass(clazz)) {
-			Class<?> enclosingClass = clazz.getEnclosingClass();
-			if (visitedEnclosingClasses.add(enclosingClass)) {
-				findHandlers(enclosingClass, testClass, handlers, localFieldsOnly, visitedEnclosingClasses);
-			}
+			findHandlers(clazz.getEnclosingClass(), testClass, handlers, localFieldsOnly);
 		}
 
 		// 2) Search class hierarchy.
 		Class<?> superclass = clazz.getSuperclass();
 		if (superclass != null && superclass != Object.class) {
-			findHandlers(superclass, testClass, handlers, localFieldsOnly, visitedEnclosingClasses);
+			findHandlers(superclass, testClass, handlers, localFieldsOnly);
 		}
 
 		if (!localFieldsOnly) {
 			// 3) Search interfaces.
 			for (Class<?> ifc : clazz.getInterfaces()) {
-				findHandlers(ifc, testClass, handlers, localFieldsOnly, visitedEnclosingClasses);
+				findHandlers(ifc, testClass, handlers, localFieldsOnly);
 			}
 
 			// 4) Process current class.

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideTestExecutionListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 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.
@@ -37,21 +37,15 @@ import org.springframework.test.context.support.DependencyInjectionTestExecution
 public class BeanOverrideTestExecutionListener extends AbstractTestExecutionListener {
 
 	/**
-	 * The {@link #getOrder() order} value for this listener: {@value}.
-	 * @since 6.2.3
-	 */
-	public static final int ORDER = 1950;
-
-	/**
-	 * Returns {@value #ORDER}, which ensures that the {@code BeanOverrideTestExecutionListener}
+	 * Returns {@code 1950}, which ensures that the {@code BeanOverrideTestExecutionListener}
 	 * is ordered after the
 	 * {@link org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener
-	 * DirtiesContextBeforeModesTestExecutionListener} and before the
+	 * DirtiesContextBeforeModesTestExecutionListener} and just before the
 	 * {@link DependencyInjectionTestExecutionListener}.
 	 */
 	@Override
 	public int getOrder() {
-		return ORDER;
+		return 1950;
 	}
 
 	/**

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/AbstractMockitoBeanOverrideHandler.java

@@ -39,7 +39,7 @@ abstract class AbstractMockitoBeanOverrideHandler extends BeanOverrideHandler {
 
 
 	protected AbstractMockitoBeanOverrideHandler(@Nullable Field field, ResolvableType beanType,
-			@Nullable String beanName, BeanOverrideStrategy strategy, MockReset reset) {
+			@Nullable String beanName, BeanOverrideStrategy strategy, @Nullable MockReset reset) {
 
 		super(field, beanType, beanName, strategy);
 		this.reset = (reset != null ? reset : MockReset.AFTER);

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoBean.java

@@ -31,9 +31,9 @@ import org.springframework.test.context.bean.override.BeanOverride;
 
 /**
  * {@code @MockitoBean} is an annotation that can be used in test classes to
- * override a bean in the test's
+ * override beans in a test's
  * {@link org.springframework.context.ApplicationContext ApplicationContext}
- * with a Mockito mock.
+ * using Mockito mocks.
  *
  * <p>{@code @MockitoBean} can be applied in the following ways.
  * <ul>
@@ -49,19 +49,18 @@ import org.springframework.test.context.bean.override.BeanOverride;
  * </ul>
  *
  * <p>When {@code @MockitoBean} is declared on a field, the bean to mock is inferred
- * from the type of the annotated field. If multiple candidates exist in the
- * {@code ApplicationContext}, a {@code @Qualifier} annotation can be declared
- * on the field to help disambiguate. In the absence of a {@code @Qualifier}
- * annotation, the name of the annotated field will be used as a <em>fallback
- * qualifier</em>. Alternatively, you can explicitly specify a bean name to mock
- * by setting the {@link #value() value} or {@link #name() name} attribute.
+ * from the type of the annotated field. If multiple candidates exist, a
+ * {@code @Qualifier} annotation can be declared on the field to help disambiguate.
+ * In the absence of a {@code @Qualifier} annotation, the name of the annotated
+ * field will be used as a fallback qualifier. Alternatively, you can explicitly
+ * specify a bean name to mock by setting the {@link #value() value} or
+ * {@link #name() name} attribute.
  *
  * <p>When {@code @MockitoBean} is declared at the type level, the type of bean
- * (or beans) to mock must be supplied via the {@link #types() types} attribute.
- * If multiple candidates exist in the {@code ApplicationContext}, you can
- * explicitly specify a bean name to mock by setting the {@link #name() name}
- * attribute. Note, however, that the {@code types} attribute must contain a
- * single type if an explicit bean {@code name} is configured.
+ * to mock must be supplied via the {@link #types() types} attribute. If multiple
+ * candidates exist, you can explicitly specify a bean name to mock by setting the
+ * {@link #name() name} attribute. Note, however, that the {@code types} attribute
+ * must contain a single type if an explicit bean {@code name} is configured.
  *
  * <p>A bean will be created if a corresponding bean does not exist. However, if
  * you would like for the test to fail when a corresponding bean does not exist,
@@ -112,7 +111,7 @@ import org.springframework.test.context.bean.override.BeanOverride;
 public @interface MockitoBean {
 
 	/**
-	 * Alias for {@link #name() name}.
+	 * Alias for {@link #name()}.
 	 * <p>Intended to be used when no other attributes are needed &mdash; for
 	 * example, {@code @MockitoBean("customBeanName")}.
 	 * @see #name()
@@ -137,7 +136,7 @@ public @interface MockitoBean {
 	 * <p>Each type specified will result in a mock being created and registered
 	 * with the {@code ApplicationContext}.
 	 * <p>Types must be omitted when the annotation is used on a field.
-	 * <p>When {@code @MockitoBean} also defines a {@link #name name}, this attribute
+	 * <p>When {@code @MockitoBean} also defines a {@link #name}, this attribute
 	 * can only contain a single value.
 	 * @return the types to mock
 	 * @since 6.2.2

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoBeanOverrideHandler.java

@@ -113,9 +113,7 @@ class MockitoBeanOverrideHandler extends AbstractMockitoBeanOverrideHandler {
 	}
 
 	@Override
-	protected Object createOverrideInstance(String beanName,
-			@Nullable BeanDefinition existingBeanDefinition, @Nullable Object existingBeanInstance) {
-
+	protected Object createOverrideInstance(String beanName, @Nullable BeanDefinition existingBeanDefinition, @Nullable Object existingBeanInstance) {
 		return createMock(beanName);
 	}
 

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoBeanOverrideProcessor.java

@@ -45,10 +45,8 @@ class MockitoBeanOverrideProcessor implements BeanOverrideProcessor {
 					"The @MockitoBean 'types' attribute must be omitted when declared on a field");
 			return new MockitoBeanOverrideHandler(field, ResolvableType.forField(field, testClass), mockitoBean);
 		}
-		else if (overrideAnnotation instanceof MockitoSpyBean mockitoSpyBean) {
-			Assert.state(mockitoSpyBean.types().length == 0,
-					"The @MockitoSpyBean 'types' attribute must be omitted when declared on a field");
-			return new MockitoSpyBeanOverrideHandler(field, ResolvableType.forField(field, testClass), mockitoSpyBean);
+		else if (overrideAnnotation instanceof MockitoSpyBean spyBean) {
+			return new MockitoSpyBeanOverrideHandler(field, ResolvableType.forField(field, testClass), spyBean);
 		}
 		throw new IllegalStateException("""
 				Invalid annotation passed to MockitoBeanOverrideProcessor: \
@@ -58,34 +56,21 @@ class MockitoBeanOverrideProcessor implements BeanOverrideProcessor {
 
 	@Override
 	public List<BeanOverrideHandler> createHandlers(Annotation overrideAnnotation, Class<?> testClass) {
-		if (overrideAnnotation instanceof MockitoBean mockitoBean) {
-			Class<?>[] types = mockitoBean.types();
-			Assert.state(types.length > 0,
-					"The @MockitoBean 'types' attribute must not be empty when declared on a class");
-			Assert.state(mockitoBean.name().isEmpty() || types.length == 1,
-					"The @MockitoBean 'name' attribute cannot be used when mocking multiple types");
-			List<BeanOverrideHandler> handlers = new ArrayList<>();
-			for (Class<?> type : types) {
-				handlers.add(new MockitoBeanOverrideHandler(ResolvableType.forClass(type), mockitoBean));
-			}
-			return handlers;
+		if (!(overrideAnnotation instanceof MockitoBean mockitoBean)) {
+			throw new IllegalStateException("""
+					Invalid annotation passed to MockitoBeanOverrideProcessor: \
+					expected @MockitoBean on test class """ + testClass.getName());
 		}
-		else if (overrideAnnotation instanceof MockitoSpyBean mockitoSpyBean) {
-			Class<?>[] types = mockitoSpyBean.types();
-			Assert.state(types.length > 0,
-					"The @MockitoSpyBean 'types' attribute must not be empty when declared on a class");
-			Assert.state(mockitoSpyBean.name().isEmpty() || types.length == 1,
-					"The @MockitoSpyBean 'name' attribute cannot be used when mocking multiple types");
-			List<BeanOverrideHandler> handlers = new ArrayList<>();
-			for (Class<?> type : types) {
-				handlers.add(new MockitoSpyBeanOverrideHandler(ResolvableType.forClass(type), mockitoSpyBean));
-			}
-			return handlers;
+		Class<?>[] types = mockitoBean.types();
+		Assert.state(types.length > 0,
+				"The @MockitoBean 'types' attribute must not be empty when declared on a class");
+		Assert.state(mockitoBean.name().isEmpty() || types.length == 1,
+				"The @MockitoBean 'name' attribute cannot be used when mocking multiple types");
+		List<BeanOverrideHandler> handlers = new ArrayList<>();
+		for (Class<?> type : types) {
+			handlers.add(new MockitoBeanOverrideHandler(ResolvableType.forClass(type), mockitoBean));
 		}
-		throw new IllegalStateException("""
-				Invalid annotation passed to MockitoBeanOverrideProcessor: \
-				expected either @MockitoBean or @MockitoSpyBean on test class %s"""
-					.formatted(testClass.getName()));
+		return handlers;
 	}
 
 }

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoResetTestExecutionListener.java

@@ -49,13 +49,6 @@ import org.springframework.util.ClassUtils;
  */
 public class MockitoResetTestExecutionListener extends AbstractTestExecutionListener {
 
-	/**
-	 * The {@link #getOrder() order} value for this listener
-	 * ({@code Ordered.LOWEST_PRECEDENCE - 100}): {@value}.
-	 * @since 6.2.3
-	 */
-	public static final int ORDER = Ordered.LOWEST_PRECEDENCE - 100;
-
 	private static final Log logger = LogFactory.getLog(MockitoResetTestExecutionListener.class);
 
 	/**
@@ -81,10 +74,7 @@ public class MockitoResetTestExecutionListener extends AbstractTestExecutionList
 
 
 	/**
-	 * Returns {@value #ORDER}, which ensures that the
-	 * {@code MockitoResetTestExecutionListener} is ordered after all standard
-	 * {@code TestExecutionListener} implementations.
-	 * @see #ORDER
+	 * Returns {@code Ordered.LOWEST_PRECEDENCE - 100}.
 	 */
 	@Override
 	public int getOrder() {

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBean.java

@@ -18,7 +18,6 @@ package org.springframework.test.context.bean.override.mockito;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
-import java.lang.annotation.Repeatable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
@@ -27,40 +26,19 @@ import org.springframework.core.annotation.AliasFor;
 import org.springframework.test.context.bean.override.BeanOverride;
 
 /**
- * {@code @MockitoSpyBean} is an annotation that can be used in test classes to
- * override a bean in the test's
+ * {@code @MockitoSpyBean} is an annotation that can be applied to a non-static
+ * field in a test class to override a bean in the test's
  * {@link org.springframework.context.ApplicationContext ApplicationContext}
  * with a Mockito spy that wraps the original bean instance.
  *
- * <p>{@code @MockitoSpyBean} can be applied in the following ways.
- * <ul>
- * <li>On a non-static field in a test class or any of its superclasses.</li>
- * <li>On a non-static field in an enclosing class for a {@code @Nested} test class
- * or in any class in the type hierarchy or enclosing class hierarchy above the
- * {@code @Nested} test class.</li>
- * <li>At the type level on a test class or any superclass or implemented interface
- * in the type hierarchy above the test class.</li>
- * <li>At the type level on an enclosing class for a {@code @Nested} test class
- * or on any class or interface in the type hierarchy or enclosing class hierarchy
- * above the {@code @Nested} test class.</li>
- * </ul>
- *
- * <p>When {@code @MockitoSpyBean} is declared on a field, the bean to spy is
- * inferred from the type of the annotated field. If multiple candidates exist in
- * the {@code ApplicationContext}, a {@code @Qualifier} annotation can be declared
- * on the field to help disambiguate. In the absence of a {@code @Qualifier}
- * annotation, the name of the annotated field will be used as a <em>fallback
- * qualifier</em>. Alternatively, you can explicitly specify a bean name to spy
- * by setting the {@link #value() value} or {@link #name() name} attribute. If a
- * bean name is specified, it is required that a target bean with that name has
- * been previously registered in the application context.
- *
- * <p>When {@code @MockitoSpyBean} is declared at the type level, the type of bean
- * (or beans) to spy must be supplied via the {@link #types() types} attribute.
- * If multiple candidates exist in the {@code ApplicationContext}, you can
- * explicitly specify a bean name to spy by setting the {@link #name() name}
- * attribute. Note, however, that the {@code types} attribute must contain a
- * single type if an explicit bean {@code name} is configured.
+ * <p>By default, the bean to spy is inferred from the type of the annotated
+ * field. If multiple candidates exist, a {@code @Qualifier} annotation can be
+ * used to help disambiguate. In the absence of a {@code @Qualifier} annotation,
+ * the name of the annotated field will be used as a fallback qualifier.
+ * Alternatively, you can explicitly specify a bean name to spy by setting the
+ * {@link #value() value} or {@link #name() name} attribute. If a bean name is
+ * specified, it is required that a target bean with that name has been previously
+ * registered in the application context.
  *
  * <p>A spy cannot be created for components which are known to the application
  * context but are not beans &mdash; for example, components
@@ -78,33 +56,24 @@ import org.springframework.test.context.bean.override.BeanOverride;
  * (default visibility), or {@code private} depending on the needs or coding
  * practices of the project.
  *
- * <p>{@code @MockitoSpyBean} fields and type-level {@code @MockitoSpyBean} declarations
- * will be inherited from an enclosing test class by default. See
- * {@link org.springframework.test.context.NestedTestConfiguration @NestedTestConfiguration}
+ * <p>{@code @MockitoSpyBean} fields will be inherited from an enclosing test class by default.
+ * See {@link org.springframework.test.context.NestedTestConfiguration @NestedTestConfiguration}
  * for details.
  *
- * <p>{@code @MockitoSpyBean} may be used as a <em>meta-annotation</em> to create
- * custom <em>composed annotations</em> &mdash; for example, to define common spy
- * configuration in a single annotation that can be reused across a test suite.
- * {@code @MockitoSpyBean} can also be used as a <em>{@linkplain Repeatable repeatable}</em>
- * annotation at the type level &mdash; for example, to spy on several beans by
- * {@link #name() name}.
- *
  * @author Simon Baslé
  * @author Sam Brannen
  * @since 6.2
  * @see org.springframework.test.context.bean.override.mockito.MockitoBean @MockitoBean
  * @see org.springframework.test.context.bean.override.convention.TestBean @TestBean
  */
-@Target({ElementType.FIELD, ElementType.TYPE})
+@Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
-@Repeatable(MockitoSpyBeans.class)
 @BeanOverride(MockitoBeanOverrideProcessor.class)
 public @interface MockitoSpyBean {
 
 	/**
-	 * Alias for {@link #name() name}.
+	 * Alias for {@link #name()}.
 	 * <p>Intended to be used when no other attributes are needed &mdash; for
 	 * example, {@code @MockitoSpyBean("customBeanName")}.
 	 * @see #name()
@@ -115,27 +84,13 @@ public @interface MockitoSpyBean {
 	/**
 	 * Name of the bean to spy.
 	 * <p>If left unspecified, the bean to spy is selected according to the
-	 * configured {@link #types() types} or the annotated field's type, taking
-	 * qualifiers into account if necessary. See the {@linkplain MockitoSpyBean
-	 * class-level documentation} for details.
+	 * annotated field's type, taking qualifiers into account if necessary. See
+	 * the {@linkplain MockitoSpyBean class-level documentation} for details.
 	 * @see #value()
 	 */
 	@AliasFor("value")
 	String name() default "";
 
-	/**
-	 * One or more types to spy.
-	 * <p>Defaults to none.
-	 * <p>Each type specified will result in a spy being created and registered
-	 * with the {@code ApplicationContext}.
-	 * <p>Types must be omitted when the annotation is used on a field.
-	 * <p>When {@code @MockitoSpyBean} also defines a {@link #name name}, this
-	 * attribute can only contain a single value.
-	 * @return the types to spy
-	 * @since 6.2.3
-	 */
-	Class<?>[] types() default {};
-
 	/**
 	 * The reset mode to apply to the spied bean.
 	 * <p>The default is {@link MockReset#AFTER} meaning that spies are automatically

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanOverrideHandler.java

@@ -48,11 +48,7 @@ class MockitoSpyBeanOverrideHandler extends AbstractMockitoBeanOverrideHandler {
 			new SpringAopBypassingVerificationStartedListener();
 
 
-	MockitoSpyBeanOverrideHandler(ResolvableType typeToSpy, MockitoSpyBean spyBean) {
-		this(null, typeToSpy, spyBean);
-	}
-
-	MockitoSpyBeanOverrideHandler(@Nullable Field field, ResolvableType typeToSpy, MockitoSpyBean spyBean) {
+	MockitoSpyBeanOverrideHandler(Field field, ResolvableType typeToSpy, MockitoSpyBean spyBean) {
 		super(field, typeToSpy, (StringUtils.hasText(spyBean.name()) ? spyBean.name() : null),
 				BeanOverrideStrategy.WRAP, spyBean.reset());
 		Assert.notNull(typeToSpy, "typeToSpy must not be null");

spring-test/src/main/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeans.java

@@ -1,41 +0,0 @@
-/*
- * Copyright 2002-2025 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.test.context.bean.override.mockito;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Container for {@link MockitoSpyBean @MockitoSpyBean} annotations which allows
- * {@code @MockitoSpyBean} to be used as a {@linkplain java.lang.annotation.Repeatable
- * repeatable annotation} at the type level — for example, on test classes
- * or interfaces implemented by test classes.
- *
- * @author Sam Brannen
- * @since 6.2.3
- */
-@Target(ElementType.TYPE)
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-public @interface MockitoSpyBeans {
-
-	MockitoSpyBean[] value();
-
-}

spring-test/src/main/java/org/springframework/test/context/event/ApplicationEventsTestExecutionListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2020 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.
@@ -48,12 +48,6 @@ import org.springframework.util.Assert;
  */
 public class ApplicationEventsTestExecutionListener extends AbstractTestExecutionListener {
 
-	/**
-	 * The {@link #getOrder() order} value for this listener: {@value}.
-	 * @since 6.2.3
-	 */
-	public static final int ORDER = 1800;
-
 	/**
 	 * Attribute name for a {@link TestContext} attribute which indicates
 	 * whether the test class for the given test context is annotated with
@@ -67,18 +61,11 @@ public class ApplicationEventsTestExecutionListener extends AbstractTestExecutio
 
 
 	/**
-	 * Returns {@value #ORDER}, which ensures that the {@code ApplicationEventsTestExecutionListener}
-	 * is ordered after the
-	 * {@link org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener
-	 * DirtiesContextBeforeModesTestExecutionListener} and before the
-	 * {@link org.springframework.test.context.bean.override.BeanOverrideTestExecutionListener
-	 * BeanOverrideTestExecutionListener} and the
-	 * {@link org.springframework.test.context.support.DependencyInjectionTestExecutionListener
-	 * DependencyInjectionTestExecutionListener}.
+	 * Returns {@code 1800}.
 	 */
 	@Override
 	public final int getOrder() {
-		return ORDER;
+		return 1800;
 	}
 
 	@Override

spring-test/src/main/java/org/springframework/test/context/event/EventPublishingTestExecutionListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2022 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.
@@ -98,22 +98,11 @@ import org.springframework.test.context.support.AbstractTestExecutionListener;
 public class EventPublishingTestExecutionListener extends AbstractTestExecutionListener {
 
 	/**
-	 * The {@link #getOrder() order} value for this listener: {@value}.
-	 * @since 6.2.3
-	 */
-	public static final int ORDER = 10_000;
-
-	/**
-	 * Returns {@value #ORDER}, which ensures that the {@code EventPublishingTestExecutionListener}
-	 * is ordered after the
-	 * {@link org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener
-	 * SqlScriptsTestExecutionListener} and before the
-	 * {@link org.springframework.test.context.bean.override.mockito.MockitoResetTestExecutionListener
-	 * MockitoResetTestExecutionListener}.
+	 * Returns {@code 10000}.
 	 */
 	@Override
 	public final int getOrder() {
-		return ORDER;
+		return 10_000;
 	}
 
 	/**