Release v6.2.9

2026-06-08 17:33:33 +00:00 · 2025-07-17 09:26:27 +02:00
522 changed files with 5816 additions and 12626 deletions
@@ -24,14 +24,14 @@ runs:
  using: composite
  steps:
    - name: Set Up Java
-      uses: actions/setup-java@v5
+      uses: actions/setup-java@v4
      with:
        distribution: ${{ inputs.java-early-access == 'true' && 'temurin' || (inputs.java-distribution || 'liberica') }}
        java-version: |
          ${{ 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@4d9f0ba0025fe599b4ebab900eb7f3a1d93ef4c2 # v5.0.0
+      uses: gradle/actions/setup-gradle@ac638b010cf58a27ee6c972d7336334ccaf61c96 # v4.4.1
      with:
        cache-read-only: false
        develocity-access-key: ${{ inputs.develocity-access-key }}
@@ -17,14 +17,14 @@ runs:
  using: composite
  steps:
    - name: Set Up JFrog CLI
-      uses: jfrog/setup-jfrog-cli@5b06f730cc5a6f55d78b30753f8583454b08c0aa # v4.8.1
+      uses: jfrog/setup-jfrog-cli@f748a0599171a192a2668afee8d0497f7c1069df # v4.5.6
      env:
        JF_ENV_SPRING: ${{ inputs.jfrog-cli-config-token }}
    - name: Download Release Artifacts
      shell: bash
      run: jf rt download --spec ${{ format('{0}/artifacts.spec', github.action_path) }} --spec-vars 'buildName=${{ format('spring-framework-{0}', inputs.spring-framework-version) }};buildNumber=${{ github.run_number }}'
    - name: Sync
-      uses: spring-io/central-publish-action@0c03960e9b16fdfe70e2443e1d5393cbc3a35622 # v0.3.0
+      uses: spring-io/central-publish-action@0cdd90d12e6876341e82860d951e1bcddc1e51b6 # v0.2.0
      with:
        token: ${{ inputs.central-token-password }}
        token-name: ${{ inputs.central-token-username }}
@@ -18,9 +18,9 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check out code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
      - name: Set up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
        with:
          distribution: 'liberica'
          java-version: 17
@@ -13,7 +13,7 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
      - name: Build and Publish
        id: build-and-publish
        uses: ./.github/actions/build
@@ -21,7 +21,7 @@ jobs:
          develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
          publish: true
      - name: Deploy
-        uses: spring-io/artifactory-deploy-action@926d7f7cc810569395346bf3a4d91b380b3e355b # v0.0.4
+        uses: spring-io/artifactory-deploy-action@dc1913008c0599f0c4b1fdafb6ff3c502b3565ea # v0.0.2
        with:
          artifact-properties: |
            /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
@@ -10,7 +10,7 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
      - name: Build
        id: build
        uses: ./.github/actions/build
@@ -19,7 +19,7 @@ jobs:
        uses: ./.github/actions/print-jvm-thread-dumps
      - name: Upload Build Reports
        if: failure()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: build-reports
          path: '**/build/reports/'
@@ -21,7 +21,7 @@ jobs:
            toolchain: false
          - version: 21
            toolchain: true
-          - version: 25
+          - version: 23
            toolchain: true
        exclude:
          - os:
@@ -36,7 +36,7 @@ jobs:
          git config --global core.longPaths true
          Stop-Service -name Docker
      - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
      - name: Build
        id: build
        uses: ./.github/actions/build
@@ -19,7 +19,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
    - name: Check out code
-      uses: actions/checkout@v6
+      uses: actions/checkout@v4
      with:
        fetch-depth: 1
        ref: docs-build
@@ -12,7 +12,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
      - name: Build and Publish
        id: build-and-publish
        uses: ./.github/actions/build
@@ -20,7 +20,7 @@ jobs:
          develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
          publish: true
      - name: Stage Release
-        uses: spring-io/artifactory-deploy-action@926d7f7cc810569395346bf3a4d91b380b3e355b # v0.0.4
+        uses: spring-io/artifactory-deploy-action@dc1913008c0599f0c4b1fdafb6ff3c502b3565ea # v0.0.2
        with:
          artifact-properties: |
            /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
@@ -56,7 +56,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
      - name: Sync to Maven Central
        uses: ./.github/actions/sync-to-maven-central
        with:
@@ -72,7 +72,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Set up JFrog CLI
-        uses: jfrog/setup-jfrog-cli@5b06f730cc5a6f55d78b30753f8583454b08c0aa # v4.8.1
+        uses: jfrog/setup-jfrog-cli@dff217c085c17666e8849ebdbf29c8fe5e3995e6 # v4.5.2
        env:
          JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
      - name: Promote build
@@ -85,7 +85,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check Out Code
-        uses: actions/checkout@v6
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
      - name: Create GitHub Release
        uses: ./.github/actions/create-github-release
        with:
@@ -30,23 +30,23 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Check Out Release Verification Tests
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
        with:
          ref: 'v0.0.2'
          repository: spring-projects/spring-framework-release-verification
          token: ${{ secrets.token }}
      - name: Check Out Send Notification Action
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
        with:
          path: send-notification
          sparse-checkout: .github/actions/send-notification
      - name: Set Up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@v4
        with:
          distribution: 'liberica'
          java-version: 17
      - name: Set Up Gradle
-        uses: gradle/actions/setup-gradle@4d9f0ba0025fe599b4ebab900eb7f3a1d93ef4c2 # v5.0.0
+        uses: gradle/actions/setup-gradle@ac638b010cf58a27ee6c972d7336334ccaf61c96 # v4.4.1
        with:
          cache-read-only: false
      - name: Configure Gradle Properties
@@ -64,7 +64,7 @@ jobs:
        run: ./gradlew spring-framework-release-verification-tests:test
      - name: Upload Build Reports on Failure
        if: failure()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v4
        with:
          name: build-reports
          path: '**/build/reports/'
@@ -27,7 +27,7 @@ See the [Build from Source](https://github.com/spring-projects/spring-framework/

 ## Continuous Integration Builds

-CI builds are defined with [GitHub Actions workflows](.github/workflows).
+Information regarding CI builds can be found in the [Spring Framework Concourse pipeline](ci/README.adoc) documentation.

 ## Stay in Touch

@@ -86,19 +86,19 @@ configure([rootProject] + javaProjects) { project ->
 	ext.javadocLinks = [
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
 			"https://jakarta.ee/specifications/platform/9/apidocs/",
-			"https://docs.hibernate.org/orm/5.6/javadocs/",
+			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
 			"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/",
 			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.14/",
-			//"https://hc.apache.org/httpcomponents-client-5.5.x/current/httpclient5/apidocs/",
+			"https://hc.apache.org/httpcomponents-client-5.5.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
 			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
 			// See https://github.com/spring-projects/spring-framework/issues/27497
 			//
-			// "https://junit.org/junit5/docs/5.14.2/api/",
-			"https://www.reactive-streams.org/reactive-streams-1.0.4-javadoc/",
+			// "https://junit.org/junit5/docs/5.13.3/api/",
+			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			//"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
 			// Previously there could be a split-package issue between JSR250 and JSR305 javax.annotation packages,
@@ -13,9 +13,7 @@ content:
  - url: https://github.com/spring-projects/spring-framework
    # Refname matching:
    # https://docs.antora.org/antora/latest/playbook/content-refname-matching/
-    # branches: We include snapshots for main, 6.2.x, and 7.0.x to 9.*.x.
-    branches: ['main', '6.2.x', '{7..9}.+({0..9}).x']
-    # tags: We effectively include all releases from 6.0.9 to 9.*.*.
+    branches: ['main', '{6..9}.+({1..9}).x']
    tags: ['v{6..9}.+({0..9}).+({0..9})?(-{RC,M}*)', '!(v6.0.{0..8})', '!(v6.0.0-{RC,M}{0..9})']
    start_path: framework-docs
 asciidoc:
@@ -38,4 +36,4 @@ runtime:
    failure_level: warn
 ui:
  bundle:
-    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.25/ui-bundle.zip
+    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.18/ui-bundle.zip
@@ -104,7 +104,7 @@ Note that pointcut definitions are generally matched against any intercepted met
 If a pointcut is strictly meant to be public-only, even in a CGLIB proxy scenario with
 potential non-public interactions through proxies, it needs to be defined accordingly.

-If your interception needs to include method calls or even constructors within the target
+If your interception needs include method calls or even constructors within the target
 class, consider the use of Spring-driven xref:core/aop/using-aspectj.adoc#aop-aj-ltw[native AspectJ weaving] instead
 of Spring's proxy-based AOP framework. This constitutes a different mode of AOP usage
 with different characteristics, so be sure to make yourself familiar with weaving
@@ -1,26 +1,24 @@
 [[beans-classpath-scanning]]
 = Classpath Scanning and Managed Components

-Most examples in this chapter use XML to specify the configuration metadata that
-produces each `BeanDefinition` within the Spring container. The previous section
-(xref:core/beans/annotation-config.adoc[Annotation-based Container Configuration])
-demonstrates how to provide a lot of the configuration metadata through source-level
-annotations. Even in those examples, however, the "base" bean definitions are explicitly
-defined in the XML file, while the annotations drive only the dependency injection.
-
-This section describes an option for implicitly detecting the candidate components by
-scanning the classpath. Candidate components are classes that match against a filter
-criteria and have a corresponding bean definition registered with the container.
-This removes the need to use XML to perform bean registration. Instead, you can use
-annotations (for example, `@Component`), AspectJ type expressions, or your own
+Most examples in this chapter use XML to specify the configuration metadata that produces
+each `BeanDefinition` within the Spring container. The previous section
+(xref:core/beans/annotation-config.adoc[Annotation-based Container Configuration]) demonstrates how to provide a lot of the configuration
+metadata through source-level annotations. Even in those examples, however, the "base"
+bean definitions are explicitly defined in the XML file, while the annotations drive only
+the dependency injection. This section describes an option for implicitly detecting the
+candidate components by scanning the classpath. Candidate components are classes that
+match against a filter criteria and have a corresponding bean definition registered with
+the container. This removes the need to use XML to perform bean registration. Instead, you
+can use annotations (for example, `@Component`), AspectJ type expressions, or your own
 custom filter criteria to select which classes have bean definitions registered with
 the container.

 [NOTE]
 ====
 You can define beans using Java rather than using XML files. Take a look at the
-`@Configuration`, `@Bean`, `@Import`, and `@DependsOn` annotations for examples
-of how to use these features.
+`@Configuration`, `@Bean`, `@Import`, and `@DependsOn` annotations for examples of how to
+use these features.
 ====


@@ -832,10 +830,10 @@ definitions, there is no notion of bean definition inheritance, and inheritance
 hierarchies at the class level are irrelevant for metadata purposes.

 For details on web-specific scopes such as "`request`" or "`session`" in a Spring context,
-see xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other[Request, Session, Application, and WebSocket Scopes].
-As with the pre-built annotations for those scopes, you may also compose your own scoping
-annotations by using Spring's meta-annotation approach: for example, a custom annotation
-meta-annotated with `@Scope("prototype")`, possibly also declaring a custom scoped-proxy mode.
+see xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other[Request, Session, Application, and WebSocket Scopes]. As with the pre-built annotations for those scopes,
+you may also compose your own scoping annotations by using Spring's meta-annotation
+approach: for example, a custom annotation meta-annotated with `@Scope("prototype")`,
+possibly also declaring a custom scoped-proxy mode.

 NOTE: To provide a custom strategy for scope resolution rather than relying on the
 annotation-based approach, you can implement the
@@ -877,8 +875,7 @@ Kotlin::
 ----

 When using certain non-singleton scopes, it may be necessary to generate proxies for the
-scoped objects. The reasoning is described in
-xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other-injection[Scoped Beans as Dependencies].
+scoped objects. The reasoning is described in xref:core/beans/factory-scopes.adoc#beans-factory-scopes-other-injection[Scoped Beans as Dependencies].
 For this purpose, a scoped-proxy attribute is available on the component-scan
 element. The three possible values are: `no`, `interfaces`, and `targetClass`. For example,
 the following configuration results in standard JDK dynamic proxies:
@@ -50,8 +50,9 @@ XML configuration:

 The preceding XML is more succinct. However, typos are discovered at runtime rather than
 design time, unless you use an IDE (such as https://www.jetbrains.com/idea/[IntelliJ
-IDEA] or the {spring-site-tools}[Spring Tools]) that supports automatic property
-completion when you create bean definitions. Such IDE assistance is highly recommended.
+IDEA] or the {spring-site-tools}[Spring Tools for Eclipse])
+that supports automatic property completion when you create bean definitions. Such IDE
+assistance is highly recommended.

 You can also configure a `java.util.Properties` instance, as follows:

@@ -84,11 +85,11 @@ element. The following example shows how to use it:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
-	<bean id="collaborator" class="..." />
+	<bean id="theTargetBean" class="..."/>

-	<bean id="client" class="...">
+	<bean id="theClientBean" class="...">
 		<property name="targetName">
-			<idref bean="collaborator" />
+			<idref bean="theTargetBean"/>
 		</property>
 	</bean>
 ----
@@ -98,24 +99,28 @@ following snippet:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
-	<bean id="collaborator" class="..." />
+	<bean id="theTargetBean" class="..." />

-	<bean id="client" class="...">
-		<property name="targetName" value="collaborator" />
+	<bean id="theClientBean" class="...">
+		<property name="targetName" ref="theTargetBean"/>
 	</bean>
 ----

 The first form is preferable to the second, because using the `idref` tag lets the
-container validate at deployment time that the referenced, named bean actually exists. In
-the second variation, no validation is performed on the value that is passed to the
-`targetName` property of the `client` bean. Typos are therefore only discovered (with most
+container validate at deployment time that the referenced, named bean actually
+exists. In the second variation, no validation is performed on the value that is passed
+to the `targetName` property of the `client` bean. Typos are only discovered (with most
 likely fatal results) when the `client` bean is actually instantiated. If the `client`
-bean is a xref:core/beans/factory-scopes.adoc[prototype] bean, this typo and the resulting
-exception may only be discovered long after the container is deployed.
+bean is a xref:core/beans/factory-scopes.adoc[prototype] bean, this typo and the resulting exception
+may only be discovered long after the container is deployed.

-NOTE: A common place (at least in versions earlier than Spring 2.0) where the `<idref/>`
-element brings value is in the configuration of xref:core/aop-api/pfb.adoc#aop-pfb-1[AOP interceptors]
-in a `ProxyFactoryBean` bean definition. Using `<idref/>` elements when you specify the
+NOTE: The `local` attribute on the `idref` element is no longer supported in the 4.0 beans
+XSD, since it does not provide value over a regular `bean` reference any more. Change
+your existing `idref local` references to `idref bean` when upgrading to the 4.0 schema.
+
+A common place (at least in versions earlier than Spring 2.0) where the `<idref/>` element
+brings value is in the configuration of xref:core/aop-api/pfb.adoc#aop-pfb-1[AOP interceptors] in a
+`ProxyFactoryBean` bean definition. Using `<idref/>` elements when you specify the
 interceptor names prevents you from misspelling an interceptor ID.


@@ -339,11 +339,11 @@ In the preceding scenario, using `@Autowired` works well and provides the desire
 modularity, but determining exactly where the autowired bean definitions are declared is
 still somewhat ambiguous. For example, as a developer looking at `ServiceConfig`, how do
 you know exactly where the `@Autowired AccountRepository` bean is declared? It is not
-explicit in the code, and this may be just fine. Note that the
-{spring-site-tools}[Spring Tools] IDE support provides tooling that can render graphs
-showing how everything is wired, which may be all you need. Also, your Java IDE can
-easily find all declarations and uses of the `AccountRepository` type and quickly show
-you the location of `@Bean` methods that return that type.
+explicit in the code, and this may be just fine. Remember that the
+{spring-site-tools}[Spring Tools for Eclipse] provides tooling that
+can render graphs showing how everything is wired, which may be all you need. Also,
+your Java IDE can easily find all declarations and uses of the `AccountRepository` type
+and quickly show you the location of `@Bean` methods that return that type.

 In cases where this ambiguity is not acceptable and you wish to have direct navigation
 from within your IDE from one `@Configuration` class to another, consider autowiring the
@@ -7,14 +7,14 @@ similar to the https://jakarta.ee/specifications/expression-language/[Jakarta Ex
 Language] but offers additional features, most notably method invocation and basic string
 templating functionality.

-While there are several other Java expression languages available -- OGNL, MVEL, and
-JBoss EL, to name a few -- the Spring Expression Language was created to provide the
-Spring community with a single well supported expression language that can be used across
-all the products in the Spring portfolio. Its language features are driven by the
-requirements of the projects in the Spring portfolio, including tooling requirements for
-code completion within the {spring-site-tools}[Spring Tools] IDE support. That said, SpEL
-is based on a technology-agnostic API that lets other expression language implementations
-be integrated, should the need arise.
+While there are several other Java expression languages available -- OGNL, MVEL, and JBoss
+EL, to name a few -- the Spring Expression Language was created to provide the Spring
+community with a single well supported expression language that can be used across all
+the products in the Spring portfolio. Its language features are driven by the
+requirements of the projects in the Spring portfolio, including tooling requirements
+for code completion support within the {spring-site-tools}[Spring Tools for Eclipse].
+That said, SpEL is based on a technology-agnostic API that lets other expression language
+implementations be integrated, should the need arise.

 While SpEL serves as the foundation for expression evaluation within the Spring
 portfolio, it is not directly tied to Spring and can be used independently. To
@@ -6,7 +6,7 @@ are set by using the `setVariable()` method in `EvaluationContext` implementatio

 [NOTE]
 ====
-Variable names must begin with a letter (as defined below), an underscore, or a dollar
+Variable names must be begin with a letter (as defined below), an underscore, or a dollar
 sign.

 Variable names must be composed of one or more of the following supported types of
@@ -676,7 +676,7 @@ provides `firstName` and `lastName` properties, such as the `Actor` class from a
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.paramSource(new Actor("Leonor", "Watling"))
+			.paramSource(new Actor("Leonor", "Watling")
 			.update();
 ----

@@ -15,7 +15,7 @@ configuration options. You should instantiate the `SimpleJdbcInsert` in the data
 layer's initialization method. For this example, the initializing method is the
 `setDataSource` method. You do not need to subclass the `SimpleJdbcInsert` class. Instead,
 you can create a new instance and set the table name by using the `withTableName` method.
-Configuration methods for this class follow the `fluent` style that returns the instance
+Configuration methods for this class follow the `fluid` style that returns the instance
 of the `SimpleJdbcInsert`, which lets you chain all configuration methods. The following
 example uses only one configuration method (we show examples of multiple methods later):

@@ -349,11 +349,11 @@ parameters return the data read from the table.

 You can declare `SimpleJdbcCall` in a manner similar to declaring `SimpleJdbcInsert`. You
 should instantiate and configure the class in the initialization method of your data-access
-layer. In contrast to the `StoredProcedure` class, you do not need to create a subclass,
-and you do not need to declare parameters that can be looked up in the database metadata.
-The following `SimpleJdbcCall` configuration example uses the preceding stored procedure.
-The only configuration option (other than the `DataSource`) is the name of the stored
-procedure.
+layer. Compared to the `StoredProcedure` class, you need not create a subclass
+and you need not to declare parameters that can be looked up in the database metadata.
+The following example of a `SimpleJdbcCall` configuration uses the preceding stored
+procedure (the only configuration option, in addition to the `DataSource`, is the name
+of the stored procedure):

 [tabs]
 ======
@@ -1,11 +1,16 @@
 [[appendix]]
 = Appendix

+
+
+
 [[appendix.xsd-schemas]]
 == XML Schemas

 This part of the appendix lists XML schemas related to integration technologies.

+
+
 [[appendix.xsd-schemas-jee]]
 === The `jee` Schema

@@ -167,7 +172,7 @@ different properties with `jee`:

 The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless Session Bean.

-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 without `jee`:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -179,7 +184,7 @@ without `jee`:
 	</bean>
 ----

-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 with `jee`:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -195,7 +200,7 @@ with `jee`:

 The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless Session Bean.

-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 and a number of properties without `jee`:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -210,7 +215,7 @@ and a number of properties without `jee`:
 	</bean>
 ----

-The following example shows how to configure a reference to a local EJB Stateless Session Bean
+The following example shows how to configures a reference to a local EJB Stateless Session Bean
 and a number of properties with `jee`:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -229,7 +234,7 @@ and a number of properties with `jee`:

 The `<jee:remote-slsb/>` element configures a reference to a `remote` EJB Stateless Session Bean.

-The following example shows how to configure a reference to a remote EJB Stateless Session Bean
+The following example shows how to configures a reference to a remote EJB Stateless Session Bean
 without `jee`:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -246,7 +251,7 @@ without `jee`:
 	</bean>
 ----

-The following example shows how to configure a reference to a remote EJB Stateless Session Bean
+The following example shows how to configures a reference to a remote EJB Stateless Session Bean
 with `jee`:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -308,7 +313,7 @@ xref:integration/jmx/naming.adoc#jmx-context-mbeanexport[Configuring Annotation-
 === The `cache` Schema

 You can use the `cache` elements to enable support for Spring's `@CacheEvict`, `@CachePut`,
-and `@Caching` annotations. The `cache` schema also supports declarative XML-based caching. See
+and `@Caching` annotations. It it also supports declarative XML-based caching. See
 xref:integration/cache/annotations.adoc#cache-annotation-enable[Enabling Caching Annotations] and
 xref:integration/cache/declarative-xml.adoc[Declarative XML-based Caching] for details.

@@ -13,4 +13,4 @@ running the Kotlin compiler with its `-java-parameters` flag for standard Java p

 You can declare configuration classes as
 {kotlin-docs}/nested-classes.html[top level or nested but not inner],
-since the latter requires a reference to the outer class.
+since the later requires a reference to the outer class.
@@ -319,17 +319,9 @@ progresses.
 == Testing

 This section addresses testing with the combination of Kotlin and Spring Framework.
-The recommended testing framework is https://junit.org/[JUnit Jupiter] along with
+The recommended testing framework is https://junit.org/junit5/[JUnit 5] along with
 https://mockk.io/[Mockk] for mocking.

-[TIP]
-====
-Kotlin lets you specify meaningful test function names between backticks (```).
-
-For a concrete example, see the `+++`Find all users on HTML page`()+++` test function later
-in this section.
-====
-
 NOTE: If you are using Spring Boot, see
 {spring-boot-docs-ref}/features/kotlin.html#features.kotlin.testing[this related documentation].

@@ -360,6 +352,7 @@ file with a `spring.test.constructor.autowire.mode = all` property.
 [[per_class-lifecycle]]
 === `PER_CLASS` Lifecycle

+Kotlin lets you specify meaningful test function names between backticks (```).
 With JUnit Jupiter (JUnit 5), Kotlin test classes can use the `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`
 annotation to enable single instantiation of test classes, which allows the use of `@BeforeAll`
 and `@AfterAll` annotations on non-static methods, which is a good fit for Kotlin.
@@ -187,7 +187,7 @@ default mode may be set via the
 xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.

 The default mode may also be configured as a
-https://docs.junit.org/current/running-tests/configuration-parameters.html[JUnit Platform configuration parameter].
+https://junit.org/junit5/docs/current/user-guide/#running-tests-config-params[JUnit Platform configuration parameter].

 If the `spring.test.constructor.autowire.mode` property is not set, test class
 constructors will not be automatically autowired.
@@ -77,17 +77,6 @@ exactly one candidate bean exists.

 [TIP]
 ====
-As stated in the documentation for Mockito, there are times when using `Mockito.when()` is
-inappropriate for stubbing a spy – for example, if calling a real method on a spy results
-in undesired side effects.
-
-To avoid such undesired side effects, consider using
-`Mockito.doReturn(...).when(spy)...`, `Mockito.doThrow(...).when(spy)...`,
-`Mockito.doNothing().when(spy)...`, and similar methods.
-====
-
-[NOTE]
-====
 Only _singleton_ beans can be overridden. Any attempt to override a non-singleton bean
 will result in an exception.

@@ -5,25 +5,24 @@ It is important to be able to perform some integration testing without requiring
 deployment to your application server or connecting to other enterprise infrastructure.
 Doing so lets you test things such as:

-* The correct wiring of your Spring components.
-* Data access using JDBC or an ORM tool.
-  ** This can include such things as the correctness of SQL statements, Hibernate queries,
-     JPA entity mappings, and so forth.
+* The correct wiring of your Spring IoC container contexts.
+* Data access using JDBC or an ORM tool. This can include such things as the correctness
+  of SQL statements, Hibernate queries, JPA entity mappings, and so forth.

 The Spring Framework provides first-class support for integration testing in the
-`spring-test` module. The name of the actual JAR file might include the release version,
-depending on where you get it from (see the
-{spring-framework-wiki}/Spring-Framework-Artifacts[Spring Framework Artifacts] wiki page
-for details). This library includes the `org.springframework.test` package, which
+`spring-test` module. The name of the actual JAR file might include the release version
+and might also be in the long `org.springframework.test` form, depending on where you get
+it from (see the xref:core/beans/dependencies.adoc[section on Dependency Management]
+for an explanation). This library includes the `org.springframework.test` package, which
 contains valuable classes for integration testing with a Spring container. This testing
 does not rely on an application server or other deployment environment. Such tests are
 slower to run than unit tests but much faster than the equivalent Selenium tests or
 remote tests that rely on deployment to an application server.

 Unit and integration testing support is provided in the form of the annotation-driven
-xref:testing/testcontext-framework.adoc[Spring TestContext Framework]. The TestContext
-framework is agnostic of the actual testing framework in use, which allows
-instrumentation of tests in various environments, including JUnit, TestNG, and others.
+xref:testing/testcontext-framework.adoc[Spring TestContext Framework]. The TestContext framework is
+agnostic of the actual testing framework in use, which allows instrumentation of tests
+in various environments, including JUnit, TestNG, and others.

 The following section provides an overview of the high-level goals of Spring's
 integration support, and the rest of this chapter then focuses on dedicated topics:
@@ -8,9 +8,9 @@ use https://www.gebish.org/[Geb] to make our tests even Groovy-er.
 == Why Geb and MockMvc?

 Geb is backed by WebDriver, so it offers many of the
-xref:testing/mockmvc/htmlunit/webdriver.adoc#mockmvc-server-htmlunit-webdriver-why[same benefits]
-that we get from WebDriver. However, Geb makes things even easier by taking care of some
-of the boilerplate code for us.
+xref:testing/mockmvc/htmlunit/webdriver.adoc#spring-mvc-test-server-htmlunit-webdriver-why[same benefits] that we get from
+WebDriver. However, Geb makes things even easier by taking care of some of the
+boilerplate code for us.

 [[mockmvc-server-htmlunit-geb-setup]]
 == MockMvc and Geb Setup
@@ -28,8 +28,7 @@ def setup() {
 ----

 NOTE: This is a simple example of using `MockMvcHtmlUnitDriverBuilder`. For more advanced
-usage, see
-xref:testing/mockmvc/htmlunit/webdriver.adoc#mockmvc-server-htmlunit-webdriver-advanced-builder[Advanced `MockMvcHtmlUnitDriverBuilder`].
+usage, see xref:testing/mockmvc/htmlunit/webdriver.adoc#spring-mvc-test-server-htmlunit-webdriver-advanced-builder[Advanced `MockMvcHtmlUnitDriverBuilder`].

 This ensures that any URL referencing `localhost` as the server is directed to our
 `MockMvc` instance without the need for a real HTTP connection. Any other URL is
@@ -63,10 +62,10 @@ forwarded to the current page object. This removes a lot of the boilerplate code
 needed when using WebDriver directly.

 As with direct WebDriver usage, this improves on the design of our
-xref:testing/mockmvc/htmlunit/mah.adoc#mockmvc-server-htmlunit-mah-usage[HtmlUnit test]
-by using the Page Object Pattern. As mentioned previously, we can use the Page Object
-Pattern with HtmlUnit and WebDriver, but it is even easier with Geb. Consider our new
-Groovy-based `CreateMessagePage` implementation:
+xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-usage[HtmlUnit test] by using the Page Object
+Pattern. As mentioned previously, we can use the Page Object Pattern with HtmlUnit and
+WebDriver, but it is even easier with Geb. Consider our new Groovy-based
+`CreateMessagePage` implementation:

 [source,groovy]
 ----
@@ -7,7 +7,8 @@ to use the raw HtmlUnit libraries.
 [[mockmvc-server-htmlunit-mah-setup]]
 == MockMvc and HtmlUnit Setup

-First, make sure that you have included a test dependency on `org.htmlunit:htmlunit`.
+First, make sure that you have included a test dependency on
+`org.htmlunit:htmlunit`.

 We can easily create an HtmlUnit `WebClient` that integrates with MockMvc by using the
 `MockMvcWebClientBuilder`, as follows:
@@ -44,7 +45,7 @@ Kotlin::
 ======

 NOTE: This is a simple example of using `MockMvcWebClientBuilder`. For advanced usage,
-see <<mockmvc-server-htmlunit-mah-advanced-builder>>.
+see xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-advanced-builder[Advanced `MockMvcWebClientBuilder`].

 This ensures that any URL that references `localhost` as the server is directed to our
 `MockMvc` instance without the need for a real HTTP connection. Any other URL is
@@ -76,7 +77,7 @@ Kotlin::
 ======

 NOTE: The default context path is `""`. Alternatively, we can specify the context path,
-as described in <<mockmvc-server-htmlunit-mah-advanced-builder>>.
+as described in xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-advanced-builder[Advanced `MockMvcWebClientBuilder`].

 Once we have a reference to the `HtmlPage`, we can then fill out the form and submit it
 to create a message, as the following example shows:
@@ -143,10 +144,10 @@ Kotlin::
 ======

 The preceding code improves on our
-xref:testing/mockmvc/htmlunit/why.adoc#mockmvc-server-htmlunit-why[MockMvc test] in a
-number of ways. First, we no longer have to explicitly verify our form and then create a
-request that looks like the form. Instead, we request the form, fill it out, and submit
-it, thereby significantly reducing the overhead.
+xref:testing/mockmvc/htmlunit/why.adoc#spring-mvc-test-server-htmlunit-mock-mvc-test[MockMvc test] in a number of ways.
+First, we no longer have to explicitly verify our form and then create a request that
+looks like the form. Instead, we request the form, fill it out, and submit it, thereby
+significantly reducing the overhead.

 Another important factor is that https://htmlunit.sourceforge.io/javascript.html[HtmlUnit
 uses the Mozilla Rhino engine] to evaluate JavaScript. This means that we can also test
@@ -203,7 +203,7 @@ Kotlin::
 ======

 NOTE: This is a simple example of using `MockMvcHtmlUnitDriverBuilder`. For more advanced
-usage, see <<mockmvc-server-htmlunit-webdriver-advanced-builder>>.
+usage, see xref:testing/mockmvc/htmlunit/webdriver.adoc#spring-mvc-test-server-htmlunit-webdriver-advanced-builder[Advanced `MockMvcHtmlUnitDriverBuilder`].

 The preceding example ensures that any URL that references `localhost` as the server is
 directed to our `MockMvc` instance without the need for a real HTTP connection. Any other
@@ -259,11 +259,10 @@ Kotlin::
 ======
 --

-This improves on the design of our
-xref:testing/mockmvc/htmlunit/mah.adoc#mockmvc-server-htmlunit-mah-usage[HtmlUnit test]
+This improves on the design of our xref:testing/mockmvc/htmlunit/mah.adoc#spring-mvc-test-server-htmlunit-mah-usage[HtmlUnit test]
 by leveraging the Page Object Pattern. As we mentioned in
-<<mockmvc-server-htmlunit-webdriver-why>>, we can use the Page Object Pattern with
-HtmlUnit, but it is much easier with WebDriver. Consider the following
+xref:testing/mockmvc/htmlunit/webdriver.adoc#spring-mvc-test-server-htmlunit-webdriver-why[Why WebDriver and MockMvc?], we can use the Page Object Pattern
+with HtmlUnit, but it is much easier with WebDriver. Consider the following
 `CreateMessagePage` implementation:

 --
@@ -60,7 +60,7 @@ assume our form looks like the following snippet:
 	</form>
 ----

-How do we ensure that our form produces the correct request to create a new message? A
+How do we ensure that our form produce the correct request to create a new message? A
 naive attempt might resemble the following:

 [tabs]
@@ -154,7 +154,7 @@ validation.
 [[mockmvc-server-htmlunit-why-integration]]
 == Integration Testing to the Rescue?

-To resolve the issues mentioned above, we could perform end-to-end integration testing,
+To resolve the issues mentioned earlier, we could perform end-to-end integration testing,
 but this has some drawbacks. Consider testing the view that lets us page through the
 messages. We might need the following tests:

@@ -171,7 +171,7 @@ leads to a number of additional challenges:
 * Testing can become slow, since each test would need to ensure that the database is in
  the correct state.
 * Since our database needs to be in a specific state, we cannot run tests in parallel.
-* Performing assertions on items such as auto-generated IDs, timestamps, and others can
+* Performing assertions on such items as auto-generated IDs, timestamps, and others can
  be difficult.

 These challenges do not mean that we should abandon end-to-end integration testing
@@ -2,10 +2,10 @@
 = Application Events

 The TestContext framework provides support for recording
-xref:core/beans/context-introduction.adoc#context-functionality-events[application events]
-published in the `ApplicationContext` so that assertions can be performed against those
-events within tests. All events published during the execution of a single test are made
-available via the `ApplicationEvents` API which allows you to process the events as a
+xref:core/beans/context-introduction.adoc#context-functionality-events[application events] published in the
+`ApplicationContext` so that assertions can be performed against those events within
+tests. All events published during the execution of a single test are made available via
+the `ApplicationEvents` API which allows you to process the events as a
 `java.util.Stream`.

 To use `ApplicationEvents` in your tests, do the following.
@@ -16,23 +16,16 @@ To use `ApplicationEvents` in your tests, do the following.
  that `ApplicationEventsTestExecutionListener` is registered by default and only needs
  to be manually registered if you have custom configuration via
  `@TestExecutionListeners` that does not include the default listeners.
-* When using the
-  xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-extension[SpringExtension for JUnit Jupiter],
-  declare a method parameter of type `ApplicationEvents` in a `@Test`, `@BeforeEach`, or
-  `@AfterEach` method.
-** Since `ApplicationEvents` is scoped to the lifecycle of the current test method, this
-   is the recommended approach.
-* Alternatively, you can annotate a field of type `ApplicationEvents` with `@Autowired`
-  and use that instance of `ApplicationEvents` in your test and lifecycle methods.
-
-NOTE: `ApplicationEvents` is registered with the `ApplicationContext` as a _resolvable
-dependency_ which is scoped to the lifecycle of the current test method. Consequently,
-`ApplicationEvents` cannot be accessed outside the lifecycle of a test method and cannot be
-`@Autowired` into the constructor of a test class.
+* Annotate a field of type `ApplicationEvents` with `@Autowired` and use that instance of
+  `ApplicationEvents` in your test and lifecycle methods (such as `@BeforeEach` and
+  `@AfterEach` methods in JUnit Jupiter).
+** When using the xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-extension[SpringExtension for JUnit Jupiter], you may declare a method
+   parameter of type `ApplicationEvents` in a test or lifecycle method as an alternative
+   to an `@Autowired` field in the test class.

 The following test class uses the `SpringExtension` for JUnit Jupiter and
-{assertj-docs}[AssertJ] to assert the types of application events published while
-invoking a method in a Spring-managed component:
+{assertj-docs}[AssertJ] to assert the types of application events
+published while invoking a method in a Spring-managed component:

 // Don't use "quotes" in the "subs" section because of the asterisks in /* ... */
 [tabs]
@@ -45,10 +38,16 @@ Java::
 	@RecordApplicationEvents // <1>
 	class OrderServiceTests {

+		@Autowired
+		OrderService orderService;
+
+		@Autowired
+		ApplicationEvents events; // <2>
+
 		@Test
-		void submitOrder(@Autowired OrderService service, ApplicationEvents events) { // <2>
+		void submitOrder() {
 			// Invoke method in OrderService that publishes an event
-			service.submitOrder(new Order(/* ... */));
+			orderService.submitOrder(new Order(/* ... */));
 			// Verify that an OrderSubmitted event was published
 			long numEvents = events.stream(OrderSubmitted.class).count(); // <3>
 			assertThat(numEvents).isEqualTo(1);
@@ -67,10 +66,16 @@ Kotlin::
 	@RecordApplicationEvents // <1>
 	class OrderServiceTests {

+		@Autowired
+		lateinit var orderService: OrderService
+
+		@Autowired
+		lateinit var events: ApplicationEvents // <2>
+
 		@Test
-		fun submitOrder(@Autowired service: OrderService, events: ApplicationEvents) { // <2>
+		fun submitOrder() {
 			// Invoke method in OrderService that publishes an event
-			service.submitOrder(Order(/* ... */))
+			orderService.submitOrder(Order(/* ... */))
 			// Verify that an OrderSubmitted event was published
 			val numEvents = events.stream(OrderSubmitted::class).count() // <3>
 			assertThat(numEvents).isEqualTo(1)
@@ -22,7 +22,7 @@ TestNG:
 * Dependency injection for test constructors, test methods, and test lifecycle callback
  methods. See xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[Dependency
  Injection with the `SpringExtension`] for further details.
-* Powerful support for link:https://docs.junit.org/current/extensions/conditional-test-execution.html[conditional
+* Powerful support for link:https://junit.org/junit5/docs/current/user-guide/#extensions-conditions[conditional
  test execution] based on SpEL expressions, environment variables, system properties,
  and so on. See the documentation for `@EnabledIf` and `@DisabledIf` in
  xref:testing/annotations/integration-junit-jupiter.adoc[Spring JUnit Jupiter Testing Annotations]
@@ -160,7 +160,7 @@ for further details.
 === Dependency Injection with the `SpringExtension`

 The `SpringExtension` implements the
-link:https://docs.junit.org/current/extensions/parameter-resolution.html[`ParameterResolver`]
+link:https://junit.org/junit5/docs/current/user-guide/#extensions-parameter-resolution[`ParameterResolver`]
 extension API from JUnit Jupiter, which lets Spring provide dependency injection for test
 constructors, test methods, and test lifecycle callback methods.

@@ -362,7 +362,7 @@ of `PlatformTransactionManager` within the test's `ApplicationContext`, you can
 qualifier by using `@Transactional("myTxMgr")` or `@Transactional(transactionManager =
 "myTxMgr")`, or `TransactionManagementConfigurer` can be implemented by an
 `@Configuration` class. Consult the
-{spring-framework-api}/test/context/transaction/TestContextTransactionUtils.html#retrieveTransactionManager(org.springframework.test.context.TestContext,java.lang.String)[javadoc
+{spring-framework-api}/test/context/transaction/TestContextTransactionUtils.html#retrieveTransactionManager-org.springframework.test.context.TestContext-java.lang.String-[javadoc
 for `TestContextTransactionUtils.retrieveTransactionManager()`] for details on the
 algorithm used to look up a transaction manager in the test's `ApplicationContext`.

@@ -75,7 +75,7 @@ infrastructure and controller declarations and use it to handle requests via moc
 and response objects, without a running server.

 For WebFlux, use the following where the Spring `ApplicationContext` is passed to
-{spring-framework-api}/web/server/adapter/WebHttpHandlerBuilder.html#applicationContext(org.springframework.context.ApplicationContext)[WebHttpHandlerBuilder]
+{spring-framework-api}/web/server/adapter/WebHttpHandlerBuilder.html#applicationContext-org.springframework.context.ApplicationContext-[WebHttpHandlerBuilder]
 to create the xref:web/webflux/reactive-spring.adoc#webflux-web-handler-api[WebHandler chain] to handle
 requests:

@@ -44,7 +44,7 @@ rejected. No CORS headers are added to the responses of simple and actual CORS r
 and, consequently, browsers reject them.

 Each `HandlerMapping` can be
-{spring-framework-api}/web/reactive/handler/AbstractHandlerMapping.html#setCorsConfigurations(java.util.Map)[configured]
+{spring-framework-api}/web/reactive/handler/AbstractHandlerMapping.html#setCorsConfigurations-java.util.Map-[configured]
 individually with URL pattern-based `CorsConfiguration` mappings. In most cases, applications
 use the WebFlux Java configuration to declare such mappings, which results in a single,
 global map passed to all `HandlerMapping` implementations.
@@ -57,7 +57,7 @@ class- or method-level `@CrossOrigin` annotations (other handlers can implement
 The rules for combining global and local configuration are generally additive -- for example,
 all global and all local origins. For those attributes where only a single value can be
 accepted, such as `allowCredentials` and `maxAge`, the local overrides the global value. See
-{spring-framework-api}/web/cors/CorsConfiguration.html#combine(org.springframework.web.cors.CorsConfiguration)[`CorsConfiguration#combine(CorsConfiguration)`]
+{spring-framework-api}/web/cors/CorsConfiguration.html#combine-org.springframework.web.cors.CorsConfiguration-[`CorsConfiguration#combine(CorsConfiguration)`]
 for more details.

 [TIP]
@@ -294,28 +294,7 @@ allPartsEvents.windowUntil(PartEvent::isLast)
 ----
 ======

-NOTE: The body contents of the `PartEvent` objects must be completely consumed, relayed, or released to avoid memory leaks.
-
-The following shows how to bind request parameters, including an optional `DataBinder` customization:
-
-[tabs]
-======
-Java::
-+
-[source,java]
----
-Pet pet = request.bind(Pet.class, dataBinder -> dataBinder.setAllowedFields("name"));
----
-
-Kotlin::
-+
-[source,kotlin]
----
-val pet = request.bind(Pet::class.java, {dataBinder -> dataBinder.setAllowedFields("name")})
----
-======
-
-
+Note that the body contents of the `PartEvent` objects must be completely consumed, relayed, or released to avoid memory leaks.

 [[webflux-fn-response]]
 === ServerResponse
@@ -448,7 +448,7 @@ Java::
 ----
 	@GetMapping
 	FragmentsRendering handle() {
-		return FragmentsRendering.fragment("posts").fragment("comments").build();
+		return FragmentsRendering.with("posts").fragment("comments").build();
 	}
 ----

@@ -458,7 +458,7 @@ Kotlin::
 ----
 	@GetMapping
 	fun handle(): FragmentsRendering {
-		return FragmentsRendering.fragment("posts").fragment("comments").build()
+		return FragmentsRendering.with("posts").fragment("comments").build()
 	}
 ----
 ======
@@ -2,18 +2,18 @@
 = WebClient
 :page-section-summary-toc: 1

-Spring WebFlux includes a client to perform HTTP requests. `WebClient` has a
-functional, fluent API based on Reactor (see xref:web/webflux-reactive-libraries.adoc[Reactive Libraries])
+Spring WebFlux includes a client to perform HTTP requests with. `WebClient` has a
+functional, fluent API based on Reactor, see xref:web-reactive.adoc#webflux-reactive-libraries[Reactive Libraries],
 which enables declarative composition of asynchronous logic without the need to deal with
-threads or concurrency. It is fully non-blocking, supports streaming, and relies on
+threads or concurrency. It is fully non-blocking, it supports streaming, and relies on
 the same xref:web/webflux/reactive-spring.adoc#webflux-codecs[codecs] that are also used to encode and
 decode request and response content on the server side.

-`WebClient` needs an HTTP client library to perform requests. There is built-in
+`WebClient` needs an HTTP client library to perform requests with. There is built-in
 support for the following:

 * {reactor-github-org}/reactor-netty[Reactor Netty]
 * {java-api}/java.net.http/java/net/http/HttpClient.html[JDK HttpClient]
 * https://github.com/jetty-project/jetty-reactive-httpclient[Jetty Reactive HttpClient]
 * https://hc.apache.org/index.html[Apache HttpComponents]
-* Others can be plugged in via `ClientHttpConnector`.
+* Others can be plugged via `ClientHttpConnector`.
@@ -310,7 +310,7 @@ Java::
 			Flux<String> source = ... ;
 			Mono<Void> output = session.send(source.map(session::textMessage));	<2>

-			return input.and(output);											<3>
+			return Mono.zip(input, output).then();								<3>
 		}
 	}
 ----
@@ -338,7 +338,7 @@ Kotlin::
 			val source: Flux<String> = ...
 			val output = session.send(source.map(session::textMessage))		// <2>

-			return input.and(output)										// <3>
+			return Mono.zip(input, output).then()							// <3>
 		}
 	}
 ----
@@ -32,9 +32,9 @@ any `@RequestMapping` method to render an RFC 9457 response. This is processed a
 - The `status` property of `ProblemDetail` determines the HTTP status.
 - The `instance` property of `ProblemDetail` is set from the current URL path, if not
 already set.
- The Jackson JSON and XML message converters use "application/problem+json" or
-"application/problem+xml" respectively as the producible media types for `ProblemDetail`
-to ensure they are favored for content negotiation.
+- For content negotiation, the Jackson `HttpMessageConverter` prefers
+"application/problem+json" over "application/json" when rendering a `ProblemDetail`,
+and also falls back on it if no compatible media type is found.

 To enable RFC 9457 responses for Spring WebFlux exceptions and for any
 `ErrorResponseException`, extend `ResponseEntityExceptionHandler` and declare it as an
@@ -114,6 +114,6 @@ and others) and is equivalent to `required=false`.
 | Any other argument
 | If a method argument is not matched to any of the above, it is, by default, resolved as
  a `@RequestParam` if it is a simple type, as determined by
-  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty],
+  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
  or as a `@ModelAttribute`, otherwise.
 |===
@@ -205,7 +205,7 @@ controller method xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation]

 TIP: Using `@ModelAttribute` is optional. By default, any argument that is not a simple
 value type as determined by
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty]
+{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]
 _AND_ that is not resolved by any other argument resolver is treated as an implicit `@ModelAttribute`.

 WARNING: When compiling to a native image with GraalVM, the implicit `@ModelAttribute`
@@ -74,6 +74,6 @@ When a `@RequestParam` annotation is declared on a `Map<String, String>` or

 Note that use of `@RequestParam` is optional -- for example, to set its attributes. By
 default, any argument that is a simple value type (as determined by
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty])
+{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty])
 and is not resolved by any other argument resolver is treated as if it were annotated
 with `@RequestParam`.
@@ -87,6 +87,6 @@ Reactor provides a dedicated operator for that, `Flux#collectList()`.
 | Other return values
 | If a return value remains unresolved in any other way, it is treated as a model
  attribute, unless it is a simple type as determined by
-  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty],
+  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
  in which case it remains unresolved.
 |===
@@ -89,7 +89,39 @@ Kotlin::

 You can map requests by using glob patterns and wildcards:

-include::partial$web/uri-patterns.adoc[leveloffset=+1]
+[cols="2,3,5"]
+|===
+|Pattern |Description |Example
+
+| `+?+`
+| Matches one character
+| `+"/pages/t?st.html"+` matches `+"/pages/test.html"+` and `+"/pages/t3st.html"+`
+
+| `+*+`
+| Matches zero or more characters within a path segment
+| `+"/resources/*.png"+` matches `+"/resources/file.png"+`
+
+`+"/projects/*/versions"+` matches `+"/projects/spring/versions"+` but does not match `+"/projects/spring/boot/versions"+`
+
+| `+**+`
+| Matches zero or more path segments until the end of the path
+| `+"/resources/**"+` matches `+"/resources/file.png"+` and `+"/resources/images/file.png"+`
+
+`+"/resources/**/file.png"+` is invalid as `+**+` is only allowed at the end of the path.
+
+| `+{name}+`
+| Matches a path segment and captures it as a variable named "name"
+| `+"/projects/{project}/versions"+` matches `+"/projects/spring/versions"+` and captures `+project=spring+`
+
+| `+{name:[a-z]+}+`
+| Matches the regexp `+"[a-z]+"+` as a path variable named "name"
+| `+"/projects/{project:[a-z]+}/versions"+` matches `+"/projects/spring/versions"+` but not `+"/projects/spring1/versions"+`
+
+| `+{*path}+`
+| Matches zero or more path segments until the end of the path and captures it as a variable named "path"
+| `+"/resources/{*file}"+` matches `+"/resources/images/file.png"+` and captures `+file=/images/file.png+`
+
+|===

 Captured URI variables can be accessed with `@PathVariable`, as the following example shows:

@@ -202,13 +234,10 @@ Kotlin::
 ======
 --

-URI path patterns can also have:
-
- Embedded `${...}` placeholders that are resolved on startup via
-`PropertySourcesPlaceholderConfigurer` against local, system, environment, and
-other property sources. This is useful, for example, to parameterize a base URL based on
-external configuration.
- SpEL expressions `#{...}`.
+URI path patterns can also have embedded `${...}` placeholders that are resolved on startup
+by using `PropertySourcesPlaceholderConfigurer` against local, system, environment, and
+other property sources. You can use this, for example, to parameterize a base URL based on
+some external configuration.

 NOTE: Spring WebFlux uses `PathPattern` and the `PathPatternParser` for URI path matching support.
 Both classes are located in `spring-web` and are expressly designed for use with HTTP URL
@@ -7,23 +7,19 @@ Spring WebFlux has built-in xref:core/validation/validator.adoc[Validation] for
 `@RequestMapping` methods, including xref:core/validation/beanvalidation.adoc[Java Bean Validation].
 Validation may be applied at one of two levels:

-1. Java Bean Validation is applied individually to an
-xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
+1. xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
 xref:web/webflux/controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] method parameter
-annotated with `@jakarta.validation.Valid` or Spring's `@Validated` so long as
-it is a command object rather than a container such as `Map` or `Collection`, it does not
-have `Errors` or `BindingResult` immediately after in the method signature, and does not
-otherwise require method validation (see next). `WebExchangeBindException` is the
-exception raised when validating a method parameter individually.
+xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] argument
+resolvers validate a method argument individually if the method parameter is annotated
+with Jakarta `@Valid` or Spring's `@Validated`, _AND_ there is no `Errors` or
+`BindingResult` parameter immediately after, _AND_ method validation is not needed (to be
+discussed next). The exception raised in this case is `WebExchangeBindException`.

-2. Java Bean Validation is applied to the method when `@Constraint` annotations such as
-`@Min`, `@NotBlank` and others are declared directly on method parameters, or on the
-method for the return value, and it supersedes any validation that would be applied
-otherwise to a method parameter individually because method validation covers both
-method parameter constraints and nested constraints via `@Valid`.
-`HandlerMethodValidationException` is the exception raised validation is applied
-to the method.
+2. When `@Constraint` annotations such as `@Min`, `@NotBlank` and others are declared
+directly on method parameters, or on the method (for the return value), then method
+validation must be applied, and that supersedes validation at the method argument level
+because method validation covers both method parameter constraints and nested constraints
+via `@Valid`. The exception raised in this case is `HandlerMethodValidationException`.

 Applications must handle both `WebExchangeBindException` and
 `HandlerMethodValidationException` as either may be raised depending on the controller
@@ -207,7 +207,7 @@ was not provided (for example, model attribute was returned) or an async return
 view resolution scenarios. Explore the options in your IDE with code completion.
 * `Model`, `Map`: Extra model attributes to be added to the model for the request.
 * Any other: Any other return value (except for simple types, as determined by
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty])
+{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty])
 is treated as a model attribute to be added to the model. The attribute name is derived
 from the class name by using {spring-framework-api}/core/Conventions.html[conventions],
 unless a handler method `@ModelAttribute` annotation is present.
@@ -418,23 +418,16 @@ See the section on xref:web/webflux-cors.adoc[CORS] and the xref:web/webflux-cor
 You may want your controller endpoints to match routes with or without a trailing slash in the URL path.
 For example, both "GET /home" and "GET /home/" should be handled by a controller method annotated with `@GetMapping("/home")`.

-Spring provides `UrlHandlerFilter` that removes the trailing slash from URL paths to ensure a consistent view of paths with or without a trailing slash.
-This is important to avoid a mismatch between URL-based authorization decisions and web framework request mappings.
-The filter can remove the trailing slash in one of a couple of ways:
+Adding trailing slash variants to all mapping declarations is not the best way to handle this use case.
+The `UrlHandlerFilter` web filter has been designed for this purpose. It can be configured to:

-* respond with an HTTP redirect status that sends clients to the same path without a trailing slash.
-* mutate the request to remove the trailing slash.
+* respond with an HTTP redirect status when receiving URLs with trailing slashes, sending browsers to the non-trailing slash URL variant.
+* mutate the request to act as if the request was sent without a trailing slash and continue the processing of the request.

 Here is how you can instantiate and configure a `UrlHandlerFilter` for a blog application:

 include-code::./UrlHandlerFilterConfiguration[tag=config,indent=0]

-Keep in mind the following:
-
- the root path `"/"` is excluded from trailing slash handling.
- `@RequestMapping("/")` adds a trailing slash to a type-level mapping, and therefore will
-not map when trailing slash handling applies; use `@RequestMapping` (no path attribute) instead.
-

 [[webflux-exception-handler]]
 == Exceptions
@@ -15,27 +15,27 @@ See xref:integration/rest-clients.adoc#rest-restclient[`RestClient`] for more de
 [[webmvc-webclient]]
 == `WebClient`

-`WebClient` is a reactive client for making HTTP requests with a fluent API.
+`WebClient` is a reactive client to perform HTTP requests with a fluent API.

-See xref:web/webflux-webclient.adoc[`WebClient`] for more details.
+See xref:web/webflux-webclient.adoc[WebClient] for more details.


 [[webmvc-resttemplate]]
 == `RestTemplate`

-`RestTemplate` is a synchronous client for making HTTP requests. It is the original
+`RestTemplate` is a synchronous client to perform HTTP requests. It is the original
 Spring REST client and exposes a simple, template-method API over underlying HTTP client
 libraries.

-See xref:integration/rest-clients.adoc#rest-resttemplate[`RestTemplate`] for details.
+See xref:integration/rest-clients.adoc[REST Endpoints] for details.


 [[webmvc-http-interface]]
 == HTTP Interface

-The Spring Framework lets you define an HTTP service as a Java interface with HTTP
+The Spring Frameworks lets you define an HTTP service as a Java interface with HTTP
 exchange methods. You can then generate a proxy that implements this interface and
 performs the exchanges. This helps to simplify HTTP remote access and provides additional
-flexibility for choosing an API style such as synchronous or reactive.
+flexibility for to choose an API style such as synchronous or reactive.

-See xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] for details.
+See xref:integration/rest-clients.adoc#rest-http-interface[REST Endpoints] for details.
@@ -71,7 +71,7 @@ rejected. No CORS headers are added to the responses of simple and actual CORS r
 and, consequently, browsers reject them.

 Each `HandlerMapping` can be
-{spring-framework-api}/web/servlet/handler/AbstractHandlerMapping.html#setCorsConfigurations(java.util.Map)[configured]
+{spring-framework-api}/web/servlet/handler/AbstractHandlerMapping.html#setCorsConfigurations-java.util.Map-[configured]
 individually with URL pattern-based `CorsConfiguration` mappings. In most cases, applications
 use the MVC Java configuration or the XML namespace to declare such mappings, which results
 in a single global map being passed to all `HandlerMapping` instances.
@@ -84,7 +84,7 @@ class- or method-level `@CrossOrigin` annotations (other handlers can implement
 The rules for combining global and local configuration are generally additive -- for example,
 all global and all local origins. For those attributes where only a single value can be
 accepted, for example, `allowCredentials` and `maxAge`, the local overrides the global value. See
-{spring-framework-api}/web/cors/CorsConfiguration.html#combine(org.springframework.web.cors.CorsConfiguration)[`CorsConfiguration#combine(CorsConfiguration)`]
+{spring-framework-api}/web/cors/CorsConfiguration.html#combine-org.springframework.web.cors.CorsConfiguration-[`CorsConfiguration#combine(CorsConfiguration)`]
 for more details.

 [TIP]
@@ -184,26 +184,6 @@ val map = request.params()
 ----
 ======

-The following shows how to bind request parameters, including an optional `DataBinder` customization:
-
-[tabs]
-======
-Java::
-+
-[source,java]
----
-Pet pet = request.bind(Pet.class, dataBinder -> dataBinder.setAllowedFields("name"));
----
-
-Kotlin::
-+
-[source,kotlin]
----
-val pet = request.bind(Pet::class.java, {dataBinder -> dataBinder.setAllowedFields("name")})
----
-======
-
-
 [[webmvc-fn-response]]
 === ServerResponse

@@ -48,7 +48,7 @@ Java::
 ----
 	@GetMapping
 	FragmentsRendering handle() {
-		return FragmentsRendering.fragment("posts").fragment("comments").build();
+		return FragmentsRendering.with("posts").fragment("comments").build();
 	}
 ----

@@ -58,7 +58,7 @@ Kotlin::
 ----
 	@GetMapping
 	fun handle(): FragmentsRendering {
-		return FragmentsRendering.fragment("posts").fragment("comments").build()
+		return FragmentsRendering.with("posts").fragment("comments").build()
 	}
 ----
 ======
@@ -3,10 +3,7 @@

 [.small]#xref:web/webflux/reactive-spring.adoc#webflux-filters[See equivalent in the Reactive stack]#

-In the Servlet API, you can add a `jakarta.servlet.Filter` to apply interception-style logic
-before and after the rest of the processing chain of filters and the target `Servlet`.
-
-The `spring-web` module has a number of built-in `Filter` implementations:
+The `spring-web` module provides some useful filters:

 * xref:web/webmvc/filters.adoc#filters-http-put[Form Data]
 * xref:web/webmvc/filters.adoc#filters-forwarded-headers[Forwarded Headers]
@@ -14,19 +11,9 @@ The `spring-web` module has a number of built-in `Filter` implementations:
 * xref:web/webmvc/filters.adoc#filters-cors[CORS]
 * xref:web/webmvc/filters.adoc#filters.url-handler[URL Handler]

-There are also base class implementations for use in Spring applications:
-
-* `GenericFilterBean` -- base class for a `Filter` configured as a Spring bean;
-integrates with the Spring `ApplicationContext` lifecycle.
-* `OncePerRequestFilter` -- extension of `GenericFilterBean` that supports a single
-invocation at the start of a request, i.e. during the `REQUEST` dispatch phase, and
-ignoring further handling via `FORWARD` dispatches. The filter also provides control
-over whether the `Filter` gets involved in `ASYNC` and `ERROR` dispatches.
-
-Servlet filters can be configured in `web.xml` or via Servlet annotations.
-In a Spring Boot application , you can
-{spring-boot-docs}/how-to/webserver.html#howto.webserver.add-servlet-filter-listener.spring-bean[declare Filter's as beans]
-and Boot will have them configured.
+Servlet filters can be configured in the `web.xml` configuration file or using Servlet annotations.
+If you are using Spring Boot, you can
+{spring-boot-docs}/how-to/webserver.html#howto.webserver.add-servlet-filter-listener.spring-bean[declare them as beans and configure them as part of your application].


 [[filters-http-put]]
@@ -120,26 +107,17 @@ See the sections on xref:web/webmvc-cors.adoc[CORS] and the xref:web/webmvc-cors
 == URL Handler
 [.small]#xref:web/webflux/reactive-spring.adoc#filters.url-handler[See equivalent in the Reactive stack]#

-You may want your controller endpoints to match routes with or without a trailing slash in the URL path.
-For example, both "GET /home" and "GET /home/" should be handled by a controller method annotated with `@GetMapping("/home")`.
+In previous Spring Framework versions, Spring MVC could be configured to ignore trailing slashes in URL paths
+when mapping incoming requests on controller methods. This could be done by enabling the `setUseTrailingSlashMatch`
+option on the `PathMatchConfigurer`. This means that sending a "GET /home/" request would be handled by a controller
+method annotated with `@GetMapping("/home")`.

-Spring provides `UrlHandlerFilter` that removes the trailing slash from URL paths to ensure a consistent view of paths with or without a trailing slash.
-This is important to avoid a mismatch between URL-based authorization decisions and web framework request mappings.
-The filter can remove the trailing slash in one of a couple of ways:
+This option has been retired, but applications are still expected to handle such requests in a safe way.
+The `UrlHandlerFilter` Servlet filter has been designed for this purpose. It can be configured to:

-* respond with an HTTP redirect status that sends clients to the same path without a trailing slash.
-* wrap the request to remove the trailing slash.
-
-NOTE: Historically Spring MVC supported trailing slash matching of URL paths.
-This capability was deprecated in 6.0 for security reasons and removed in 7.0 with
-`UrlHandlerFilter` providing a safer alternative.
+* respond with an HTTP redirect status when receiving URLs with trailing slashes, sending browsers to the non-trailing slash URL variant.
+* wrap the request to act as if the request was sent without a trailing slash and continue the processing of the request.

 Here is how you can instantiate and configure a `UrlHandlerFilter` for a blog application:

 include-code::./UrlHandlerFilterConfiguration[tag=config,indent=0]
-
-Keep in mind the following:
-
- the root path `"/"` is excluded from trailing slash handling.
- `@RequestMapping("/")` adds a trailing slash to a type-level mapping, and therefore will
-not map when trailing slash handling applies; use `@RequestMapping` (no path attribute) instead.
@@ -422,7 +422,7 @@ reactive types from the controller method.
 Reactive return values are handled as follows:

 * A single-value promise is adapted to, similar to using `DeferredResult`. Examples
-include `CompletionStage` (JDK), `Mono` (Reactor), and `Single` (RxJava).
+include `CompletionStage` (JDK), Mono` (Reactor), and `Single` (RxJava).
 * A multi-value stream with a streaming media type (such as `application/x-ndjson`
 or `text/event-stream`) is adapted to, similar to using `ResponseBodyEmitter` or
 `SseEmitter`. Examples include `Flux` (Reactor) or `Observable` (RxJava).
@@ -32,9 +32,9 @@ any `@RequestMapping` method to render an RFC 9457 response. This is processed a
 - The `status` property of `ProblemDetail` determines the HTTP status.
 - The `instance` property of `ProblemDetail` is set from the current URL path, if not
 already set.
- The Jackson JSON and XML codecs use "application/problem+json" or
-"application/problem+xml" respectively as the producible media types for `ProblemDetail`
-to ensure they are favored for content negotiation.
+- For content negotiation, the Jackson `HttpMessageConverter` prefers
+"application/problem+json" over "application/json" when rendering a `ProblemDetail`,
+and also falls back on it if no compatible media type is found.

 To enable RFC 9457 responses for Spring MVC exceptions and for any
 `ErrorResponseException`, extend `ResponseEntityExceptionHandler` and declare it as an
@@ -175,7 +175,7 @@ Message codes and arguments for each error are also resolved via `MessageSource`

 | `TypeMismatchException`
 | (default)
-| `+{0}+` property name, `+{1}+` property value, `+{2}+` simple name of required type
+| `+{0}+` property name, `+{1}+` property value

 | `UnsatisfiedServletRequestParameterException`
 | (default)
@@ -215,7 +215,7 @@ the content negotiation during the error handling phase will decide which conten

 | Any other return value
 | If a return value is not matched to any of the above and is not a simple type (as determined by
-  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty]),
+  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]),
  by default, it is treated as a model attribute to be added to the model. If it is a simple type,
  it remains unresolved.
 |===
@@ -135,6 +135,6 @@ and others) and is equivalent to `required=false`.
 | Any other argument
 | If a method argument is not matched to any of the earlier values in this table and it is
  a simple type (as determined by
-	{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty]),
+	{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]),
  it is resolved as a `@RequestParam`. Otherwise, it is resolved as a `@ModelAttribute`.
 |===
@@ -250,7 +250,7 @@ xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation].

 TIP: Using `@ModelAttribute` is optional. By default, any parameter that is not a simple
 value type as determined by
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty]
+{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]
 _AND_ that is not resolved by any other argument resolver is treated as an implicit `@ModelAttribute`.

 WARNING: When compiling to a native image with GraalVM, the implicit `@ModelAttribute`
@@ -117,6 +117,6 @@ Kotlin::

 Note that use of `@RequestParam` is optional (for example, to set its attributes).
 By default, any argument that is a simple value type (as determined by
-{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty])
+{spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty])
 and is not resolved by any other argument resolver, is treated as if it were annotated
 with `@RequestParam`.
@@ -98,6 +98,6 @@ supported for all return values.
 | Other return values
 | If a return value remains unresolved in any other way, it is treated as a model
  attribute, unless it is a simple type as determined by
-  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty(java.lang.Class)[BeanUtils#isSimpleProperty],
+  {spring-framework-api}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
  in which case it remains unresolved.
 |===
@@ -103,9 +103,22 @@ Spring WebFlux. It was enabled for use in Spring MVC from version 5.3 and is ena
 default from version 6.0. See xref:web/webmvc/mvc-config/path-matching.adoc[MVC config] for
 customizations of path matching options.

-You can map requests by using glob patterns and wildcards:
+`PathPattern` supports the same pattern syntax as `AntPathMatcher`. In addition, it also
+supports the capturing pattern, for example, `+{*spring}+`, for matching 0 or more path segments
+at the end of a path. `PathPattern` also restricts the use of `+**+` for matching multiple
+path segments such that it's only allowed at the end of a pattern. This eliminates many
+cases of ambiguity when choosing the best matching pattern for a given request.
+For full pattern syntax please refer to
+{spring-framework-api}/web/util/pattern/PathPattern.html[PathPattern] and
+{spring-framework-api}/util/AntPathMatcher.html[AntPathMatcher].

-include::partial$web/uri-patterns.adoc[leveloffset=+1]
+Some example patterns:
+
+* `+"/resources/ima?e.png"+` - match one character in a path segment
+* `+"/resources/*.png"+` - match zero or more characters in a path segment
+* `+"/resources/**"+` - match multiple path segments
+* `+"/projects/{project}/versions"+` - match a path segment and capture it as a variable
+* `++"/projects/{project:[a-z]+}/versions"++` - match and capture a variable with a regex

 Captured URI variables can be accessed with `@PathVariable`. For example:

@@ -204,13 +217,10 @@ Kotlin::
 ----
 ======

-URI path patterns can also have:
-
- Embedded `${...}` placeholders that are resolved on startup via
-`PropertySourcesPlaceholderConfigurer` against local, system, environment, and
-other property sources. This is useful, for example, to parameterize a base URL based on
-external configuration.
- SpEL expression `#{...}`.
+URI path patterns can also have embedded `${...}` placeholders that are resolved on startup
+by using `PropertySourcesPlaceholderConfigurer` against local, system, environment, and
+other property sources. You can use this, for example, to parameterize a base URL based on
+some external configuration.


 [[mvc-ann-requestmapping-pattern-comparison]]
@@ -221,7 +231,7 @@ When multiple patterns match a URL, the best match must be selected. This is don
 one of the following depending on whether use of parsed `PathPattern` is enabled for use or not:

 * {spring-framework-api}/web/util/pattern/PathPattern.html#SPECIFICITY_COMPARATOR[`PathPattern.SPECIFICITY_COMPARATOR`]
-* {spring-framework-api}/util/AntPathMatcher.html#getPatternComparator(java.lang.String)[`AntPathMatcher.getPatternComparator(String path)`]
+* {spring-framework-api}/util/AntPathMatcher.html#getPatternComparator-java.lang.String-[`AntPathMatcher.getPatternComparator(String path)`]

 Both help to sort patterns with more specific ones on top. A pattern is more specific if
 it has a lower count of URI variables (counted as 1), single wildcards (counted as 1),
@@ -7,26 +7,22 @@ Spring MVC has built-in xref:core/validation/validator.adoc[validation] for
 `@RequestMapping` methods, including xref:core/validation/beanvalidation.adoc[Java Bean Validation].
 Validation may be applied at one of two levels:

-1. Java Bean Validation is applied individually to an
-xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
+1. xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
 xref:web/webmvc/mvc-controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[@RequestPart] method parameter
-annotated with `@jakarta.validation.Valid` or Spring's `@Validated` so long as
-it is a command object rather than a container such as `Map` or `Collection`, it does not
-have `Errors` or `BindingResult` immediately after in the method signature, and does not
-otherwise require method validation (see next). `MethodArgumentNotValidException` is the
-exception raised when validating a method parameter individually.
+xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[@RequestPart] argument
+resolvers validate a method argument individually if the method parameter is annotated
+with Jakarta `@Valid` or Spring's `@Validated`, _AND_ there is no `Errors` or
+`BindingResult` parameter immediately after, _AND_ method validation is not needed (to be
+discussed next). The exception raised in this case is `MethodArgumentNotValidException`.

-2. Java Bean Validation is applied to the method when `@Constraint` annotations such as
-`@Min`, `@NotBlank` and others are declared directly on method parameters, or on the
-method for the return value, and it supersedes any validation that would be applied
-otherwise to a method parameter individually because method validation covers both
-method parameter constraints and nested constraints via `@Valid`.
-`HandlerMethodValidationException` is the exception raised validation is applied
-to the method.
+2. When `@Constraint` annotations such as `@Min`, `@NotBlank` and others are declared
+directly on method parameters, or on the method (for the return value), then method
+validation must be applied, and that supersedes validation at the method argument level
+because method validation covers both method parameter constraints and nested constraints
+via `@Valid`. The exception raised in this case is `HandlerMethodValidationException`.

-Applications should handle both `MethodArgumentNotValidException` and
-`HandlerMethodValidationException` since either may be raised depending on the controller
+Applications must handle both `MethodArgumentNotValidException` and
+`HandlerMethodValidationException` as either may be raised depending on the controller
 method signature. The two exceptions, however are designed to be very similar, and can be
 handled with almost identical code. The main difference is that the former is for a single
 object while the latter is for a list of method parameters.
@@ -1,51 +0,0 @@
-[cols="2,3,5"]
-|===
-|Pattern |Description |Example
-
-| `spring`
-| Literal pattern
-| `+"/spring"+` matches `+"/spring"+`
-
-| `+?+`
-| Matches one character
-| `+"/pages/t?st.html"+` matches `+"/pages/test.html"+` and `+"/pages/t3st.html"+`
-
-| `+*+`
-| Matches zero or more characters within a path segment
-| `+"/resources/*.png"+` matches `+"/resources/file.png"+`
-
-`+"/projects/*/versions"+` matches `+"/projects/spring/versions"+` but does not match `+"/projects/spring/boot/versions"+`.
-
-`+"/projects/*"+` matches `+"/projects/spring"+` but does not match `+"/projects"+` as the path segment is not present.
-
-| `+**+`
-| Matches zero or more path segments
-| `+"/resources/**"+` matches `+"/resources"+`, `+"/resources/file.png"+` and `+"/resources/images/file.png"+`
-
-`+"/**/info"+` matches `+"/info"+`, `+"/spring/info"+` and `+"/spring/framework/info"+`
-
-`+"/resources/**/file.png"+` is invalid as `+**+` is not allowed in the middle of the path.
-
-`+"/**/spring/**"+` is not allowed, as only a single `+**+`/`+{*path}+` instance is allowed per pattern.
-
-| `+{name}+`
-| Similar to `+*+`, but also captures the path segment as a variable named "name"
-| `+"/projects/{project}/versions"+` matches `+"/projects/spring/versions"+` and captures `+project=spring+`
-
-`+"/projects/{project}/versions"+` does not match `+"/projects/spring/framework/versions"+` as it captures a single path segment.
-
-| `{name:[a-z]+}`
-| Matches the regexp `"[a-z]+"` as a path variable named "name"
-| `"/projects/{project:[a-z]+}/versions"` matches `"/projects/spring/versions"` but not `"/projects/spring1/versions"`
-
-| `+{*path}+`
-| Similar to `+**+`, but also captures the path segments as a variable named "path"
-| `+"/resources/{*file}"+` matches `+"/resources/images/file.png"+` and captures `+file=/images/file.png+`
-
-`+"{*path}/resources"+` matches `+"/spring/framework/resources"+` and captures `+path=/spring/framework+`
-
-`+"/resources/{*path}/file.png"+` is invalid as `{*path}` is not allowed in the middle of the path.
-
-`+"/{*path}/spring/**"+` is not allowed, as only a single `+**+`/`+{*path}+` instance is allowed per pattern.
-
-|===
@@ -1,11 +1,11 @@
 {
  "dependencies": {
-    "antora": "3.2.0-alpha.11",
-    "@antora/atlas-extension": "1.0.0-alpha.5",
-    "@antora/collector-extension": "1.0.2",
+    "antora": "3.2.0-alpha.4",
+    "@antora/atlas-extension": "1.0.0-alpha.2",
+    "@antora/collector-extension": "1.0.0-alpha.3",
    "@asciidoctor/tabs": "1.0.0-beta.6",
-    "@springio/antora-extensions": "1.14.7",
-    "fast-xml-parser": "5.3.4",
-    "@springio/asciidoctor-extensions": "1.0.0-alpha.17"
+    "@springio/antora-extensions": "1.14.2",
+    "fast-xml-parser": "4.5.2",
+    "@springio/asciidoctor-extensions": "1.0.0-alpha.10"
  }
 }
@@ -200,7 +200,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.

-
 =======================================================================

 SPRING FRAMEWORK ${version} SUBCOMPONENTS:
@@ -213,7 +212,7 @@ code for these subcomponents is subject to the terms and
 conditions of the following licenses.


->>> ASM 9.9.1 (org.ow2.asm:asm:9.9.1):
+>>> ASM 9.1 (org.ow2.asm:asm:9.1, org.ow2.asm:asm-commons:9.1):

 Copyright (c) 2000-2011 INRIA, France Telecom
 All rights reserved.
@@ -250,8 +249,10 @@ Copyright (c) 1999-2009, OW2 Consortium <https://www.ow2.org/>

 >>> CGLIB 3.3 (cglib:cglib:3.3):

-Per the LICENSE file in the CGLIB distribution, CGLIB 3.3 is licensed
-under the Apache License, version 2.0, the text of which is included above.
+Per the LICENSE file in the CGLIB JAR distribution downloaded from
+https://github.com/cglib/cglib/releases/download/RELEASE_3_3_0/cglib-3.3.0.jar,
+CGLIB 3.3 is licensed under the Apache License, version 2.0, the text of which
+is included above.


 >>> JavaPoet 1.13.0 (com.squareup:javapoet:1.13.0):
@@ -262,18 +263,18 @@ JavaPoet 1.13.0 is licensed under the Apache License, version 2.0, the text of
 which is included above.


->>> Objenesis 3.5 (org.objenesis:objenesis:3.5):
+>>> Objenesis 3.4 (org.objenesis:objenesis:3.4):

-Per the LICENSE file in the Objenesis distribution downloaded from
-http://objenesis.org/download.html, Objenesis 3.5 is licensed under the
+Per the LICENSE file in the Objenesis ZIP distribution downloaded from
+http://objenesis.org/download.html, Objenesis 3.4 is licensed under the
 Apache License, version 2.0, the text of which is included above.

-Per the NOTICE file in the Objenesis distribution downloaded from
+Per the NOTICE file in the Objenesis ZIP distribution downloaded from
 http://objenesis.org/download.html and corresponding to section 4d of the
 Apache License, Version 2.0, in this case for Objenesis:

 Objenesis
-Copyright 2006-2026 Joe Walnes, Henri Tremblay, Leonardo Mesquita
+Copyright 2006-2019 Joe Walnes, Henri Tremblay, Leonardo Mesquita


 ===============================================================================
@@ -7,33 +7,33 @@ javaPlatform {
 }

 dependencies {
-	api(platform("com.fasterxml.jackson:jackson-bom:2.18.5"))
-	api(platform("io.micrometer:micrometer-bom:1.15.9"))
-	api(platform("io.netty:netty-bom:4.1.130.Final"))
+	api(platform("com.fasterxml.jackson:jackson-bom:2.18.4"))
+	api(platform("io.micrometer:micrometer-bom:1.14.9"))
+	api(platform("io.netty:netty-bom:4.1.123.Final"))
 	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2024.0.15"))
+	api(platform("io.projectreactor:reactor-bom:2024.0.8"))
 	api(platform("io.rsocket:rsocket-bom:1.1.5"))
-	api(platform("org.apache.groovy:groovy-bom:4.0.30"))
+	api(platform("org.apache.groovy:groovy-bom:4.0.27"))
 	api(platform("org.apache.logging.log4j:log4j-bom:2.21.1"))
-	api(platform("org.assertj:assertj-bom:3.27.7"))
-	api(platform("org.eclipse.jetty:jetty-bom:12.0.30"))
-	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.30"))
+	api(platform("org.assertj:assertj-bom:3.27.3"))
+	api(platform("org.eclipse.jetty:jetty-bom:12.0.23"))
+	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.23"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.8.1"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:1.6.3"))
-	api(platform("org.junit:junit-bom:5.14.2"))
-	api(platform("org.mockito:mockito-bom:5.21.0"))
+	api(platform("org.junit:junit-bom:5.13.3"))
+	api(platform("org.mockito:mockito-bom:5.18.0"))

 	constraints {
-		api("com.fasterxml:aalto-xml:1.3.4")
+		api("com.fasterxml:aalto-xml:1.3.2")
 		api("com.fasterxml.woodstox:woodstox-core:6.7.0")
-		api("com.github.ben-manes.caffeine:caffeine:3.2.3")
+		api("com.github.ben-manes.caffeine:caffeine:3.2.1")
 		api("com.github.librepdf:openpdf:1.3.43")
 		api("com.google.code.findbugs:findbugs:3.0.1")
 		api("com.google.code.findbugs:jsr305:3.0.2")
-		api("com.google.code.gson:gson:2.13.2")
-		api("com.google.protobuf:protobuf-java-util:4.33.4")
+		api("com.google.code.gson:gson:2.13.1")
+		api("com.google.protobuf:protobuf-java-util:4.30.2")
 		api("com.h2database:h2:2.3.232")
-		api("com.jayway.jsonpath:json-path:2.10.0")
+		api("com.jayway.jsonpath:json-path:2.9.0")
 		api("com.oracle.database.jdbc:ojdbc11:21.9.0.0")
 		api("com.rometools:rome:1.19.0")
 		api("com.squareup.okhttp3:mockwebserver:3.14.9")
@@ -53,11 +53,11 @@ dependencies {
 		api("io.r2dbc:r2dbc-h2:1.0.0.RELEASE")
 		api("io.r2dbc:r2dbc-spi-test:1.0.0.RELEASE")
 		api("io.r2dbc:r2dbc-spi:1.0.0.RELEASE")
-		api("io.reactivex.rxjava3:rxjava:3.1.12")
+		api("io.reactivex.rxjava3:rxjava:3.1.10")
 		api("io.smallrye.reactive:mutiny:1.10.0")
-		api("io.undertow:undertow-core:2.3.20.Final")
-		api("io.undertow:undertow-servlet:2.3.20.Final")
-		api("io.undertow:undertow-websockets-jsr:2.3.20.Final")
+		api("io.undertow:undertow-core:2.3.18.Final")
+		api("io.undertow:undertow-servlet:2.3.18.Final")
+		api("io.undertow:undertow-websockets-jsr:2.3.18.Final")
 		api("io.vavr:vavr:0.10.4")
 		api("jakarta.activation:jakarta.activation-api:2.0.1")
 		api("jakarta.annotation:jakarta.annotation-api:2.0.0")
@@ -90,17 +90,17 @@ dependencies {
 		api("junit:junit:4.13.2")
 		api("net.sf.jopt-simple:jopt-simple:5.0.4")
 		api("org.apache-extras.beanshell:bsh:2.0b6")
-		api("org.apache.activemq:activemq-broker:5.17.7")
-		api("org.apache.activemq:activemq-kahadb-store:5.17.7")
-		api("org.apache.activemq:activemq-stomp:5.17.7")
-		api("org.apache.activemq:artemis-jakarta-client:2.42.0")
-		api("org.apache.activemq:artemis-junit-5:2.42.0")
+		api("org.apache.activemq:activemq-broker:5.17.6")
+		api("org.apache.activemq:activemq-kahadb-store:5.17.6")
+		api("org.apache.activemq:activemq-stomp:5.17.6")
+		api("org.apache.activemq:artemis-jakarta-client:2.31.2")
+		api("org.apache.activemq:artemis-junit-5:2.31.2")
 		api("org.apache.commons:commons-pool2:2.9.0")
 		api("org.apache.derby:derby:10.16.1.1")
 		api("org.apache.derby:derbyclient:10.16.1.1")
 		api("org.apache.derby:derbytools:10.16.1.1")
 		api("org.apache.httpcomponents.client5:httpclient5:5.5")
-		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.3.5")
+		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.3.4")
 		api("org.apache.poi:poi-ooxml:5.2.5")
 		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.28")
 		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.28")
@@ -113,9 +113,9 @@ dependencies {
 		api("org.bouncycastle:bcpkix-jdk18on:1.72")
 		api("org.codehaus.jettison:jettison:1.5.4")
 		api("org.crac:crac:1.4.0")
-		api("org.dom4j:dom4j:2.2.0")
-		api("org.easymock:easymock:5.6.0")
-		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.12")
+		api("org.dom4j:dom4j:2.1.4")
+		api("org.easymock:easymock:5.5.0")
+		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.9")
 		api("org.eclipse.persistence:org.eclipse.persistence.jpa:3.0.4")
 		api("org.eclipse:yasson:2.0.4")
 		api("org.ehcache:ehcache:3.10.8")
@@ -129,24 +129,24 @@ dependencies {
 		api("org.hibernate:hibernate-core-jakarta:5.6.15.Final")
 		api("org.hibernate:hibernate-validator:7.0.5.Final")
 		api("org.hsqldb:hsqldb:2.7.4")
-		api("org.htmlunit:htmlunit:4.21.0")
+		api("org.htmlunit:htmlunit:4.13.0")
 		api("org.javamoney:moneta:1.4.4")
-		api("org.jruby:jruby:9.4.13.0")
+		api("org.jruby:jruby:9.4.12.0")
 		api("org.junit.support:testng-engine:1.0.5")
 		api("org.mozilla:rhino:1.7.15")
 		api("org.ogce:xpp3:1.1.6")
 		api("org.python:jython-standalone:2.7.4")
 		api("org.quartz-scheduler:quartz:2.3.2")
-		api("org.seleniumhq.selenium:htmlunit3-driver:4.40.0")
-		api("org.seleniumhq.selenium:selenium-java:4.40.0")
+		api("org.seleniumhq.selenium:htmlunit3-driver:4.33.0")
+		api("org.seleniumhq.selenium:selenium-java:4.34.0")
 		api("org.skyscreamer:jsonassert:1.5.3")
 		api("org.slf4j:slf4j-api:2.0.17")
 		api("org.testng:testng:7.11.0")
 		api("org.webjars:underscorejs:1.8.3")
 		api("org.webjars:webjars-locator-core:0.59")
 		api("org.webjars:webjars-locator-lite:1.1.0")
-		api("org.xmlunit:xmlunit-assertj:2.10.4")
-		api("org.xmlunit:xmlunit-matchers:2.10.4")
-		api("org.yaml:snakeyaml:2.5")
+		api("org.xmlunit:xmlunit-assertj:2.10.3")
+		api("org.xmlunit:xmlunit-matchers:2.10.3")
+		api("org.yaml:snakeyaml:2.4")
 	}
 }
@@ -1,4 +1,4 @@
-version=6.2.16
+version=6.2.9

 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m
@@ -62,7 +62,7 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	MethodInvocation invocableClone(Object... arguments);

 	/**
-	 * Set the arguments to be used on subsequent invocations in any advice
+	 * Set the arguments to be used on subsequent invocations in the any advice
 	 * in this chain.
 	 * @param arguments the argument array
 	 */
@@ -121,12 +121,12 @@ public abstract class AopConfigUtils {
 		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

 		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
-			BeanDefinition beanDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
-			if (!cls.getName().equals(beanDefinition.getBeanClassName())) {
-				int currentPriority = findPriorityForClass(beanDefinition.getBeanClassName());
+			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
+			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
+				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
 				int requiredPriority = findPriorityForClass(cls);
 				if (currentPriority < requiredPriority) {
-					beanDefinition.setBeanClassName(cls.getName());
+					apcDefinition.setBeanClassName(cls.getName());
 				}
 			}
 			return null;
@@ -134,8 +134,8 @@ public abstract class AopConfigUtils {

 		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
 		beanDefinition.setSource(source);
-		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
 		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
+		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
 		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
 		return beanDefinition;
 	}
@@ -117,7 +117,6 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSu
 			}
 			proxyFactory.addAdvisor(this.advisor);
 			customizeProxyFactory(proxyFactory);
-			proxyFactory.setPreFiltered(true);

 			// Use original ClassLoader if bean class not locally loaded in overriding class loader
 			ClassLoader classLoader = getProxyClassLoader();
@@ -41,8 +41,8 @@ abstract class CoroutinesUtils {
 		}
 	}

-	@SuppressWarnings({"rawtypes", "unchecked"})
 	@Nullable
+	@SuppressWarnings({"unchecked", "rawtypes"})
 	static Object awaitSingleOrNull(@Nullable Object value, Object continuation) {
 		return MonoKt.awaitSingleOrNull(value instanceof Mono mono ? mono : Mono.justOrEmpty(value),
 				(Continuation<Object>) continuation);
@@ -24,9 +24,9 @@ import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.lang.Nullable;

 /**
- * Extension of {@link AbstractAdvisingBeanPostProcessor} which implements
- * {@link BeanFactoryAware}, adds exposure of the original target class for each
- * proxied bean ({@link AutoProxyUtils#ORIGINAL_TARGET_CLASS_ATTRIBUTE}),
+ * Extension of {@link AbstractAutoProxyCreator} which implements {@link BeanFactoryAware},
+ * adds exposure of the original target class for each proxied bean
+ * ({@link AutoProxyUtils#ORIGINAL_TARGET_CLASS_ATTRIBUTE}),
 * and participates in an externally enforced target-class mode for any given bean
 * ({@link AutoProxyUtils#PRESERVE_TARGET_CLASS_ATTRIBUTE}).
 * This post-processor is therefore aligned with {@link AbstractAutoProxyCreator}.
@@ -81,19 +81,13 @@ public abstract class ScopedProxyUtils {
 		// Copy autowire settings from original bean definition.
 		proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
 		proxyDefinition.setPrimary(targetDefinition.isPrimary());
-		proxyDefinition.setFallback(targetDefinition.isFallback());
 		if (targetDefinition instanceof AbstractBeanDefinition abd) {
-			proxyDefinition.setDefaultCandidate(abd.isDefaultCandidate());
 			proxyDefinition.copyQualifiersFrom(abd);
 		}

 		// The target bean should be ignored in favor of the scoped proxy.
 		targetDefinition.setAutowireCandidate(false);
 		targetDefinition.setPrimary(false);
-		targetDefinition.setFallback(false);
-		if (targetDefinition instanceof AbstractBeanDefinition abd) {
-			abd.setDefaultCandidate(false);
-		}

 		// Register the target bean as separate bean in the factory.
 		registry.registerBeanDefinition(targetBeanName, targetDefinition);
@@ -37,6 +37,7 @@ import static org.mockito.Mockito.verify;
 * Tests for {@link AsyncExecutionInterceptor}.
 *
 * @author Bao Ngo
+ * @since 7.0
 */
 class AsyncExecutionInterceptorTests {

@@ -61,13 +62,11 @@ class AsyncExecutionInterceptorTests {
 		O run();
 	}

-
 	static class FutureRunner implements GenericRunner<Future<Void>> {
-
 		@Override
 		public Future<Void> run() {
-			return CompletableFuture.runAsync(() -> {});
+			return CompletableFuture.runAsync(() -> {
+			});
 		}
 	}
-
 }
@@ -18,15 +18,6 @@ package org.springframework.aop.scope;

 import org.junit.jupiter.api.Test;

-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.beans.factory.config.BeanDefinitionHolder;
-import org.springframework.beans.factory.support.AbstractBeanDefinition;
-import org.springframework.beans.factory.support.AutowireCandidateQualifier;
-import org.springframework.beans.factory.support.BeanDefinitionRegistry;
-import org.springframework.beans.factory.support.GenericBeanDefinition;
-import org.springframework.beans.factory.support.RootBeanDefinition;
-import org.springframework.beans.factory.support.SimpleBeanDefinitionRegistry;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;

@@ -34,7 +25,6 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
 * Tests for {@link ScopedProxyUtils}.
 *
 * @author Sam Brannen
- * @author Juergen Hoeller
 * @since 5.1.10
 */
 class ScopedProxyUtilsTests {
@@ -63,79 +53,15 @@ class ScopedProxyUtilsTests {
 	@Test
 	void getOriginalBeanNameForNullTargetBean() {
 		assertThatIllegalArgumentException()
-				.isThrownBy(() -> ScopedProxyUtils.getOriginalBeanName(null))
-				.withMessage("bean name 'null' does not refer to the target of a scoped proxy");
+			.isThrownBy(() -> ScopedProxyUtils.getOriginalBeanName(null))
+			.withMessage("bean name 'null' does not refer to the target of a scoped proxy");
 	}

 	@Test
 	void getOriginalBeanNameForNonScopedTarget() {
 		assertThatIllegalArgumentException()
-				.isThrownBy(() -> ScopedProxyUtils.getOriginalBeanName("myBean"))
-				.withMessage("bean name 'myBean' does not refer to the target of a scoped proxy");
-	}
-
-	@Test
-	void createScopedProxyTargetAppliesAutowireSettingsToProxyBeanDefinition() {
-		AbstractBeanDefinition targetDefinition = new GenericBeanDefinition();
-		// Opposite of defaults
-		targetDefinition.setAutowireCandidate(false);
-		targetDefinition.setDefaultCandidate(false);
-		targetDefinition.setPrimary(true);
-		targetDefinition.setFallback(true);
-
-		BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
-		BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(
-				new BeanDefinitionHolder(targetDefinition, "myBean"), registry, false);
-		AbstractBeanDefinition proxyBeanDefinition = (AbstractBeanDefinition) proxyHolder.getBeanDefinition();
-
-		assertThat(proxyBeanDefinition.isAutowireCandidate()).isFalse();
-		assertThat(proxyBeanDefinition.isDefaultCandidate()).isFalse();
-		assertThat(proxyBeanDefinition.isPrimary()).isTrue();
-		assertThat(proxyBeanDefinition.isFallback()).isTrue();
-	}
-
-	@Test
-	void createScopedProxyTargetAppliesBeanAttributesToProxyBeanDefinition() {
-		GenericBeanDefinition targetDefinition = new GenericBeanDefinition();
-		// Opposite of defaults
-		targetDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
-		targetDefinition.setSource("theSource");
-		targetDefinition.addQualifier(new AutowireCandidateQualifier("myQualifier"));
-
-		BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
-		BeanDefinitionHolder proxyHolder = ScopedProxyUtils.createScopedProxy(
-				new BeanDefinitionHolder(targetDefinition, "myBean"), registry, false);
-		BeanDefinition proxyBeanDefinition = proxyHolder.getBeanDefinition();
-
-		assertThat(proxyBeanDefinition.getRole()).isEqualTo(BeanDefinition.ROLE_INFRASTRUCTURE);
-		assertThat(proxyBeanDefinition).isInstanceOf(RootBeanDefinition.class);
-		assertThat(proxyBeanDefinition.getPropertyValues()).hasSize(2);
-		assertThat(proxyBeanDefinition.getPropertyValues().get("proxyTargetClass")).isEqualTo(false);
-		assertThat(proxyBeanDefinition.getPropertyValues().get("targetBeanName")).isEqualTo(
-				ScopedProxyUtils.getTargetBeanName("myBean"));
-
-		RootBeanDefinition rootBeanDefinition = (RootBeanDefinition) proxyBeanDefinition;
-		assertThat(rootBeanDefinition.getQualifiers()).hasSize(1);
-		assertThat(rootBeanDefinition.hasQualifier("myQualifier")).isTrue();
-		assertThat(rootBeanDefinition.getSource()).isEqualTo("theSource");
-	}
-
-	@Test
-	void createScopedProxyTargetCleansAutowireSettingsInTargetDefinition() {
-		AbstractBeanDefinition targetDefinition = new GenericBeanDefinition();
-		targetDefinition.setAutowireCandidate(true);
-		targetDefinition.setDefaultCandidate(true);
-		targetDefinition.setPrimary(true);
-		targetDefinition.setFallback(true);
-
-		BeanDefinitionRegistry registry = new SimpleBeanDefinitionRegistry();
-		ScopedProxyUtils.createScopedProxy(
-				new BeanDefinitionHolder(targetDefinition, "myBean"), registry, false);
-
-		assertThat(targetDefinition.isAutowireCandidate()).isFalse();
-		assertThat(targetDefinition.isDefaultCandidate()).isFalse();
-		assertThat(targetDefinition.isPrimary()).isFalse();
-		assertThat(targetDefinition.isFallback()).isFalse();
+			.isThrownBy(() -> ScopedProxyUtils.getOriginalBeanName("myBean"))
+			.withMessage("bean name 'myBean' does not refer to the target of a scoped proxy");
 	}

 }
@@ -19,7 +19,6 @@ package org.springframework.aop.framework
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.jupiter.api.Test
-import java.time.LocalDateTime

 /**
 * Tests for Kotlin support in [CglibAopProxy].
@@ -49,13 +48,6 @@ class CglibAopProxyKotlinTests {
 		assertThatThrownBy { proxy.checkedException() }.isInstanceOf(CheckedException::class.java)
 	}

-	@Test // gh-35487
-	fun jvmDefault() {
-		val proxyFactory = ProxyFactory()
-		proxyFactory.setTarget(AddressRepo())
-		proxyFactory.proxy
-	}
-

 	open class MyKotlinBean {

@@ -71,24 +63,4 @@ class CglibAopProxyKotlinTests {
 	}

 	class CheckedException() : Exception()
-
-	open class AddressRepo(): CrudRepo<Address, Int>
-
-	interface CrudRepo<E : Any, ID : Any> {
-		fun save(e: E): E {
-			return e
-		}
-		fun delete(id: ID): Long {
-			return 0L
-		}
-	}
-
-	data class Address(
-		val id: Int = 0,
-		val street: String,
-		val version: Int = 0,
-		val createdAt: LocalDateTime? = null,
-		val updatedAt: LocalDateTime? = null,
-	)
-
 }
@@ -489,9 +489,6 @@ public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyA
 	@Override
 	@Nullable
 	public Class<?> getPropertyType(String propertyName) throws BeansException {
-		if (this.wrappedObject == null) {
-			return null;
-		}
 		try {
 			PropertyHandler ph = getPropertyHandler(propertyName);
 			if (ph != null) {
@@ -192,7 +192,7 @@ public class BeanWrapperImpl extends AbstractNestablePropertyAccessor implements

 	@Override
 	@Nullable
-	protected PropertyHandler getLocalPropertyHandler(String propertyName) {
+	protected BeanPropertyHandler getLocalPropertyHandler(String propertyName) {
 		PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(propertyName);
 		return (pd != null ? new BeanPropertyHandler((GenericTypeAwarePropertyDescriptor) pd) : null);
 	}
@@ -73,7 +73,7 @@ public class DirectFieldAccessor extends AbstractNestablePropertyAccessor {

 	@Override
 	@Nullable
-	protected PropertyHandler getLocalPropertyHandler(String propertyName) {
+	protected FieldPropertyHandler getLocalPropertyHandler(String propertyName) {
 		FieldPropertyHandler propertyHandler = this.fieldMap.get(propertyName);
 		if (propertyHandler == null) {
 			Field field = ReflectionUtils.findField(getWrappedClass(), propertyName);
@@ -26,7 +26,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;

-import org.springframework.core.ResolvableType;
 import org.springframework.lang.Nullable;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
@@ -36,7 +35,6 @@ import org.springframework.util.StringUtils;
 *
 * @author Chris Beams
 * @author Juergen Hoeller
- * @author Sam Brannen
 */
 abstract class PropertyDescriptorUtils {

@@ -101,13 +99,14 @@ abstract class PropertyDescriptorUtils {
 				}
 				else {
 					Method readMethod = pd.getReadMethod();
-					if (readMethod == null || readMethod.getReturnType().isAssignableFrom(method.getReturnType())) {
+					if (readMethod == null ||
+							(readMethod.getReturnType() == method.getReturnType() && method.getName().startsWith("is"))) {
 						pd.setReadMethod(method);
 					}
 				}
 			}
 			else {
-				pd = new BasicPropertyDescriptor(propertyName, beanClass, (!setter ? method : null), (setter ? method : null));
+				pd = new BasicPropertyDescriptor(propertyName, (!setter ? method : null), (setter ? method : null));
 				pdMap.put(propertyName, pd);
 			}
 		}
@@ -265,8 +264,6 @@ abstract class PropertyDescriptorUtils {
 	 */
 	private static class BasicPropertyDescriptor extends PropertyDescriptor {

-		private final Class<?> beanClass;
-
 		@Nullable
 		private Method readMethod;

@@ -275,11 +272,10 @@ abstract class PropertyDescriptorUtils {

 		private final List<Method> alternativeWriteMethods = new ArrayList<>();

-		public BasicPropertyDescriptor(String propertyName, Class<?> beanClass, @Nullable Method readMethod, @Nullable Method writeMethod)
+		public BasicPropertyDescriptor(String propertyName, @Nullable Method readMethod, @Nullable Method writeMethod)
 				throws IntrospectionException {

 			super(propertyName, readMethod, writeMethod);
-			this.beanClass = beanClass;
 		}

 		@Override
@@ -311,24 +307,14 @@ abstract class PropertyDescriptorUtils {
 		public Method getWriteMethod() {
 			if (this.writeMethod == null && !this.alternativeWriteMethods.isEmpty()) {
 				if (this.readMethod == null) {
-					this.writeMethod = this.alternativeWriteMethods.get(0);
+					return this.alternativeWriteMethods.get(0);
 				}
 				else {
 					for (Method method : this.alternativeWriteMethods) {
-						// Check subtype match first.
 						if (this.readMethod.getReturnType().isAssignableFrom(method.getParameterTypes()[0])) {
 							this.writeMethod = method;
 							break;
 						}
-						// Check exact match against resolved generic parameter type as a fallback.
-						if (!(method.getGenericParameterTypes()[0] instanceof Class<?>)) {
-							Class<?> resolvedParameterType =
-									ResolvableType.forMethodParameter(method, 0, this.beanClass).toClass();
-							if (this.readMethod.getReturnType().equals(resolvedParameterType)) {
-								this.writeMethod = method;
-								break;
-							}
-						}
 					}
 				}
 			}
@@ -336,4 +322,5 @@ abstract class PropertyDescriptorUtils {
 		}
 	}

+
 }
@@ -566,7 +566,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 		}

 		final List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
-		Class<?> targetClass = ClassUtils.getUserClass(clazz);
+		Class<?> targetClass = clazz;

 		do {
 			final List<InjectionMetadata.InjectedElement> fieldElements = new ArrayList<>();
@@ -586,11 +586,12 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA

 			final List<InjectionMetadata.InjectedElement> methodElements = new ArrayList<>();
 			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
-				if (method.isBridge()) {
+				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
+				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
 					return;
 				}
-				MergedAnnotation<?> ann = findAutowiredAnnotation(method);
-				if (ann != null && method.equals(BridgeMethodResolver.getMostSpecificMethod(method, clazz))) {
+				MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
+				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
 					if (Modifier.isStatic(method.getModifiers())) {
 						if (logger.isInfoEnabled()) {
 							logger.info("Autowired annotation is not supported on static methods: " + method);
@@ -608,7 +609,7 @@ public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationA
 						}
 					}
 					boolean required = determineRequiredStatus(ann);
-					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method, clazz);
+					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
 					methodElements.add(new AutowiredMethodElement(method, required, pd));
 				}
 			});
@@ -180,6 +180,7 @@ public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwa
 	 * {@code true} if a qualifier has been found and matched,
 	 * {@code null} if no qualifier has been found at all
 	 */
+
 	@Nullable
 	protected Boolean checkQualifiers(BeanDefinitionHolder bdHolder, Annotation[] annotationsToSearch) {
 		boolean qualifierFound = false;
@@ -374,17 +375,6 @@ public class QualifierAnnotationAutowireCandidateResolver extends GenericTypeAwa
 				return true;
 			}
 		}
-		MethodParameter methodParam = descriptor.getMethodParameter();
-		if (methodParam != null) {
-			Method method = methodParam.getMethod();
-			if (method == null || void.class == method.getReturnType()) {
-				for (Annotation annotation : methodParam.getMethodAnnotations()) {
-					if (isQualifier(annotation.annotationType())) {
-						return true;
-					}
-				}
-			}
-		}
 		return false;
 	}

@@ -29,7 +29,6 @@ import org.springframework.aot.generate.ValueCodeGenerator.Delegate;
 import org.springframework.aot.generate.ValueCodeGeneratorDelegates;
 import org.springframework.aot.generate.ValueCodeGeneratorDelegates.CollectionDelegate;
 import org.springframework.aot.generate.ValueCodeGeneratorDelegates.MapDelegate;
-import org.springframework.beans.factory.config.AutowiredPropertyMarker;
 import org.springframework.beans.factory.config.BeanReference;
 import org.springframework.beans.factory.config.RuntimeBeanReference;
 import org.springframework.beans.factory.config.TypedStringValue;
@@ -58,7 +57,6 @@ abstract class BeanDefinitionPropertyValueCodeGeneratorDelegates {
 	 * <li>{@link LinkedHashMap}</li>
 	 * <li>{@link BeanReference}</li>
 	 * <li>{@link TypedStringValue}</li>
-	 * <li>{@link AutowiredPropertyMarker}</li>
 	 * </ul>
 	 * When combined with {@linkplain ValueCodeGeneratorDelegates#INSTANCES the
 	 * delegates for common value types}, this should be added first as they have
@@ -70,8 +68,7 @@ abstract class BeanDefinitionPropertyValueCodeGeneratorDelegates {
 			new ManagedMapDelegate(),
 			new LinkedHashMapDelegate(),
 			new BeanReferenceDelegate(),
-			new TypedStringValueDelegate(),
-			new AutowiredPropertyMarkerDelegate()
+			new TypedStringValueDelegate()
 	);


@@ -219,20 +216,4 @@ abstract class BeanDefinitionPropertyValueCodeGeneratorDelegates {
 			return valueCodeGenerator.generateCode(value);
 		}
 	}
-
-	/**
-	 * {@link Delegate} for {@link AutowiredPropertyMarker} types.
-	 */
-	private static class AutowiredPropertyMarkerDelegate implements Delegate {
-
-		@Override
-		@Nullable
-		public CodeBlock generateCode(ValueCodeGenerator valueCodeGenerator, Object value) {
-			if (value instanceof AutowiredPropertyMarker) {
-				return CodeBlock.of("$T.INSTANCE", AutowiredPropertyMarker.class);
-			}
-			return null;
-		}
-	}
-
 }
@@ -294,12 +294,9 @@ public class InstanceSupplierCodeGenerator {

 		this.generationContext.getRuntimeHints().reflection().registerMethod(factoryMethod, ExecutableMode.INVOKE);
 		GeneratedMethod getInstanceMethod = generateGetInstanceSupplierMethod(method -> {
-			CodeWarnings codeWarnings = new CodeWarnings();
 			Class<?> suppliedType = ClassUtils.resolvePrimitiveIfNecessary(factoryMethod.getReturnType());
-			codeWarnings.detectDeprecation(suppliedType, factoryMethod);
 			method.addJavadoc("Get the bean instance supplier for '$L'.", beanName);
 			method.addModifiers(PRIVATE_STATIC);
-			codeWarnings.suppress(method);
 			method.returns(ParameterizedTypeName.get(BeanInstanceSupplier.class, suppliedType));
 			method.addStatement(generateInstanceSupplierForFactoryMethod(
 					factoryMethod, suppliedType, targetClass, factoryMethod.getName()));
@@ -152,18 +152,6 @@ public interface ConfigurableListableBeanFactory
 	 */
 	boolean isConfigurationFrozen();

-	/**
-	 * Mark current thread as main bootstrap thread for singleton instantiation,
-	 * with lenient bootstrap locking applying for background threads.
-	 * <p>Any such marker is to be removed at the end of the managed bootstrap in
-	 * {@link #preInstantiateSingletons()}.
-	 * @since 6.2.12
-	 * @see #setBootstrapExecutor
-	 * @see #preInstantiateSingletons()
-	 */
-	default void prepareSingletonBootstrap() {
-	}
-
 	/**
 	 * Ensure that all non-lazy-init singletons are instantiated, also considering
 	 * {@link org.springframework.beans.factory.FactoryBean FactoryBeans}.
@@ -171,7 +159,6 @@ public interface ConfigurableListableBeanFactory
 	 * @throws BeansException if one of the singleton beans could not be created.
 	 * Note: This may have left the factory with some beans already initialized!
 	 * Call {@link #destroySingletons()} for full cleanup in this case.
-	 * @see #prepareSingletonBootstrap()
 	 * @see #destroySingletons()
 	 */
 	void preInstantiateSingletons() throws BeansException;
@@ -520,7 +520,8 @@ public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport imp
 	 * to check whether the bean with the given name matches the specified type. Allow
 	 * additional constraints to be applied to ensure that beans are not created early.
 	 * @param name the name of the bean to query
-	 * @param typeToMatch the type to match against (as a {@code ResolvableType})
+	 * @param typeToMatch the type to match against (as a
+	 * {@code ResolvableType})
 	 * @return {@code true} if the bean type matches, {@code false} if it
 	 * doesn't match or cannot be determined yet
 	 * @throws NoSuchBeanDefinitionException if there is no bean with the given name
@@ -32,6 +32,7 @@ import org.springframework.util.StringUtils;
 * @author Juergen Hoeller
 * @author Rob Harrop
 * @since 1.1
+ * @see PropertiesBeanDefinitionReader
 * @see org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
 */
 public abstract class BeanDefinitionReaderUtils {
@@ -43,6 +43,7 @@ import org.springframework.core.AliasRegistry;
 * @see DefaultListableBeanFactory
 * @see org.springframework.context.support.GenericApplicationContext
 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
+ * @see PropertiesBeanDefinitionReader
 */
 public interface BeanDefinitionRegistry extends AliasRegistry {

@@ -58,7 +58,6 @@ import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.BeanNotOfRequiredTypeException;
 import org.springframework.beans.factory.CannotLoadBeanClassException;
-import org.springframework.beans.factory.FactoryBean;
 import org.springframework.beans.factory.InjectionPoint;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
@@ -197,8 +196,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 	/** Map from bean name to merged BeanDefinitionHolder. */
 	private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256);

-	/** Map of bean definition names with a primary marker plus corresponding type. */
-	private final Map<String, Class<?>> primaryBeanNamesWithType = new ConcurrentHashMap<>(16);
+	/** Set of bean definition names with a primary marker. */
+	private final Set<String> primaryBeanNames = ConcurrentHashMap.newKeySet(16);

 	/** Map of singleton and non-singleton bean names, keyed by dependency type. */
 	private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);
@@ -1038,7 +1037,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 	protected void cacheMergedBeanDefinition(RootBeanDefinition mbd, String beanName) {
 		super.cacheMergedBeanDefinition(mbd, beanName);
 		if (mbd.isPrimary()) {
-			this.primaryBeanNamesWithType.put(beanName, Void.class);
+			this.primaryBeanNames.add(beanName);
 		}
 	}

@@ -1102,11 +1101,6 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		return null;
 	}

-	@Override
-	public void prepareSingletonBootstrap() {
-		this.mainThreadPrefix = getThreadNamePrefix();
-	}
-
 	@Override
 	public void preInstantiateSingletons() throws BeansException {
 		if (logger.isTraceEnabled()) {
@@ -1118,12 +1112,11 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

 		// Trigger initialization of all non-lazy singleton beans...
+		List<CompletableFuture<?>> futures = new ArrayList<>();
+
 		this.preInstantiationThread.set(PreInstantiation.MAIN);
-		if (this.mainThreadPrefix == null) {
-			this.mainThreadPrefix = getThreadNamePrefix();
-		}
+		this.mainThreadPrefix = getThreadNamePrefix();
 		try {
-			List<CompletableFuture<?>> futures = new ArrayList<>();
 			for (String beanName : beanNames) {
 				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 				if (!mbd.isAbstract() && mbd.isSingleton()) {
@@ -1133,20 +1126,21 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 					}
 				}
 			}
-			if (!futures.isEmpty()) {
-				try {
-					CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0])).join();
-				}
-				catch (CompletionException ex) {
-					ReflectionUtils.rethrowRuntimeException(ex.getCause());
-				}
-			}
 		}
 		finally {
 			this.mainThreadPrefix = null;
 			this.preInstantiationThread.remove();
 		}

+		if (!futures.isEmpty()) {
+			try {
+				CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0])).join();
+			}
+			catch (CompletionException ex) {
+				ReflectionUtils.rethrowRuntimeException(ex.getCause());
+			}
+		}
+
 		// Trigger post-initialization callback for all applicable beans...
 		for (String beanName : beanNames) {
 			Object singletonInstance = getSingleton(beanName, false);
@@ -1319,7 +1313,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto

 		// Cache a primary marker for the given bean.
 		if (beanDefinition.isPrimary()) {
-			this.primaryBeanNamesWithType.put(beanName, Void.class);
+			this.primaryBeanNames.add(beanName);
 		}
 	}

@@ -1411,7 +1405,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		destroySingleton(beanName);

 		// Remove a cached primary marker for the given bean.
-		this.primaryBeanNamesWithType.remove(beanName);
+		this.primaryBeanNames.remove(beanName);

 		// Notify all post-processors that the specified bean definition has been reset.
 		for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
@@ -1461,30 +1455,11 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		}
 	}

-	@Override
-	protected void addSingleton(String beanName, Object singletonObject) {
-		super.addSingleton(beanName, singletonObject);
-
-		Predicate<Class<?>> filter = (beanType -> beanType != Object.class && beanType.isInstance(singletonObject));
-		this.allBeanNamesByType.keySet().removeIf(filter);
-		this.singletonBeanNamesByType.keySet().removeIf(filter);
-
-		if (this.primaryBeanNamesWithType.containsKey(beanName) && singletonObject.getClass() != NullBean.class) {
-			Class<?> beanType = (singletonObject instanceof FactoryBean<?> fb ?
-					getTypeForFactoryBean(fb) : singletonObject.getClass());
-			if (beanType != null) {
-				this.primaryBeanNamesWithType.put(beanName, beanType);
-			}
-		}
-	}
-
 	@Override
 	public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
 		super.registerSingleton(beanName, singletonObject);
-
 		updateManualSingletonNames(set -> set.add(beanName), set -> !this.beanDefinitionMap.containsKey(beanName));
-		this.allBeanNamesByType.remove(Object.class);
-		this.singletonBeanNamesByType.remove(Object.class);
+		clearByTypeCache();
 	}

 	@Override
@@ -1653,8 +1628,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 		return doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
 	}

-	@SuppressWarnings("NullAway")  // Dataflow analysis limitation
 	@Nullable
+	@SuppressWarnings("NullAway")
 	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
 			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

@@ -1991,8 +1966,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 			DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
 			for (String candidate : candidateNames) {
 				if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
-						(!multiple || matchesBeanName(candidate, descriptor.getDependencyName()) ||
-								getAutowireCandidateResolver().hasQualifier(descriptor))) {
+						(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
 					addCandidateEntry(result, candidate, descriptor, requiredType);
 				}
 			}
@@ -2109,9 +2083,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 					boolean candidateLocal = containsBeanDefinition(candidateBeanName);
 					boolean primaryLocal = containsBeanDefinition(primaryBeanName);
 					if (candidateLocal == primaryLocal) {
-						String message = "more than one 'primary' bean found among candidates: " + candidates.keySet();
-						logger.trace(message);
-						throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(), message);
+						throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
+								"more than one 'primary' bean found among candidates: " + candidates.keySet());
 					}
 					else if (candidateLocal) {
 						primaryBeanName = candidateBeanName;
@@ -2263,12 +2236,12 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 	}

 	/**
-	 * Determine whether the given dependency name matches the bean name or the aliases
+	 * Determine whether the given candidate name matches the bean name or the aliases
 	 * stored in this bean definition.
 	 */
-	protected boolean matchesBeanName(String beanName, @Nullable String dependencyName) {
-		return (dependencyName != null &&
-				(dependencyName.equals(beanName) || ObjectUtils.containsElement(getAliases(beanName), dependencyName)));
+	protected boolean matchesBeanName(String beanName, @Nullable String candidateName) {
+		return (candidateName != null &&
+				(candidateName.equals(beanName) || ObjectUtils.containsElement(getAliases(beanName), candidateName)));
 	}

 	/**
@@ -2288,12 +2261,8 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 	 * not matching the given bean name.
 	 */
 	private boolean hasPrimaryConflict(String beanName, Class<?> dependencyType) {
-		for (Map.Entry<String, Class<?>> candidate : this.primaryBeanNamesWithType.entrySet()) {
-			String candidateName = candidate.getKey();
-			Class<?> candidateType = candidate.getValue();
-			if (!candidateName.equals(beanName) && (candidateType != Void.class ?
-					dependencyType.isAssignableFrom(candidateType) :  // cached singleton class for primary bean
-					isTypeMatch(candidateName, dependencyType))) {  // not instantiated yet or not a singleton
+		for (String candidate : this.primaryBeanNames) {
+			if (isTypeMatch(candidate, dependencyType) && !candidate.equals(beanName)) {
 				return true;
 			}
 		}
@@ -585,7 +585,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	public void registerContainedBean(String containedBeanName, String containingBeanName) {
 		synchronized (this.containedBeanMap) {
 			Set<String> containedBeans =
-					this.containedBeanMap.computeIfAbsent(containingBeanName, key -> new LinkedHashSet<>(8));
+					this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
 			if (!containedBeans.add(containedBeanName)) {
 				return;
 			}
@@ -604,7 +604,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements

 		synchronized (this.dependentBeanMap) {
 			Set<String> dependentBeans =
-					this.dependentBeanMap.computeIfAbsent(canonicalName, key -> new LinkedHashSet<>(8));
+					this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
 			if (!dependentBeans.add(dependentBeanName)) {
 				return;
 			}
@@ -612,7 +612,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements

 		synchronized (this.dependenciesForBeanMap) {
 			Set<String> dependenciesForBean =
-					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, key -> new LinkedHashSet<>(8));
+					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
 			dependenciesForBean.add(canonicalName);
 		}
 	}
@@ -23,7 +23,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;

 import org.apache.commons.logging.Log;
@@ -419,29 +418,14 @@ class DisposableBeanAdapter implements DisposableBean, Runnable, Serializable {
 		String destroyMethodName = beanDefinition.resolvedDestroyMethodName;
 		if (destroyMethodName == null) {
 			destroyMethodName = beanDefinition.getDestroyMethodName();
-			boolean autoCloseable = AutoCloseable.class.isAssignableFrom(target);
-			boolean executorService = ExecutorService.class.isAssignableFrom(target);
+			boolean autoCloseable = (AutoCloseable.class.isAssignableFrom(target));
 			if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName) ||
-					(destroyMethodName == null && (autoCloseable || executorService))) {
+					(destroyMethodName == null && autoCloseable)) {
 				// Only perform destroy method inference in case of the bean
 				// not explicitly implementing the DisposableBean interface
 				destroyMethodName = null;
 				if (!(DisposableBean.class.isAssignableFrom(target))) {
-					if (executorService) {
-						destroyMethodName = SHUTDOWN_METHOD_NAME;
-						try {
-							// On JDK 19+, avoid the ExecutorService-level AutoCloseable default implementation
-							// which awaits task termination for 1 day, even for delayed tasks such as cron jobs.
-							// Custom close() implementations in ExecutorService subclasses are still accepted.
-							if (target.getMethod(CLOSE_METHOD_NAME).getDeclaringClass() != ExecutorService.class) {
-								destroyMethodName = CLOSE_METHOD_NAME;
-							}
-						}
-						catch (NoSuchMethodException ex) {
-							// Ignore - stick with shutdown()
-						}
-					}
-					else if (autoCloseable) {
+					if (autoCloseable) {
 						destroyMethodName = CLOSE_METHOD_NAME;
 					}
 					else {
@@ -128,48 +128,43 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
 				locked = (lockFlag && this.singletonLock.tryLock());
 			}
 			try {
-				// Defensively synchronize against non-thread-safe FactoryBean.getObject() implementations,
-				// potentially to be called from a background thread while the main thread currently calls
-				// the same getObject() method within the singleton lock.
-				synchronized (factory) {
-					Object object = this.factoryBeanObjectCache.get(beanName);
-					if (object == null) {
-						object = doGetObjectFromFactoryBean(factory, beanName);
-						// Only post-process and store if not put there already during getObject() call above
-						// (for example, because of circular reference processing triggered by custom getBean calls)
-						Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
-						if (alreadyThere != null) {
-							object = alreadyThere;
-						}
-						else {
-							if (shouldPostProcess) {
+				Object object = this.factoryBeanObjectCache.get(beanName);
+				if (object == null) {
+					object = doGetObjectFromFactoryBean(factory, beanName);
+					// Only post-process and store if not put there already during getObject() call above
+					// (for example, because of circular reference processing triggered by custom getBean calls)
+					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
+					if (alreadyThere != null) {
+						object = alreadyThere;
+					}
+					else {
+						if (shouldPostProcess) {
+							if (locked) {
+								if (isSingletonCurrentlyInCreation(beanName)) {
+									// Temporarily return non-post-processed object, not storing it yet
+									return object;
+								}
+								beforeSingletonCreation(beanName);
+							}
+							try {
+								object = postProcessObjectFromFactoryBean(object, beanName);
+							}
+							catch (Throwable ex) {
+								throw new BeanCreationException(beanName,
+										"Post-processing of FactoryBean's singleton object failed", ex);
+							}
+							finally {
 								if (locked) {
-									if (isSingletonCurrentlyInCreation(beanName)) {
-										// Temporarily return non-post-processed object, not storing it yet
-										return object;
-									}
-									beforeSingletonCreation(beanName);
-								}
-								try {
-									object = postProcessObjectFromFactoryBean(object, beanName);
-								}
-								catch (Throwable ex) {
-									throw new BeanCreationException(beanName,
-											"Post-processing of FactoryBean's singleton object failed", ex);
-								}
-								finally {
-									if (locked) {
-										afterSingletonCreation(beanName);
-									}
+									afterSingletonCreation(beanName);
 								}
 							}
-							if (containsSingleton(beanName)) {
-								this.factoryBeanObjectCache.put(beanName, object);
-							}
+						}
+						if (containsSingleton(beanName)) {
+							this.factoryBeanObjectCache.put(beanName, object);
 						}
 					}
-					return object;
 				}
+				return object;
 			}
 			finally {
 				if (locked) {
@@ -74,10 +74,10 @@ import org.springframework.util.StringUtils;
 * @author Rob Harrop
 * @since 26.11.2003
 * @see DefaultListableBeanFactory
- * @deprecated in favor of Spring's common bean definition formats and/or
- * custom BeanDefinitionReader implementations
+ * @deprecated as of 5.3, in favor of Spring's common bean definition formats
+ * and/or custom reader implementations
 */
-@Deprecated(since = "5.3")
+@Deprecated
 public class PropertiesBeanDefinitionReader extends AbstractBeanDefinitionReader {

 	/**
@@ -103,7 +103,7 @@ public class PathEditor extends PropertyEditorSupport {
 		if (resource == null) {
 			setValue(null);
 		}
-		else if (nioPathCandidate && (!resource.isFile() || !resource.exists())) {
+		else if (nioPathCandidate && !resource.exists()) {
 			setValue(Paths.get(text).normalize());
 		}
 		else {
@@ -472,7 +472,7 @@ abstract class AbstractPropertyAccessorTests {
 		assertThat(target.getAge()).as("age is OK").isEqualTo(age);
 		assertThat(name).as("name is OK").isEqualTo(target.getName());
 		accessor.setPropertyValues(new MutablePropertyValues());
-		// Check it's unchanged
+		// Check its unchanged
 		assertThat(target.getAge()).as("age is OK").isEqualTo(age);
 		assertThat(name).as("name is OK").isEqualTo(target.getName());
 	}
@@ -33,12 +33,10 @@ import java.util.List;
 import java.util.Locale;
 import java.util.UUID;

-import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;

-import org.springframework.beans.PropertyDescriptorUtilsPropertyResolutionTests.ServiceWithOverriddenGetterAndOverloadedSetter;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.propertyeditors.CustomDateEditor;
 import org.springframework.beans.testfixture.beans.DerivedTestBean;
@@ -69,14 +67,14 @@ class BeanUtilsTests {

 	@Test
 	void instantiateClassGivenInterface() {
-		assertThatExceptionOfType(FatalBeanException.class)
-				.isThrownBy(() -> BeanUtils.instantiateClass(List.class));
+		assertThatExceptionOfType(FatalBeanException.class).isThrownBy(() ->
+				BeanUtils.instantiateClass(List.class));
 	}

 	@Test
 	void instantiateClassGivenClassWithoutDefaultConstructor() {
-		assertThatExceptionOfType(FatalBeanException.class)
-				.isThrownBy(() -> BeanUtils.instantiateClass(CustomDateEditor.class));
+		assertThatExceptionOfType(FatalBeanException.class).isThrownBy(() ->
+				BeanUtils.instantiateClass(CustomDateEditor.class));
 	}

 	@Test  // gh-22531
@@ -93,16 +91,16 @@ class BeanUtilsTests {
 	void instantiateClassWithFewerArgsThanParameters() throws NoSuchMethodException {
 		Constructor<BeanWithPrimitiveTypes> constructor = getBeanWithPrimitiveTypesConstructor();

-		assertThatExceptionOfType(BeanInstantiationException.class)
-				.isThrownBy(() -> BeanUtils.instantiateClass(constructor, null, null, "foo"));
+		assertThatExceptionOfType(BeanInstantiationException.class).isThrownBy(() ->
+				BeanUtils.instantiateClass(constructor, null, null, "foo"));
 	}

 	@Test  // gh-22531
 	void instantiateClassWithMoreArgsThanParameters() throws NoSuchMethodException {
 		Constructor<BeanWithPrimitiveTypes> constructor = getBeanWithPrimitiveTypesConstructor();

-		assertThatExceptionOfType(BeanInstantiationException.class)
-				.isThrownBy(() -> BeanUtils.instantiateClass(constructor, null, null, null, null, null, null, null, null, "foo", null));
+		assertThatExceptionOfType(BeanInstantiationException.class).isThrownBy(() ->
+				BeanUtils.instantiateClass(constructor, null, null, null, null, null, null, null, null, "foo", null));
 	}

 	@Test  // gh-22531, gh-27390
@@ -159,6 +157,267 @@ class BeanUtilsTests {
 		assertThat(BeanUtils.findEditorByConvention(Resource.class).getClass()).isEqualTo(ResourceEditor.class);
 	}

+	@Test
+	void copyProperties() throws Exception {
+		TestBean tb = new TestBean();
+		tb.setName("rod");
+		tb.setAge(32);
+		tb.setTouchy("touchy");
+		TestBean tb2 = new TestBean();
+		assertThat(tb2.getName()).as("Name empty").isNull();
+		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
+		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		BeanUtils.copyProperties(tb, tb2);
+		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
+		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
+		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+	}
+
+	@Test
+	void copyPropertiesWithDifferentTypes1() throws Exception {
+		DerivedTestBean tb = new DerivedTestBean();
+		tb.setName("rod");
+		tb.setAge(32);
+		tb.setTouchy("touchy");
+		TestBean tb2 = new TestBean();
+		assertThat(tb2.getName()).as("Name empty").isNull();
+		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
+		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		BeanUtils.copyProperties(tb, tb2);
+		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
+		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
+		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+	}
+
+	@Test
+	void copyPropertiesWithDifferentTypes2() throws Exception {
+		TestBean tb = new TestBean();
+		tb.setName("rod");
+		tb.setAge(32);
+		tb.setTouchy("touchy");
+		DerivedTestBean tb2 = new DerivedTestBean();
+		assertThat(tb2.getName()).as("Name empty").isNull();
+		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
+		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+		BeanUtils.copyProperties(tb, tb2);
+		assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
+		assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
+		assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
+	}
+
+	/**
+	 * {@code Integer} can be copied to {@code Number}.
+	 */
+	@Test
+	void copyPropertiesFromSubTypeToSuperType() {
+		IntegerHolder integerHolder = new IntegerHolder();
+		integerHolder.setNumber(42);
+		NumberHolder numberHolder = new NumberHolder();
+
+		BeanUtils.copyProperties(integerHolder, numberHolder);
+		assertThat(integerHolder.getNumber()).isEqualTo(42);
+		assertThat(numberHolder.getNumber()).isEqualTo(42);
+	}
+
+	/**
+	 * {@code List<Integer>} can be copied to {@code List<Integer>}.
+	 */
+	@Test
+	void copyPropertiesHonorsGenericTypeMatchesFromIntegerToInteger() {
+		IntegerListHolder1 integerListHolder1 = new IntegerListHolder1();
+		integerListHolder1.getList().add(42);
+		IntegerListHolder2 integerListHolder2 = new IntegerListHolder2();
+
+		BeanUtils.copyProperties(integerListHolder1, integerListHolder2);
+		assertThat(integerListHolder1.getList()).containsExactly(42);
+		assertThat(integerListHolder2.getList()).containsExactly(42);
+	}
+
+	/**
+	 * {@code List<?>} can be copied to {@code List<?>}.
+	 */
+	@Test
+	void copyPropertiesHonorsGenericTypeMatchesFromWildcardToWildcard() {
+		List<?> list = List.of("foo", 42);
+		WildcardListHolder1 wildcardListHolder1 = new WildcardListHolder1();
+		wildcardListHolder1.setList(list);
+		WildcardListHolder2 wildcardListHolder2 = new WildcardListHolder2();
+		assertThat(wildcardListHolder2.getList()).isEmpty();
+
+		BeanUtils.copyProperties(wildcardListHolder1, wildcardListHolder2);
+		assertThat(wildcardListHolder1.getList()).isEqualTo(list);
+		assertThat(wildcardListHolder2.getList()).isEqualTo(list);
+	}
+
+	/**
+	 * {@code List<Integer>} can be copied to {@code List<?>}.
+	 */
+	@Test
+	void copyPropertiesHonorsGenericTypeMatchesFromIntegerToWildcard() {
+		IntegerListHolder1 integerListHolder1 = new IntegerListHolder1();
+		integerListHolder1.getList().add(42);
+		WildcardListHolder2 wildcardListHolder2 = new WildcardListHolder2();
+
+		BeanUtils.copyProperties(integerListHolder1, wildcardListHolder2);
+		assertThat(integerListHolder1.getList()).containsExactly(42);
+		assertThat(wildcardListHolder2.getList()).isEqualTo(List.of(42));
+	}
+
+	/**
+	 * {@code List<Integer>} can be copied to {@code List<? extends Number>}.
+	 */
+	@Test
+	void copyPropertiesHonorsGenericTypeMatchesForUpperBoundedWildcard() {
+		IntegerListHolder1 integerListHolder1 = new IntegerListHolder1();
+		integerListHolder1.getList().add(42);
+		NumberUpperBoundedWildcardListHolder numberListHolder = new NumberUpperBoundedWildcardListHolder();
+
+		BeanUtils.copyProperties(integerListHolder1, numberListHolder);
+		assertThat(integerListHolder1.getList()).containsExactly(42);
+		assertThat(numberListHolder.getList()).isEqualTo(List.of(42));
+	}
+
+	/**
+	 * {@code Number} can NOT be copied to {@code Integer}.
+	 */
+	@Test
+	void copyPropertiesDoesNotCopyFromSuperTypeToSubType() {
+		NumberHolder numberHolder = new NumberHolder();
+		numberHolder.setNumber(42);
+		IntegerHolder integerHolder = new IntegerHolder();
+
+		BeanUtils.copyProperties(numberHolder, integerHolder);
+		assertThat(numberHolder.getNumber()).isEqualTo(42);
+		assertThat(integerHolder.getNumber()).isNull();
+	}
+
+	/**
+	 * {@code List<Integer>} can NOT be copied to {@code List<Long>}.
+	 */
+	@Test
+	void copyPropertiesDoesNotHonorGenericTypeMismatches() {
+		IntegerListHolder1 integerListHolder = new IntegerListHolder1();
+		integerListHolder.getList().add(42);
+		LongListHolder longListHolder = new LongListHolder();
+
+		BeanUtils.copyProperties(integerListHolder, longListHolder);
+		assertThat(integerListHolder.getList()).containsExactly(42);
+		assertThat(longListHolder.getList()).isEmpty();
+	}
+
+	/**
+	 * {@code List<Integer>} can NOT be copied to {@code List<Number>}.
+	 */
+	@Test
+	void copyPropertiesDoesNotHonorGenericTypeMismatchesFromSubTypeToSuperType() {
+		IntegerListHolder1 integerListHolder = new IntegerListHolder1();
+		integerListHolder.getList().add(42);
+		NumberListHolder numberListHolder = new NumberListHolder();
+
+		BeanUtils.copyProperties(integerListHolder, numberListHolder);
+		assertThat(integerListHolder.getList()).containsExactly(42);
+		assertThat(numberListHolder.getList()).isEmpty();
+	}
+
+	@Test  // gh-26531
+	void copyPropertiesIgnoresGenericsIfSourceOrTargetHasUnresolvableGenerics() throws Exception {
+		Order original = new Order("test", List.of("foo", "bar"));
+
+		// Create a Proxy that loses the generic type information for the getLineItems() method.
+		OrderSummary proxy = (OrderSummary) Proxy.newProxyInstance(getClass().getClassLoader(),
+				new Class<?>[] {OrderSummary.class}, new OrderInvocationHandler(original));
+		assertThat(OrderSummary.class.getDeclaredMethod("getLineItems").toGenericString())
+				.contains("java.util.List<java.lang.String>");
+		assertThat(proxy.getClass().getDeclaredMethod("getLineItems").toGenericString())
+				.contains("java.util.List")
+				.doesNotContain("<java.lang.String>");
+
+		// Ensure that our custom Proxy works as expected.
+		assertThat(proxy.getId()).isEqualTo("test");
+		assertThat(proxy.getLineItems()).containsExactly("foo", "bar");
+
+		// Copy from proxy to target.
+		Order target = new Order();
+		BeanUtils.copyProperties(proxy, target);
+		assertThat(target.getId()).isEqualTo("test");
+		assertThat(target.getLineItems()).containsExactly("foo", "bar");
+	}
+
+	@Test  // gh-32888
+	public void copyPropertiesWithGenericCglibClass() {
+		Enhancer enhancer = new Enhancer();
+		enhancer.setSuperclass(User.class);
+		enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> proxy.invokeSuper(obj, args));
+		User user = (User) enhancer.create();
+		user.setId(1);
+		user.setName("proxy");
+		user.setAddress("addr");
+
+		User target = new User();
+		BeanUtils.copyProperties(user, target);
+		assertThat(target.getId()).isEqualTo(user.getId());
+		assertThat(target.getName()).isEqualTo(user.getName());
+		assertThat(target.getAddress()).isEqualTo(user.getAddress());
+	}
+
+	@Test
+	void copyPropertiesWithEditable() throws Exception {
+		TestBean tb = new TestBean();
+		assertThat(tb.getName()).as("Name empty").isNull();
+		tb.setAge(32);
+		tb.setTouchy("bla");
+		TestBean tb2 = new TestBean();
+		tb2.setName("rod");
+		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
+		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+
+		// "touchy" should not be copied: it's not defined in ITestBean
+		BeanUtils.copyProperties(tb, tb2, ITestBean.class);
+		assertThat(tb2.getName()).as("Name copied").isNull();
+		assertThat(tb2.getAge()).as("Age copied").isEqualTo(32);
+		assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
+	}
+
+	@Test
+	void copyPropertiesWithIgnore() throws Exception {
+		TestBean tb = new TestBean();
+		assertThat(tb.getName()).as("Name empty").isNull();
+		tb.setAge(32);
+		tb.setTouchy("bla");
+		TestBean tb2 = new TestBean();
+		tb2.setName("rod");
+		assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
+		assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
+
+		// "spouse", "touchy", "age" should not be copied
+		BeanUtils.copyProperties(tb, tb2, "spouse", "touchy", "age");
+		assertThat(tb2.getName()).as("Name copied").isNull();
+		assertThat(tb2.getAge()).as("Age still empty").isEqualTo(0);
+		assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
+	}
+
+	@Test
+	void copyPropertiesWithIgnoredNonExistingProperty() {
+		NameAndSpecialProperty source = new NameAndSpecialProperty();
+		source.setName("name");
+		TestBean target = new TestBean();
+		BeanUtils.copyProperties(source, target, "specialProperty");
+		assertThat(target.getName()).isEqualTo("name");
+	}
+
+	@Test
+	void copyPropertiesWithInvalidProperty() {
+		InvalidProperty source = new InvalidProperty();
+		source.setName("name");
+		source.setFlag1(true);
+		source.setFlag2(true);
+		InvalidProperty target = new InvalidProperty();
+		BeanUtils.copyProperties(source, target);
+		assertThat(target.getName()).isEqualTo("name");
+		assertThat((boolean) target.getFlag1()).isTrue();
+		assertThat(target.getFlag2()).isTrue();
+	}
+
 	@Test
 	void resolveSimpleSignature() throws Exception {
 		Method desiredMethod = MethodSignatureBean.class.getMethod("doSomething");
@@ -168,14 +427,14 @@ class BeanUtilsTests {

 	@Test
 	void resolveInvalidSignatureEndParen() {
-		assertThatIllegalArgumentException()
-				.isThrownBy(() -> BeanUtils.resolveSignature("doSomething(", MethodSignatureBean.class));
+		assertThatIllegalArgumentException().isThrownBy(() ->
+				BeanUtils.resolveSignature("doSomething(", MethodSignatureBean.class));
 	}

 	@Test
 	void resolveInvalidSignatureStartParen() {
-		assertThatIllegalArgumentException()
-				.isThrownBy(() -> BeanUtils.resolveSignature("doSomething)", MethodSignatureBean.class));
+		assertThatIllegalArgumentException().isThrownBy(() ->
+				BeanUtils.resolveSignature("doSomething)", MethodSignatureBean.class));
 	}

 	@Test
@@ -279,283 +538,6 @@ class BeanUtilsTests {
 	}


-	@Nested
-	class CopyPropertiesTests {
-
-		@Test
-		void copyProperties() throws Exception {
-			TestBean tb = new TestBean();
-			tb.setName("rod");
-			tb.setAge(32);
-			tb.setTouchy("touchy");
-			TestBean tb2 = new TestBean();
-			assertThat(tb2.getName()).as("Name empty").isNull();
-			assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-			assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
-			BeanUtils.copyProperties(tb, tb2);
-			assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-			assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-			assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
-		}
-
-		@Test
-		void copyPropertiesWithDifferentTypes1() throws Exception {
-			DerivedTestBean tb = new DerivedTestBean();
-			tb.setName("rod");
-			tb.setAge(32);
-			tb.setTouchy("touchy");
-			TestBean tb2 = new TestBean();
-			assertThat(tb2.getName()).as("Name empty").isNull();
-			assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-			assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
-			BeanUtils.copyProperties(tb, tb2);
-			assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-			assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-			assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
-		}
-
-		@Test
-		void copyPropertiesWithDifferentTypes2() throws Exception {
-			TestBean tb = new TestBean();
-			tb.setName("rod");
-			tb.setAge(32);
-			tb.setTouchy("touchy");
-			DerivedTestBean tb2 = new DerivedTestBean();
-			assertThat(tb2.getName()).as("Name empty").isNull();
-			assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-			assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
-			BeanUtils.copyProperties(tb, tb2);
-			assertThat(tb2.getName()).as("Name copied").isEqualTo(tb.getName());
-			assertThat(tb2.getAge()).as("Age copied").isEqualTo(tb.getAge());
-			assertThat(tb2.getTouchy()).as("Touchy copied").isEqualTo(tb.getTouchy());
-		}
-
-		/**
-		 * {@code Integer} can be copied to {@code Number}.
-		 */
-		@Test
-		void copyPropertiesFromSubTypeToSuperType() {
-			IntegerHolder integerHolder = new IntegerHolder();
-			integerHolder.setNumber(42);
-			NumberHolder numberHolder = new NumberHolder();
-
-			BeanUtils.copyProperties(integerHolder, numberHolder);
-			assertThat(integerHolder.getNumber()).isEqualTo(42);
-			assertThat(numberHolder.getNumber()).isEqualTo(42);
-		}
-
-		/**
-		 * {@code List<Integer>} can be copied to {@code List<Integer>}.
-		 */
-		@Test
-		void copyPropertiesHonorsGenericTypeMatchesFromIntegerToInteger() {
-			IntegerListHolder1 integerListHolder1 = new IntegerListHolder1();
-			integerListHolder1.getList().add(42);
-			IntegerListHolder2 integerListHolder2 = new IntegerListHolder2();
-
-			BeanUtils.copyProperties(integerListHolder1, integerListHolder2);
-			assertThat(integerListHolder1.getList()).containsExactly(42);
-			assertThat(integerListHolder2.getList()).containsExactly(42);
-		}
-
-		/**
-		 * {@code List<?>} can be copied to {@code List<?>}.
-		 */
-		@Test
-		void copyPropertiesHonorsGenericTypeMatchesFromWildcardToWildcard() {
-			List<?> list = List.of("foo", 42);
-			WildcardListHolder1 wildcardListHolder1 = new WildcardListHolder1();
-			wildcardListHolder1.setList(list);
-			WildcardListHolder2 wildcardListHolder2 = new WildcardListHolder2();
-			assertThat(wildcardListHolder2.getList()).isEmpty();
-
-			BeanUtils.copyProperties(wildcardListHolder1, wildcardListHolder2);
-			assertThat(wildcardListHolder1.getList()).isEqualTo(list);
-			assertThat(wildcardListHolder2.getList()).isEqualTo(list);
-		}
-
-		/**
-		 * {@code List<Integer>} can be copied to {@code List<?>}.
-		 */
-		@Test
-		void copyPropertiesHonorsGenericTypeMatchesFromIntegerToWildcard() {
-			IntegerListHolder1 integerListHolder1 = new IntegerListHolder1();
-			integerListHolder1.getList().add(42);
-			WildcardListHolder2 wildcardListHolder2 = new WildcardListHolder2();
-
-			BeanUtils.copyProperties(integerListHolder1, wildcardListHolder2);
-			assertThat(integerListHolder1.getList()).containsExactly(42);
-			assertThat(wildcardListHolder2.getList()).isEqualTo(List.of(42));
-		}
-
-		/**
-		 * {@code List<Integer>} can be copied to {@code List<? extends Number>}.
-		 */
-		@Test
-		void copyPropertiesHonorsGenericTypeMatchesForUpperBoundedWildcard() {
-			IntegerListHolder1 integerListHolder1 = new IntegerListHolder1();
-			integerListHolder1.getList().add(42);
-			NumberUpperBoundedWildcardListHolder numberListHolder = new NumberUpperBoundedWildcardListHolder();
-
-			BeanUtils.copyProperties(integerListHolder1, numberListHolder);
-			assertThat(integerListHolder1.getList()).containsExactly(42);
-			assertThat(numberListHolder.getList()).isEqualTo(List.of(42));
-		}
-
-		/**
-		 * {@code Number} can NOT be copied to {@code Integer}.
-		 */
-		@Test
-		void copyPropertiesDoesNotCopyFromSuperTypeToSubType() {
-			NumberHolder numberHolder = new NumberHolder();
-			numberHolder.setNumber(42);
-			IntegerHolder integerHolder = new IntegerHolder();
-
-			BeanUtils.copyProperties(numberHolder, integerHolder);
-			assertThat(numberHolder.getNumber()).isEqualTo(42);
-			assertThat(integerHolder.getNumber()).isNull();
-		}
-
-		/**
-		 * {@code List<Integer>} can NOT be copied to {@code List<Long>}.
-		 */
-		@Test
-		void copyPropertiesDoesNotHonorGenericTypeMismatches() {
-			IntegerListHolder1 integerListHolder = new IntegerListHolder1();
-			integerListHolder.getList().add(42);
-			LongListHolder longListHolder = new LongListHolder();
-
-			BeanUtils.copyProperties(integerListHolder, longListHolder);
-			assertThat(integerListHolder.getList()).containsExactly(42);
-			assertThat(longListHolder.getList()).isEmpty();
-		}
-
-		/**
-		 * {@code List<Integer>} can NOT be copied to {@code List<Number>}.
-		 */
-		@Test
-		void copyPropertiesDoesNotHonorGenericTypeMismatchesFromSubTypeToSuperType() {
-			IntegerListHolder1 integerListHolder = new IntegerListHolder1();
-			integerListHolder.getList().add(42);
-			NumberListHolder numberListHolder = new NumberListHolder();
-
-			BeanUtils.copyProperties(integerListHolder, numberListHolder);
-			assertThat(integerListHolder.getList()).containsExactly(42);
-			assertThat(numberListHolder.getList()).isEmpty();
-		}
-
-		@Test  // gh-26531
-		void copyPropertiesIgnoresGenericsIfSourceOrTargetHasUnresolvableGenerics() throws Exception {
-			Order original = new Order("test", List.of("foo", "bar"));
-
-			// Create a Proxy that loses the generic type information for the getLineItems() method.
-			OrderSummary proxy = (OrderSummary) Proxy.newProxyInstance(getClass().getClassLoader(),
-				new Class<?>[] {OrderSummary.class}, new OrderInvocationHandler(original));
-			assertThat(OrderSummary.class.getDeclaredMethod("getLineItems").toGenericString())
-					.contains("java.util.List<java.lang.String>");
-			assertThat(proxy.getClass().getDeclaredMethod("getLineItems").toGenericString())
-					.contains("java.util.List")
-					.doesNotContain("<java.lang.String>");
-
-			// Ensure that our custom Proxy works as expected.
-			assertThat(proxy.getId()).isEqualTo("test");
-			assertThat(proxy.getLineItems()).containsExactly("foo", "bar");
-
-			// Copy from proxy to target.
-			Order target = new Order();
-			BeanUtils.copyProperties(proxy, target);
-			assertThat(target.getId()).isEqualTo("test");
-			assertThat(target.getLineItems()).containsExactly("foo", "bar");
-		}
-
-		@Test  // gh-32888
-		void copyPropertiesWithGenericCglibClass() {
-			Enhancer enhancer = new Enhancer();
-			enhancer.setSuperclass(User.class);
-			enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> proxy.invokeSuper(obj, args));
-			User user = (User) enhancer.create();
-			user.setId(1);
-			user.setName("proxy");
-			user.setAddress("addr");
-
-			User target = new User();
-			BeanUtils.copyProperties(user, target);
-			assertThat(target.getId()).isEqualTo(user.getId());
-			assertThat(target.getName()).isEqualTo(user.getName());
-			assertThat(target.getAddress()).isEqualTo(user.getAddress());
-		}
-
-		@Test
-		void copyPropertiesWithEditable() throws Exception {
-			TestBean tb = new TestBean();
-			assertThat(tb.getName()).as("Name empty").isNull();
-			tb.setAge(32);
-			tb.setTouchy("bla");
-			TestBean tb2 = new TestBean();
-			tb2.setName("rod");
-			assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-			assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
-
-			// "touchy" should not be copied: it's not defined in ITestBean
-			BeanUtils.copyProperties(tb, tb2, ITestBean.class);
-			assertThat(tb2.getName()).as("Name copied").isNull();
-			assertThat(tb2.getAge()).as("Age copied").isEqualTo(32);
-			assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
-		}
-
-		@Test
-		void copyPropertiesWithIgnore() throws Exception {
-			TestBean tb = new TestBean();
-			assertThat(tb.getName()).as("Name empty").isNull();
-			tb.setAge(32);
-			tb.setTouchy("bla");
-			TestBean tb2 = new TestBean();
-			tb2.setName("rod");
-			assertThat(tb2.getAge()).as("Age empty").isEqualTo(0);
-			assertThat(tb2.getTouchy()).as("Touchy empty").isNull();
-
-			// "spouse", "touchy", "age" should not be copied
-			BeanUtils.copyProperties(tb, tb2, "spouse", "touchy", "age");
-			assertThat(tb2.getName()).as("Name copied").isNull();
-			assertThat(tb2.getAge()).as("Age still empty").isEqualTo(0);
-			assertThat(tb2.getTouchy()).as("Touchy still empty").isNull();
-		}
-
-		@Test
-		void copyPropertiesWithIgnoredNonExistingProperty() {
-			NameAndSpecialProperty source = new NameAndSpecialProperty();
-			source.setName("name");
-			TestBean target = new TestBean();
-			BeanUtils.copyProperties(source, target, "specialProperty");
-			assertThat(target.getName()).isEqualTo("name");
-		}
-
-		@Test
-		void copyPropertiesWithInvalidProperty() {
-			InvalidProperty source = new InvalidProperty();
-			source.setName("name");
-			source.setFlag1(true);
-			source.setFlag2(true);
-			InvalidProperty target = new InvalidProperty();
-			BeanUtils.copyProperties(source, target);
-			assertThat(target.getName()).isEqualTo("name");
-			assertThat((boolean) target.getFlag1()).isTrue();
-			assertThat(target.getFlag2()).isTrue();
-		}
-
-		@Test  // gh-36019
-		void copyPropertiesHonorsGenericsInTypeHieararchyAndIgnoresOverloadedSetterMethod() {
-			var source = new ServiceWithOverriddenGetterAndOverloadedSetter();
-			var target = new ServiceWithOverriddenGetterAndOverloadedSetter();
-
-			source.setId(1);
-			BeanUtils.copyProperties(source, target);
-
-			assertThat(target.getId()).isEqualTo(source.getId()).isEqualTo("1");
-		}
-	}
-
-
 	public record RecordWithMultiplePublicConstructors(String value, String name) {
 		@SuppressWarnings("unused")
 		public RecordWithMultiplePublicConstructors(String value) {
@@ -1,265 +0,0 @@
-/*
- * Copyright 2002-present 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.beans;
-
-import java.beans.Introspector;
-import java.beans.PropertyDescriptor;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Stream;
-
-import org.junit.jupiter.api.Named;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.Parameter;
-import org.junit.jupiter.params.ParameterizedClass;
-import org.junit.jupiter.params.provider.FieldSource;
-
-import static java.util.stream.Collectors.groupingBy;
-import static java.util.stream.Collectors.toList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assumptions.assumeThat;
-import static org.assertj.core.api.SoftAssertions.assertSoftly;
-import static org.junit.jupiter.api.Named.named;
-
-/**
- * Unit tests for property descriptor resolution via
- * {@link PropertyDescriptorUtils#determineBasicProperties(Class)}.
- *
- * <p>Results are compared to the behavior of the standard {@link Introspector}.
- *
- * @author Sam Brannen
- * @since 6.2.16
- */
-@ParameterizedClass(name = "{0}")
-@FieldSource("resolvers")
-class PropertyDescriptorUtilsPropertyResolutionTests {
-
-	static final List<Named<PropertiesResolver>> resolvers = List.of(
-			named("Basic Properties", new BasicPropertiesResolver()),
-			named("Standard Properties", new StandardPropertiesResolver()));
-
-
-	@Parameter
-	PropertiesResolver resolver;
-
-
-	@Test
-	void determineBasicPropertiesWithUnresolvedGenericsInInterface() {
-		var pdMap = resolver.resolve(GenericService.class);
-
-		assertThat(pdMap).containsOnlyKeys("id");
-		assertReadAndWriteMethodsForId(pdMap.get("id"), Object.class, Object.class);
-	}
-
-	@Test
-	void determineBasicPropertiesWithUnresolvedGenericsInSubInterface() {
-		// FYI: java.beans.Introspector does not resolve properties for sub-interfaces.
-		assumeThat(resolver).isNotInstanceOf(StandardPropertiesResolver.class);
-
-		var pdMap = resolver.resolve(SubGenericService.class);
-
-		assertThat(pdMap).containsOnlyKeys("id");
-		assertReadAndWriteMethodsForId(pdMap.get("id"), Object.class, Object.class);
-	}
-
-	@Test
-	void resolvePropertiesWithUnresolvedGenericsInClass() {
-		var pdMap = resolver.resolve(BaseService.class);
-
-		assertReadAndWriteMethodsForClassAndId(pdMap, Object.class, Object.class);
-	}
-
-	@Test  // gh-36019
-	void resolvePropertiesInSubclassWithOverriddenGetterAndSetter() {
-		var pdMap = resolver.resolve(ServiceWithOverriddenGetterAndSetter.class);
-
-		assertReadAndWriteMethodsForClassAndId(pdMap, String.class, String.class);
-	}
-
-	@Test  // gh-36019
-	void resolvePropertiesWithUnresolvedGenericsInSubclassWithOverloadedSetter() {
-		var pdMap = resolver.resolve(ServiceWithOverloadedSetter.class);
-
-		assertReadAndWriteMethodsForClassAndId(pdMap, Object.class, Object.class);
-	}
-
-	@Test  // gh-36019
-	void resolvePropertiesWithPartiallyUnresolvedGenericsInSubclassWithOverriddenGetter() {
-		var pdMap = resolver.resolve(ServiceWithOverriddenGetter.class);
-
-		assertReadAndWriteMethodsForClassAndId(pdMap, String.class, Object.class);
-	}
-
-	@Test  // gh-36019
-	void resolvePropertiesWithPartiallyUnresolvedGenericsInSubclassWithOverriddenGetterAndOverloadedSetter() {
-		var pdMap = resolver.resolve(ServiceWithOverriddenGetterAndOverloadedSetter.class);
-
-		assertReadAndWriteMethodsForClassAndId(pdMap, String.class, Object.class);
-	}
-
-
-	private static void assertReadAndWriteMethodsForClassAndId(Map<String, List<PropertyDescriptor>> pdMap,
-			Class<?> readType, Class<?> writeType) {
-
-		assertThat(pdMap).containsOnlyKeys("class", "id");
-		assertReadAndWriteMethodsForClass(pdMap.get("class"));
-		assertReadAndWriteMethodsForId(pdMap.get("id"), readType, writeType);
-	}
-
-	private static void assertReadAndWriteMethodsForClass(List<PropertyDescriptor> pds) {
-		assertThat(pds).hasSize(1);
-		var pd = pds.get(0);
-		assertThat(pd.getName()).isEqualTo("class");
-
-		var readMethod = pd.getReadMethod();
-		assertThat(readMethod.getName()).isEqualTo("getClass");
-		assertThat(readMethod.getReturnType()).as("read type").isEqualTo(Class.class);
-		assertThat(readMethod.getParameterCount()).isZero();
-
-		assertThat(pd.getWriteMethod()).as("write method").isNull();
-	}
-
-	private static void assertReadAndWriteMethodsForId(List<PropertyDescriptor> pds, Class<?> readType, Class<?> writeType) {
-		assertThat(pds).hasSize(1);
-		var pd = pds.get(0);
-		assertThat(pd.getName()).isEqualTo("id");
-
-		var readMethod = pd.getReadMethod();
-		var writeMethod = pd.getWriteMethod();
-
-		assertSoftly(softly -> {
-			softly.assertThat(readMethod.getName()).isEqualTo("getId");
-			softly.assertThat(readMethod.getReturnType()).as("read type").isEqualTo(readType);
-			softly.assertThat(readMethod.getParameterCount()).isZero();
-
-			softly.assertThat(writeMethod).as("write method").isNotNull();
-			if (writeMethod != null) {
-				softly.assertThat(writeMethod.getName()).isEqualTo("setId");
-				softly.assertThat(writeMethod.getReturnType()).isEqualTo(void.class);
-				softly.assertThat(writeMethod.getParameterCount()).isEqualTo(1);
-				softly.assertThat(writeMethod.getParameterTypes()[0]).as("write type").isEqualTo(writeType);
-			}
-		});
-	}
-
-	private static Map<String, List<PropertyDescriptor>> toMap(Stream<? extends PropertyDescriptor> stream) {
-		return stream.collect(groupingBy(PropertyDescriptor::getName, toList()));
-	}
-
-
-	interface PropertiesResolver {
-
-		Map<String, List<PropertyDescriptor>> resolve(Class<?> beanClass);
-	}
-
-	static class BasicPropertiesResolver implements PropertiesResolver {
-
-		@Override
-		public Map<String, List<PropertyDescriptor>> resolve(Class<?> beanClass) {
-			try {
-				var pds = PropertyDescriptorUtils.determineBasicProperties(beanClass);
-				return toMap(pds.stream());
-			}
-			catch (Exception ex) {
-				throw new RuntimeException(ex);
-			}
-		}
-	}
-
-	static class StandardPropertiesResolver implements PropertiesResolver {
-
-		@Override
-		public Map<String, List<PropertyDescriptor>> resolve(Class<?> beanClass) {
-			try {
-				var beanInfo = Introspector.getBeanInfo(beanClass);
-				return toMap(Arrays.stream(beanInfo.getPropertyDescriptors()));
-			}
-			catch (Exception ex) {
-				throw new RuntimeException(ex);
-			}
-		}
-	}
-
-	interface GenericService<T> {
-
-		void setId(T id);
-
-		T getId();
-	}
-
-	interface SubGenericService<T> extends GenericService<T> {
-	}
-
-	static class BaseService<T> {
-
-		private T id;
-
-		public T getId() {
-			return id;
-		}
-
-		public void setId(T id) {
-			this.id = id;
-		}
-	}
-
-	static class ServiceWithOverriddenGetterAndSetter extends BaseService<String>
-			implements SubGenericService<String> {
-
-		@Override
-		public String getId() {
-			return super.getId();
-		}
-
-		@Override
-		public void setId(String id) {
-			super.setId(id);
-		}
-	}
-
-	static class ServiceWithOverloadedSetter extends BaseService<String>
-			implements SubGenericService<String> {
-
-		public void setId(int id) {
-			setId(String.valueOf(id));
-		}
-	}
-
-	static class ServiceWithOverriddenGetter extends BaseService<String>
-			implements SubGenericService<String> {
-
-		@Override
-		public String getId() {
-			return super.getId();
-		}
-	}
-
-	static class ServiceWithOverriddenGetterAndOverloadedSetter extends BaseService<String>
-			implements SubGenericService<String> {
-
-		@Override
-		public String getId() {
-			return super.getId();
-		}
-
-		public void setId(int id) {
-			setId(String.valueOf(id));
-		}
-	}
-
-}
@@ -87,7 +87,6 @@ import org.springframework.core.io.Resource;
 import org.springframework.core.io.UrlResource;
 import org.springframework.core.testfixture.io.SerializationTestUtils;
 import org.springframework.lang.Nullable;
-import org.springframework.util.StringUtils;
 import org.springframework.util.StringValueResolver;

 import static org.assertj.core.api.Assertions.assertThat;
@@ -1799,7 +1798,7 @@ class DefaultListableBeanFactoryTests {

 		assertThatExceptionOfType(NoUniqueBeanDefinitionException.class)
 				.isThrownBy(() -> lbf.getBean(TestBean.class))
-				.withMessageEndingWith("more than one 'primary' bean found among candidates: [bd1, bd2]");
+				.withMessageContaining("more than one 'primary'");
 	}

 	@Test
@@ -2123,7 +2122,7 @@ class DefaultListableBeanFactoryTests {

 		assertThatExceptionOfType(NoUniqueBeanDefinitionException.class)
 				.isThrownBy(() -> lbf.getBean(ConstructorDependency.class, 42))
-				.withMessageEndingWith("more than one 'primary' bean found among candidates: [bd1, bd2]");
+				.withMessageContaining("more than one 'primary'");
 	}

 	@Test
@@ -3203,33 +3202,6 @@ class DefaultListableBeanFactoryTests {
 		assertThat(holder.getNonPublicEnum()).isEqualTo(NonPublicEnum.VALUE_1);
 	}

-	@Test
-	void mostSpecificCacheEntryForTypeMatching() {
-		RootBeanDefinition bd1 = new RootBeanDefinition();
-		bd1.setFactoryBeanName("config");
-		bd1.setFactoryMethodName("create");
-		lbf.registerBeanDefinition("config", new RootBeanDefinition(BeanWithFactoryMethod.class));
-		lbf.registerBeanDefinition("bd1", bd1);
-		lbf.registerBeanDefinition("bd2", new RootBeanDefinition(NestedTestBean.class));
-		lbf.freezeConfiguration();
-
-		String[] allBeanNames = lbf.getBeanNamesForType(Object.class);
-		String[] nestedBeanNames = lbf.getBeanNamesForType(NestedTestBean.class);
-		assertThat(lbf.getType("bd1")).isEqualTo(TestBean.class);
-		assertThat(lbf.getBeanNamesForType(TestBean.class)).containsExactly("bd1");
-		assertThat(lbf.getBeanNamesForType(DerivedTestBean.class)).isEmpty();
-		lbf.getBean("bd1");
-		assertThat(lbf.getType("bd1")).isEqualTo(DerivedTestBean.class);
-		assertThat(lbf.getBeanNamesForType(TestBean.class)).containsExactly("bd1");
-		assertThat(lbf.getBeanNamesForType(DerivedTestBean.class)).containsExactly("bd1");
-		assertThat(lbf.getBeanNamesForType(NestedTestBean.class)).isSameAs(nestedBeanNames);
-		assertThat(lbf.getBeanNamesForType(Object.class)).isSameAs(allBeanNames);
-
-		lbf.registerSingleton("bd3", new Object());
-		assertThat(lbf.getBeanNamesForType(NestedTestBean.class)).isSameAs(nestedBeanNames);
-		assertThat(lbf.getBeanNamesForType(Object.class)).containsExactly(StringUtils.addStringToArray(allBeanNames, "bd3"));
-	}
-

 	private int registerBeanDefinitions(Properties p) {
 		return registerBeanDefinitions(p, null);
@@ -3446,7 +3418,7 @@ class DefaultListableBeanFactoryTests {
 		}

 		public TestBean create() {
-			DerivedTestBean tb = new DerivedTestBean();
+			TestBean tb = new TestBean();
 			tb.setName(this.name);
 			return tb;
 		}
@@ -3674,11 +3646,11 @@ class DefaultListableBeanFactoryTests {

 		private FactoryBean<?> factoryBean;

-		public FactoryBean<?> getFactoryBean() {
+		public final FactoryBean<?> getFactoryBean() {
 			return this.factoryBean;
 		}

-		public void setFactoryBean(FactoryBean<?> factoryBean) {
+		public final void setFactoryBean(final FactoryBean<?> factoryBean) {
 			this.factoryBean = factoryBean;
 		}
 	}
@@ -1275,6 +1275,88 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBean().get("testBean2")).isNull();
 	}

+	@Test
+	void fieldInjectionWithMap() {
+		RootBeanDefinition bd = new RootBeanDefinition(MapFieldInjectionBean.class);
+		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
+		bf.registerBeanDefinition("annotatedBean", bd);
+		TestBean tb1 = new TestBean("tb1");
+		TestBean tb2 = new TestBean("tb2");
+		bf.registerSingleton("testBean1", tb1);
+		bf.registerSingleton("testBean2", tb2);
+		bf.registerAlias("testBean1", "testBean");
+
+		MapFieldInjectionBean bean = bf.getBean("annotatedBean", MapFieldInjectionBean.class);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
+		assertThat(bean.getTestBeanMap()).containsKey("testBean1");
+		assertThat(bean.getTestBeanMap()).containsKey("testBean2");
+		assertThat(bean.getTestBeanMap()).containsValue(tb1);
+		assertThat(bean.getTestBeanMap()).containsValue(tb2);
+
+		bean = bf.getBean("annotatedBean", MapFieldInjectionBean.class);
+		assertThat(bean.getTestBeanMap()).hasSize(2);
+		assertThat(bean.getTestBeanMap()).containsKey("testBean1");
+		assertThat(bean.getTestBeanMap()).containsKey("testBean2");
+		assertThat(bean.getTestBeanMap()).containsValue(tb1);
+		assertThat(bean.getTestBeanMap()).containsValue(tb2);
+	}
+
+	@Test
+	void methodInjectionWithMap() {
+		RootBeanDefinition bd = new RootBeanDefinition(MapMethodInjectionBean.class);
+		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
+		bf.registerBeanDefinition("annotatedBean", bd);
+		TestBean tb = new TestBean();
+		bf.registerSingleton("testBean", tb);
+
+		MapMethodInjectionBean bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
+		assertThat(bean.getTestBeanMap()).containsKey("testBean");
+		assertThat(bean.getTestBeanMap()).containsValue(tb);
+		assertThat(bean.getTestBean()).isSameAs(tb);
+
+		bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
+		assertThat(bean.getTestBeanMap()).containsKey("testBean");
+		assertThat(bean.getTestBeanMap()).containsValue(tb);
+		assertThat(bean.getTestBean()).isSameAs(tb);
+	}
+
+	@Test
+	void methodInjectionWithMapAndMultipleMatches() {
+		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(MapMethodInjectionBean.class));
+		bf.registerBeanDefinition("testBean1", new RootBeanDefinition(TestBean.class));
+		bf.registerBeanDefinition("testBean2", new RootBeanDefinition(TestBean.class));
+		assertThatExceptionOfType(UnsatisfiedDependencyException.class).as("should have failed, more than one bean of type")
+				.isThrownBy(() -> bf.getBean("annotatedBean"))
+				.satisfies(methodParameterDeclaredOn(MapMethodInjectionBean.class));
+	}
+
+	@Test
+	void methodInjectionWithMapAndMultipleMatchesButOnlyOneAutowireCandidate() {
+		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(MapMethodInjectionBean.class));
+		bf.registerBeanDefinition("testBean1", new RootBeanDefinition(TestBean.class));
+		RootBeanDefinition rbd2 = new RootBeanDefinition(TestBean.class);
+		rbd2.setAutowireCandidate(false);
+		bf.registerBeanDefinition("testBean2", rbd2);
+
+		MapMethodInjectionBean bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
+		TestBean tb = bf.getBean("testBean1", TestBean.class);
+		assertThat(bean.getTestBeanMap()).hasSize(1);
+		assertThat(bean.getTestBeanMap()).containsKey("testBean1");
+		assertThat(bean.getTestBeanMap()).containsValue(tb);
+		assertThat(bean.getTestBean()).isSameAs(tb);
+	}
+
+	@Test
+	void methodInjectionWithMapAndNoMatches() {
+		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(MapMethodInjectionBean.class));
+
+		MapMethodInjectionBean bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
+		assertThat(bean.getTestBeanMap()).isNull();
+		assertThat(bean.getTestBean()).isNull();
+	}
+
 	@Test
 	void constructorInjectionWithTypedMapAsBean() {
 		RootBeanDefinition bd = new RootBeanDefinition(MapConstructorInjectionBean.class);
@@ -1327,19 +1409,6 @@ class AutowiredAnnotationBeanPostProcessorTests {

 	@Test
 	void constructorInjectionWithPlainHashMapAsBean() {
-		RootBeanDefinition bd = new RootBeanDefinition(NamedMapConstructorInjectionBean.class);
-		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
-		bf.registerBeanDefinition("annotatedBean", bd);
-		bf.registerBeanDefinition("testBeanMap", new RootBeanDefinition(HashMap.class));
-
-		NamedMapConstructorInjectionBean bean = bf.getBean("annotatedBean", NamedMapConstructorInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).isSameAs(bf.getBean("testBeanMap"));
-		bean = bf.getBean("annotatedBean", NamedMapConstructorInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).isSameAs(bf.getBean("testBeanMap"));
-	}
-
-	@Test
-	void constructorInjectionWithQualifiedPlainHashMapAsBean() {
 		RootBeanDefinition bd = new RootBeanDefinition(QualifiedMapConstructorInjectionBean.class);
 		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
 		bf.registerBeanDefinition("annotatedBean", bd);
@@ -1428,114 +1497,6 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		assertThat(bean.getTestBeanSet()).contains(tb1, tb2);
 	}

-	@Test
-	void fieldInjectionWithMap() {
-		RootBeanDefinition bd = new RootBeanDefinition(MapFieldInjectionBean.class);
-		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
-		bf.registerBeanDefinition("annotatedBean", bd);
-		TestBean tb1 = new TestBean("tb1");
-		TestBean tb2 = new TestBean("tb2");
-		bf.registerSingleton("testBean1", tb1);
-		bf.registerSingleton("testBean2", tb2);
-		bf.registerAlias("testBean1", "testBean");
-
-		MapFieldInjectionBean bean = bf.getBean("annotatedBean", MapFieldInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).hasSize(2);
-		assertThat(bean.getTestBeanMap()).containsKey("testBean1");
-		assertThat(bean.getTestBeanMap()).containsKey("testBean2");
-		assertThat(bean.getTestBeanMap()).containsValue(tb1);
-		assertThat(bean.getTestBeanMap()).containsValue(tb2);
-
-		bean = bf.getBean("annotatedBean", MapFieldInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).hasSize(2);
-		assertThat(bean.getTestBeanMap()).containsKey("testBean1");
-		assertThat(bean.getTestBeanMap()).containsKey("testBean2");
-		assertThat(bean.getTestBeanMap()).containsValue(tb1);
-		assertThat(bean.getTestBeanMap()).containsValue(tb2);
-	}
-
-	@Test
-	void methodInjectionWithMap() {
-		RootBeanDefinition bd = new RootBeanDefinition(MapMethodInjectionBean.class);
-		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
-		bf.registerBeanDefinition("annotatedBean", bd);
-		TestBean tb = new TestBean();
-		bf.registerSingleton("testBean", tb);
-
-		MapMethodInjectionBean bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).hasSize(1);
-		assertThat(bean.getTestBeanMap()).containsKey("testBean");
-		assertThat(bean.getTestBeanMap()).containsValue(tb);
-		assertThat(bean.getTestBean()).isSameAs(tb);
-
-		bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).hasSize(1);
-		assertThat(bean.getTestBeanMap()).containsKey("testBean");
-		assertThat(bean.getTestBeanMap()).containsValue(tb);
-		assertThat(bean.getTestBean()).isSameAs(tb);
-	}
-
-	@Test
-	void methodInjectionWithMapAndMultipleMatches() {
-		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(MapMethodInjectionBean.class));
-		bf.registerBeanDefinition("testBean1", new RootBeanDefinition(TestBean.class));
-		bf.registerBeanDefinition("testBean2", new RootBeanDefinition(TestBean.class));
-		assertThatExceptionOfType(UnsatisfiedDependencyException.class).as("should have failed, more than one bean of type")
-				.isThrownBy(() -> bf.getBean("annotatedBean"))
-				.satisfies(methodParameterDeclaredOn(MapMethodInjectionBean.class));
-	}
-
-	@Test
-	void methodInjectionWithMapAndMultipleMatchesButOnlyOneAutowireCandidate() {
-		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(MapMethodInjectionBean.class));
-		bf.registerBeanDefinition("testBean1", new RootBeanDefinition(TestBean.class));
-		RootBeanDefinition rbd2 = new RootBeanDefinition(TestBean.class);
-		rbd2.setAutowireCandidate(false);
-		bf.registerBeanDefinition("testBean2", rbd2);
-
-		MapMethodInjectionBean bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
-		TestBean tb = bf.getBean("testBean1", TestBean.class);
-		assertThat(bean.getTestBeanMap()).hasSize(1);
-		assertThat(bean.getTestBeanMap()).containsKey("testBean1");
-		assertThat(bean.getTestBeanMap()).containsValue(tb);
-		assertThat(bean.getTestBean()).isSameAs(tb);
-	}
-
-	@Test
-	void methodInjectionWithMapAndNoMatches() {
-		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(MapMethodInjectionBean.class));
-
-		MapMethodInjectionBean bean = bf.getBean("annotatedBean", MapMethodInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).isNull();
-		assertThat(bean.getTestBean()).isNull();
-	}
-
-	@Test
-	void methodInjectionWithPlainHashMapAsBean() {
-		RootBeanDefinition bd = new RootBeanDefinition(NamedMapMethodInjectionBean.class);
-		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
-		bf.registerBeanDefinition("annotatedBean", bd);
-		bf.registerBeanDefinition("testBeanMap", new RootBeanDefinition(HashMap.class));
-
-		NamedMapMethodInjectionBean bean = bf.getBean("annotatedBean", NamedMapMethodInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).isSameAs(bf.getBean("testBeanMap"));
-		bean = bf.getBean("annotatedBean", NamedMapMethodInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).isSameAs(bf.getBean("testBeanMap"));
-	}
-
-	@Test
-	void methodInjectionWithQualifiedPlainHashMapAsBean() {
-		RootBeanDefinition bd = new RootBeanDefinition(QualifiedMapMethodInjectionBean.class);
-		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
-		bf.registerBeanDefinition("annotatedBean", bd);
-		bf.registerBeanDefinition("myTestBeanMap", new RootBeanDefinition(HashMap.class));
-
-		QualifiedMapMethodInjectionBean bean = bf.getBean("annotatedBean", QualifiedMapMethodInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).isSameAs(bf.getBean("myTestBeanMap"));
-		bean = bf.getBean("annotatedBean", QualifiedMapMethodInjectionBean.class);
-		assertThat(bean.getTestBeanMap()).isSameAs(bf.getBean("myTestBeanMap"));
-	}
-
 	@Test
 	void selfReference() {
 		bf.registerBeanDefinition("annotatedBean", new RootBeanDefinition(SelfInjectionBean.class));
@@ -2112,8 +2073,8 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		bf.registerBeanDefinition("factoryBeanDependentBean", new RootBeanDefinition(FactoryBeanDependentBean.class));
 		bf.registerSingleton("stringFactoryBean", new StringFactoryBean());

-		StringFactoryBean factoryBean = (StringFactoryBean) bf.getBean("&stringFactoryBean");
-		FactoryBeanDependentBean bean = (FactoryBeanDependentBean) bf.getBean("factoryBeanDependentBean");
+		final StringFactoryBean factoryBean = (StringFactoryBean) bf.getBean("&stringFactoryBean");
+		final FactoryBeanDependentBean bean = (FactoryBeanDependentBean) bf.getBean("factoryBeanDependentBean");

 		assertThat(factoryBean).as("The singleton StringFactoryBean should have been registered.").isNotNull();
 		assertThat(bean).as("The factoryBeanDependentBean should have been registered.").isNotNull();
@@ -2724,7 +2685,6 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		bf.registerSingleton("nonNullBean", "Test");
 		bf.registerBeanDefinition("mixedNullableInjectionBean",
 				new RootBeanDefinition(MixedNullableInjectionBean.class));
-
 		MixedNullableInjectionBean mixedNullableInjectionBean = bf.getBean(MixedNullableInjectionBean.class);
 		assertThat(mixedNullableInjectionBean.nonNullBean).isNotNull();
 		assertThat(mixedNullableInjectionBean.nullableBean).isNull();
@@ -2735,7 +2695,6 @@ class AutowiredAnnotationBeanPostProcessorTests {
 		bf.registerSingleton("nonNullBean", "Test");
 		bf.registerBeanDefinition("mixedOptionalInjectionBean",
 				new RootBeanDefinition(MixedOptionalInjectionBean.class));
-
 		MixedOptionalInjectionBean mixedOptionalInjectionBean = bf.getBean(MixedOptionalInjectionBean.class);
 		assertThat(mixedOptionalInjectionBean.nonNullBean).isNotNull();
 		assertThat(mixedOptionalInjectionBean.nullableBean).isNull();
@@ -3299,21 +3258,6 @@ class AutowiredAnnotationBeanPostProcessorTests {
 	}


-	public static class NamedMapConstructorInjectionBean {
-
-		private Map<String, TestBean> testBeanMap;
-
-		@Autowired
-		public NamedMapConstructorInjectionBean(Map<String, TestBean> testBeanMap) {
-			this.testBeanMap = testBeanMap;
-		}
-
-		public Map<String, TestBean> getTestBeanMap() {
-			return this.testBeanMap;
-		}
-	}
-
-
 	public static class QualifiedMapConstructorInjectionBean {

 		private Map<String, TestBean> testBeanMap;
@@ -3413,37 +3357,6 @@ class AutowiredAnnotationBeanPostProcessorTests {
 	}


-	public static class NamedMapMethodInjectionBean {
-
-		private Map<String, TestBean> testBeanMap;
-
-		@Autowired
-		public void setTestBeanMap(Map<String, TestBean> testBeanMap) {
-			this.testBeanMap = testBeanMap;
-		}
-
-		public Map<String, TestBean> getTestBeanMap() {
-			return this.testBeanMap;
-		}
-	}
-
-
-	public static class QualifiedMapMethodInjectionBean {
-
-		private Map<String, TestBean> testBeanMap;
-
-		@Autowired
-		@Qualifier("myTestBeanMap")
-		public void setTestBeanMap(Map<String, TestBean> testBeanMap) {
-			this.testBeanMap = testBeanMap;
-		}
-
-		public Map<String, TestBean> getTestBeanMap() {
-			return this.testBeanMap;
-		}
-	}
-
-
 	@SuppressWarnings("serial")
 	public static class ObjectFactoryFieldInjectionBean implements Serializable {

@@ -444,8 +444,8 @@ class InjectAnnotationBeanPostProcessorTests {
 		bf.registerBeanDefinition("factoryBeanDependentBean", new RootBeanDefinition(FactoryBeanDependentBean.class));
 		bf.registerSingleton("stringFactoryBean", new StringFactoryBean());

-		StringFactoryBean factoryBean = (StringFactoryBean) bf.getBean("&stringFactoryBean");
-		FactoryBeanDependentBean bean = (FactoryBeanDependentBean) bf.getBean("factoryBeanDependentBean");
+		final StringFactoryBean factoryBean = (StringFactoryBean) bf.getBean("&stringFactoryBean");
+		final FactoryBeanDependentBean bean = (FactoryBeanDependentBean) bf.getBean("factoryBeanDependentBean");

 		assertThat(factoryBean).as("The singleton StringFactoryBean should have been registered.").isNotNull();
 		assertThat(bean).as("The factoryBeanDependentBean should have been registered.").isNotNull();
@@ -788,6 +788,7 @@ class InjectAnnotationBeanPostProcessorTests {

 		private ConfigurableListableBeanFactory beanFactory;

+
 		public ConstructorResourceInjectionBean() {
 			throw new UnsupportedOperationException();
 		}
--- a/Show More
+++ b/Show More