Release v6.2.0-RC3

2026-06-08 17:33:33 +00:00 · 2024-10-24 11:03:16 +02:00
625 changed files with 4584 additions and 15790 deletions
@@ -31,11 +31,10 @@ runs:
          ${{ inputs.java-early-access == 'true' && format('{0}-ea', inputs.java-version) || inputs.java-version }}
          ${{ inputs.java-toolchain == 'true' && '17' || '' }}
    - name: Set Up Gradle
-      uses: gradle/actions/setup-gradle@cc4fc85e6b35bafd578d5ffbc76a5518407e1af0 # v4.2.1
+      uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
      with:
        cache-read-only: false
        develocity-access-key: ${{ inputs.develocity-access-key }}
-        develocity-token-expiry: 4
    - name: Configure Gradle Properties
      shell: bash
      run: |
@@ -20,7 +20,7 @@ runs:
  using: composite
  steps:
    - name: Set Up JFrog CLI
-      uses: jfrog/setup-jfrog-cli@dff217c085c17666e8849ebdbf29c8fe5e3995e6 # v4.5.2
+      uses: jfrog/setup-jfrog-cli@9fe0f98bd45b19e6e931d457f4e98f8f84461fb5 # v4.4.1
      env:
        JF_ENV_SPRING: ${{ inputs.jfrog-cli-config-token }}
    - name: Download Release Artifacts
@@ -2,7 +2,7 @@ name: Build and Deploy Snapshot
 on:
  push:
    branches:
-      - 6.2.x
+      - main
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
@@ -21,7 +21,7 @@ jobs:
          develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
          publish: true
      - name: Deploy
-        uses: spring-io/artifactory-deploy-action@dc1913008c0599f0c4b1fdafb6ff3c502b3565ea # v0.0.2
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
        with:
          artifact-properties: |
            /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
@@ -9,11 +9,22 @@ jobs:
    runs-on: ubuntu-latest
    timeout-minutes: 60
    steps:
-      - name: Check Out Code
+      - name: Set Up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'liberica'
+          java-version: '17'
+      - name: Check Out
        uses: actions/checkout@v4
+      - name: Validate Gradle Wrapper
+        uses: gradle/actions/wrapper-validation@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
+      - name: Set Up Gradle
+        uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
      - name: Build
-        id: build
-        uses: ./.github/actions/build
+        env:
+          CI: 'true'
+          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
+        run: ./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --no-parallel --continue build
      - name: Print JVM Thread Dumps When Cancelled
        if: cancelled()
        uses: ./.github/actions/print-jvm-thread-dumps
@@ -1,8 +1,7 @@
 name: CI
 on:
-  push:
-    branches:
-      - 6.2.x
+  schedule:
+    - cron: '30 9 * * *'
 concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
 jobs:
@@ -21,6 +20,8 @@ jobs:
            toolchain: false
          - version: 21
            toolchain: true
+          - version: 22
+            toolchain: true
          - version: 23
            toolchain: true
        exclude:
@@ -0,0 +1,79 @@
+name: Release Milestone
+on:
+  push:
+    tags:
+      - v6.2.0-M[1-9]
+      - v6.2.0-RC[1-9]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build-and-stage-release:
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    name: Build and Stage Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Build and Publish
+        id: build-and-publish
+        uses: ./.github/actions/build
+        with:
+          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+          publish: true
+      - name: Stage Release
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
+        with:
+          artifact-properties: |
+            /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
+            /**/framework-api-*-docs.zip::zip.type=docs
+            /**/framework-api-*-schema.zip::zip.type=schema
+          build-name: ${{ format('spring-framework-{0}', steps.build-and-publish.outputs.version)}}
+          folder: 'deployment-repository'
+          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          repository: 'libs-staging-local'
+          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
+          uri: 'https://repo.spring.io'
+          username: ${{ secrets.ARTIFACTORY_USERNAME }}
+    outputs:
+      version: ${{ steps.build-and-publish.outputs.version }}
+  verify:
+    name: Verify
+    needs: build-and-stage-release
+    uses: ./.github/workflows/verify.yml
+    with:
+      staging: true
+      version: ${{ needs.build-and-stage-release.outputs.version }}
+    secrets:
+      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
+      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+  promote-release:
+    name: Promote Release
+    needs:
+      - build-and-stage-release
+      - verify
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up JFrog CLI
+        uses: jfrog/setup-jfrog-cli@9fe0f98bd45b19e6e931d457f4e98f8f84461fb5 # v4.4.1
+        env:
+          JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
+      - name: Promote build
+        run: jfrog rt build-promote ${{ format('spring-framework-{0}', needs.build-and-stage-release.outputs.version)}} ${{ github.run_number }} libs-milestone-local
+  create-github-release:
+    name: Create GitHub Release
+    needs:
+      - build-and-stage-release
+      - promote-release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - name: Create GitHub Release
+        uses: ./.github/actions/create-github-release
+        with:
+          milestone: ${{ needs.build-and-stage-release.outputs.version }}
+          pre-release: true
+          token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
@@ -73,7 +73,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Set up JFrog CLI
-        uses: jfrog/setup-jfrog-cli@dff217c085c17666e8849ebdbf29c8fe5e3995e6 # v4.5.2
+        uses: jfrog/setup-jfrog-cli@9fe0f98bd45b19e6e931d457f4e98f8f84461fb5 # v4.4.1
        env:
          JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
      - name: Promote build
@@ -12,9 +12,8 @@ permissions:

 jobs:
  update-antora-ui-spring:
-    name: Update on Supported Branches
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
    runs-on: ubuntu-latest
+    name: Update on Supported Branches
    strategy:
      matrix:
        branch: [ '6.1.x' ]
@@ -26,9 +25,8 @@ jobs:
          token: ${{ secrets.GITHUB_TOKEN }}
          antora-file-path: 'framework-docs/antora-playbook.yml'
  update-antora-ui-spring-docs-build:
-    name: Update on docs-build
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
    runs-on: ubuntu-latest
+    name: Update on docs-build
    steps:
      - uses: spring-io/spring-doc-actions/update-antora-spring-ui@5a57bcc6a0da2a1474136cf29571b277850432bc
        name: Update
@@ -46,7 +46,7 @@ jobs:
          distribution: 'liberica'
          java-version: 17
      - name: Set Up Gradle
-        uses: gradle/actions/setup-gradle@cc4fc85e6b35bafd578d5ffbc76a5518407e1af0 # v4.2.1
+        uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
        with:
          cache-read-only: false
      - name: Configure Gradle Properties
@@ -1,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=17.0.13-librca
+java=17.0.12-librca
@@ -16,7 +16,7 @@ First off, thank you for taking the time to contribute! :+1: :tada:

 ### Code of Conduct

-This project is governed by the [Spring Code of Conduct](https://github.com/spring-projects/spring-framework#coc-ov-file).
+This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc).
 By participating you are expected to uphold this code.
 Please report unacceptable behavior to spring-code-of-conduct@spring.io.

@@ -65,6 +65,10 @@ follow-up reports will need to be created as new issues with a fresh description

 #### Submit a Pull Request

+1. If you have not previously done so, please sign the
+[Contributor License Agreement](https://cla.spring.io/sign/spring). You will be reminded
+automatically when you submit the PR.
+
 1. Should you create an issue first? No, just create the pull request and use the
 description to provide context and motivation, as you would for an issue. If you want
 to start a discussion first or have already created an issue, once a pull request is
@@ -81,11 +85,6 @@ multiple edits or corrections of the same logical change. See
 [Rewriting History section of Pro Git](https://git-scm.com/book/en/Git-Tools-Rewriting-History)
 for an overview of streamlining the commit history.

-1. All commits must include a _Signed-off-by_ trailer at the end of each commit message
-to indicate that the contributor agrees to the Developer Certificate of Origin.
-For additional details, please refer to the blog post
-[Hello DCO, Goodbye CLA: Simplifying Contributions to Spring](https://spring.io/blog/2025/01/06/hello-dco-goodbye-cla-simplifying-contributions-to-spring).
-
 1. Format commit messages using 55 characters for the subject line, 72 characters per line
 for the description, followed by the issue fixed, for example, `Closes gh-22276`. See the
 [Commit Guidelines section of Pro Git](https://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines)
@@ -25,17 +25,17 @@ configure(allprojects) { project ->
 	repositories {
 		mavenCentral()
 		maven {
-			url = "https://repo.spring.io/milestone"
+			url "https://repo.spring.io/milestone"
 			content {
 				// Netty 5 optional support
 				includeGroup 'io.projectreactor.netty'
 			}
 		}
 		if (version.contains('-')) {
-			maven { url = "https://repo.spring.io/milestone" }
+			maven { url "https://repo.spring.io/milestone" }
 		}
 		if (version.endsWith('-SNAPSHOT')) {
-			maven { url = "https://repo.spring.io/snapshot" }
+			maven { url "https://repo.spring.io/snapshot" }
 		}
 	}
 	configurations.all {
@@ -102,7 +102,7 @@ configure([rootProject] + javaProjects) { project ->
 			// 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.11.4/api/",
+			// "https://junit.org/junit5/docs/5.11.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/",
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -50,7 +50,7 @@ public class CheckstyleConventions {
 			project.getPlugins().apply(CheckstylePlugin.class);
 			project.getTasks().withType(Checkstyle.class).forEach(checkstyle -> checkstyle.getMaxHeapSize().set("1g"));
 			CheckstyleExtension checkstyle = project.getExtensions().getByType(CheckstyleExtension.class);
-			checkstyle.setToolVersion("10.21.1");
+			checkstyle.setToolVersion("10.18.1");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
@@ -9,7 +9,7 @@ apply from: "${rootDir}/gradle/publications.gradle"

 repositories {
 	maven {
-		url = "https://repo.spring.io/release"
+		url "https://repo.spring.io/release"
 	}
 }

@@ -87,7 +87,7 @@ tasks.register('schemaZip', Zip) {
 	archiveClassifier.set("schema")
 	description = "Builds -${archiveClassifier} archive containing all " +
 			"XSDs for deployment at https://springframework.org/schema."
-	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+	duplicatesStrategy DuplicatesStrategy.EXCLUDE
 	moduleProjects.each { module ->
 		def Properties schemas = new Properties();

@@ -36,4 +36,4 @@ runtime:
    failure_level: warn
 ui:
  bundle:
-    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.18/ui-bundle.zip
+    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.17/ui-bundle.zip
@@ -37,7 +37,7 @@ javadoc {

 repositories {
 	maven {
-		url = "https://repo.spring.io/release"
+		url "https://repo.spring.io/release"
 	}
 }

@@ -60,7 +60,6 @@
 **** xref:core/expressions/language-ref/constructors.adoc[]
 **** xref:core/expressions/language-ref/variables.adoc[]
 **** xref:core/expressions/language-ref/functions.adoc[]
-**** xref:core/expressions/language-ref/varargs.adoc[]
 **** xref:core/expressions/language-ref/bean-references.adoc[]
 **** xref:core/expressions/language-ref/operator-ternary.adoc[]
 **** xref:core/expressions/language-ref/operator-elvis.adoc[]
@@ -23,12 +23,6 @@ The following table lists all currently supported Spring properties.
 |===
 | Name | Description

-| `spring.aop.ajc.ignore`
-| Instructs Spring to ignore ajc-compiled aspects for Spring AOP proxying, restoring traditional
-Spring behavior for scenarios where both weaving and AspectJ auto-proxying are enabled. See
-{spring-framework-api}++/aop/aspectj/annotation/AbstractAspectJAdvisorFactory.html#IGNORE_AJC_PROPERTY_NAME++[`AbstractAspectJAdvisorFactory`]
-for details.
-
 | `spring.aot.enabled`
 | Indicates the application should run with AOT generated artifacts. See
 xref:core/aot.adoc[Ahead of Time Optimizations] and 
@@ -38,7 +32,7 @@ for details.
 | `spring.beaninfo.ignore`
 | Instructs Spring to use the `Introspector.IGNORE_ALL_BEANINFO` mode when calling the
 JavaBeans `Introspector`. See
-{spring-framework-api}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`StandardBeanInfoFactory`]
+{spring-framework-api}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
 for details.

 | `spring.cache.reactivestreams.ignore`
@@ -55,13 +49,15 @@ for details.

 | `spring.context.checkpoint`
 | Property that specifies a common context checkpoint. See
-xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic checkpoint/restore at startup] and
+xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic
+checkpoint/restore at startup] and
 {spring-framework-api}++/context/support/DefaultLifecycleProcessor.html#CHECKPOINT_PROPERTY_NAME++[`DefaultLifecycleProcessor`]
 for details.

 | `spring.context.exit`
 | Property for terminating the JVM when the context reaches a specific phase. See
-xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic checkpoint/restore at startup] and
+xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic
+checkpoint/restore at startup] and
 {spring-framework-api}++/context/support/DefaultLifecycleProcessor.html#EXIT_PROPERTY_NAME++[`DefaultLifecycleProcessor`]
 for details.

@@ -33,11 +33,11 @@ arbitrary advice types. This section describes the basic concepts and standard a
 [[aop-api-advice-around]]
 === Interception Around Advice

-The most fundamental advice type in Spring is _interception around advice_.
+The most fundamental advice type in Spring is interception around advice.

-Spring is compliant with the AOP Alliance interface for around advice that uses method
-interception. Classes that implement around advice should therefore implement the
-following `MethodInterceptor` interface from the `org.aopalliance.intercept` package:
+Spring is compliant with the AOP `Alliance` interface for around advice that uses method
+interception. Classes that implement `MethodInterceptor` and that implement around advice should also implement the
+following interface:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -49,8 +49,8 @@ following `MethodInterceptor` interface from the `org.aopalliance.intercept` pac

 The `MethodInvocation` argument to the `invoke()` method exposes the method being
 invoked, the target join point, the AOP proxy, and the arguments to the method. The
-`invoke()` method should return the invocation's result: typically the return value of
-the join point.
+`invoke()` method should return the invocation's result: the return value of the join
+point.

 The following example shows a simple `MethodInterceptor` implementation:

@@ -64,9 +64,9 @@ Java::

 		public Object invoke(MethodInvocation invocation) throws Throwable {
 			System.out.println("Before: invocation=[" + invocation + "]");
-			Object result = invocation.proceed();
+			Object rval = invocation.proceed();
 			System.out.println("Invocation returned");
-			return result;
+			return rval;
 		}
 	}
 ----
@@ -79,9 +79,9 @@ Kotlin::

 		override fun invoke(invocation: MethodInvocation): Any {
 			println("Before: invocation=[$invocation]")
-			val result = invocation.proceed()
+			val rval = invocation.proceed()
 			println("Invocation returned")
-			return result
+			return rval
 		}
 	}
 ----
@@ -105,7 +105,7 @@ currently define pointcut interfaces.
 [[aop-api-advice-before]]
 === Before Advice

-A simpler advice type is a _before advice_. This does not need a `MethodInvocation`
+A simpler advice type is a before advice. This does not need a `MethodInvocation`
 object, since it is called only before entering the method.

 The main advantage of a before advice is that there is no need to invoke the `proceed()`
@@ -122,6 +122,10 @@ The following listing shows the `MethodBeforeAdvice` interface:
 	}
 ----

+(Spring's API design would allow for
+field before advice, although the usual objects apply to field interception and it is
+unlikely for Spring to ever implement it.)
+
 Note that the return type is `void`. Before advice can insert custom behavior before the join
 point runs but cannot change the return value. If a before advice throws an
 exception, it stops further execution of the interceptor chain. The exception
@@ -172,10 +176,10 @@ TIP: Before advice can be used with any pointcut.
 [[aop-api-advice-throws]]
 === Throws Advice

-_Throws advice_ is invoked after the return of the join point if the join point threw
+Throws advice is invoked after the return of the join point if the join point threw
 an exception. Spring offers typed throws advice. Note that this means that the
 `org.springframework.aop.ThrowsAdvice` interface does not contain any methods. It is a
-marker interface identifying that the given object implements one or more typed throws
+tag interface identifying that the given object implements one or more typed throws
 advice methods. These should be in the following form:

 [source,java,indent=0,subs="verbatim,quotes"]
@@ -185,10 +189,9 @@ advice methods. These should be in the following form:

 Only the last argument is required. The method signatures may have either one or four
 arguments, depending on whether the advice method is interested in the method and
-arguments. The next two listings show classes that are examples of throws advice.
+arguments. The next two listing show classes that are examples of throws advice.

-The following advice is invoked if a `RemoteException` is thrown (including subclasses of
-`RemoteException`):
+The following advice is invoked if a `RemoteException` is thrown (including from subclasses):

 [tabs]
 ======
@@ -217,9 +220,9 @@ Kotlin::
 ----
 ======

-Unlike the preceding advice, the next example declares four arguments, so that it has
-access to the invoked method, method arguments, and target object. The following advice
-is invoked if a `ServletException` is thrown:
+Unlike the preceding
+advice, the next example declares four arguments, so that it has access to the invoked method, method
+arguments, and target object. The following advice is invoked if a `ServletException` is thrown:

 [tabs]
 ======
@@ -301,7 +304,7 @@ TIP: Throws advice can be used with any pointcut.
 [[aop-api-advice-after-returning]]
 === After Returning Advice

-An _after returning advice_ in Spring must implement the
+An after returning advice in Spring must implement the
 `org.springframework.aop.AfterReturningAdvice` interface, which the following listing shows:

 [source,java,indent=0,subs="verbatim,quotes"]
@@ -365,7 +368,7 @@ TIP: After returning advice can be used with any pointcut.
 [[aop-api-advice-introduction]]
 === Introduction Advice

-Spring treats _introduction advice_ as a special kind of interception advice.
+Spring treats introduction advice as a special kind of interception advice.

 Introduction requires an `IntroductionAdvisor` and an `IntroductionInterceptor` that
 implement the following interface:
@@ -36,7 +36,7 @@ NOTE: At the moment, AOT is focused on allowing Spring applications to be deploy
 We intend to support more JVM-based use cases in future generations.

 [[aot.basics]]
-== AOT Engine Overview
+== AOT engine overview

 The entry point of the AOT engine for processing an `ApplicationContext` is `ApplicationContextAotGenerator`. It takes care of the following steps, based on a `GenericApplicationContext` that represents the application to optimize and a {spring-framework-api}/aot/generate/GenerationContext.html[`GenerationContext`]:

@@ -225,7 +225,7 @@ When a `datasource` instance is required, a `BeanInstanceSupplier` is called.
 This supplier invokes the `dataSource()` method on the `dataSourceConfiguration` bean.

 [[aot.running]]
-== Running with AOT Optimizations
+== Running with AOT optimizations

 AOT is a mandatory step to transform a Spring application to a native executable, so it
 is automatically enabled when running in this mode. It is possible to use those optimizations
@@ -244,7 +244,7 @@ However, keep in mind that some optimizations are made at build time based on a
 This section lists the best practices that make sure your application is ready for AOT.

 [[aot.bestpractices.bean-registration]]
-=== Programmatic Bean Registration
+== Programmatic bean registration

 The AOT engine takes care of the `@Configuration` model and any callback that might be
 invoked as part of processing your configuration. If you need to register additional
@@ -266,7 +266,7 @@ notion of a classpath. For cases like this, it is crucial that the scanning happ
 build time.

 [[aot.bestpractices.bean-type]]
-=== Expose the Most Precise Bean Type
+=== Expose The Most Precise Bean Type

 While your application may interact with an interface that a bean implements, it is still very important to declare the most precise type.
 The AOT engine performs additional checks on the bean type, such as detecting the presence of `@Autowired` members or lifecycle callback methods.
@@ -352,21 +352,21 @@ However, this is not a best practice and flagging the preferred constructor with

 In case you are working on a code base that you cannot modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.

-[[aot.bestpractices.complex-data-structures]]
-=== Avoid Complex Data Structures for Constructor Parameters and Properties
+[[aot.bestpractices.comlext-data-structure]]
+=== Avoid Complex Data Structure for Constructor Parameters and Properties

 When crafting a `RootBeanDefinition` programmatically, you are not constrained in terms of types that you can use.
 For instance, you may have a custom `record` with several properties that your bean takes as a constructor argument.

 While this works fine with the regular runtime, AOT does not know how to generate the code of your custom data structure.
 A good rule of thumb is to keep in mind that bean definitions are an abstraction on top of several models.
-Rather than using such structures, decomposing to simple types or referring to a bean that is built as such is recommended.
+Rather than using such structure, decomposing to simple types or referring to a bean that is built as such is recommended.

 As a last resort, you can implement your own `org.springframework.aot.generate.ValueCodeGenerator$Delegate`.
 To use it, register its fully qualified name in `META-INF/spring/aot.factories` using the `Delegate` as the key.

 [[aot.bestpractices.custom-arguments]]
-=== Avoid Creating Beans with Custom Arguments
+=== Avoid Creating Bean with Custom Arguments

 Spring AOT detects what needs to be done to create a bean and translates that in generated code using an instance supplier.
 The container also supports creating a bean with {spring-framework-api}++/beans/factory/BeanFactory.html#getBean(java.lang.String,java.lang.Object...)++[custom arguments] that leads to several issues with AOT:
@@ -378,20 +378,6 @@ For instance, autowiring on fields and methods will be skipped as they are handl

 Rather than having prototype-scoped beans created with custom arguments, we recommend a manual factory pattern where a bean is responsible for the creation of the instance.

-[[aot.bestpractices.circular-dependencies]]
-=== Avoid Circular Dependencies
-
-Certain use cases can result in circular dependencies between one or more beans. With the
-regular runtime, it may be possible to wire those circular dependencies via `@Autowired`
-on setter methods or fields. However, an AOT-optimized context will fail to start with
-explicit circular dependencies.
-
-In an AOT-optimized application, you should therefore strive to avoid circular
-dependencies. If that is not possible, you can use `@Lazy` injection points or
-`ObjectProvider` to lazily access or retrieve the necessary collaborating beans. See
-xref:core/beans/classpath-scanning.adoc#beans-factorybeans-annotations-lazy-injection-points[this tip]
-for further information.
-
 [[aot.bestpractices.factory-bean]]
 === FactoryBean

@@ -480,15 +480,11 @@ factory method and other bean definition properties, such as a qualifier value t
 the `@Qualifier` annotation. Other method-level annotations that can be specified are
 `@Scope`, `@Lazy`, and custom qualifier annotations.

-[[beans-factorybeans-annotations-lazy-injection-points]]
-[TIP]
-====
-In addition to its role for component initialization, you can also place the `@Lazy`
+TIP: In addition to its role for component initialization, you can also place the `@Lazy`
 annotation on injection points marked with `@Autowired` or `@Inject`. In this context,
 it leads to the injection of a lazy-resolution proxy. However, such a proxy approach
 is rather limited. For sophisticated lazy interactions, in particular in combination
 with optional dependencies, we recommend `ObjectProvider<MyTargetBean>` instead.
-====

 Autowired fields and methods are supported, as previously discussed, with additional
 support for autowiring of `@Bean` methods. The following example shows how to do so:
@@ -578,8 +578,6 @@ Kotlin::
 ----
 ======

-NOTE: Do not define such beans to be lazy as the `ApplicationContext` will honour that and will not register the method to listen to events.
-
 The method signature once again declares the event type to which it listens,
 but, this time, with a flexible name and without implementing a specific listener interface.
 The event type can also be narrowed through generics as long as the actual event type
@@ -885,12 +883,11 @@ for example, for processing all events asynchronously and/or for handling listen
 == Convenient Access to Low-level Resources

 For optimal usage and understanding of application contexts, you should familiarize
-yourself with Spring's `Resource` abstraction, as described in
-xref:core/resources.adoc[Resources].
+yourself with Spring's `Resource` abstraction, as described in xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources].

 An application context is a `ResourceLoader`, which can be used to load `Resource` objects.
 A `Resource` is essentially a more feature rich version of the JDK `java.net.URL` class.
-In fact, implementations of `Resource` wrap an instance of `java.net.URL`, where
+In fact, the implementations of the `Resource` wrap an instance of `java.net.URL`, where
 appropriate. A `Resource` can obtain low-level resources from almost any location in a
 transparent fashion, including from the classpath, a filesystem location, anywhere
 describable with a standard URL, and some other variations. If the resource location
@@ -3,7 +3,7 @@

 If a bean is a dependency of another bean, that usually means that one bean is set as a
 property of another. Typically you accomplish this with the
-xref:core/beans/dependencies/factory-properties-detailed.adoc#beans-ref-element[`<ref/>` element]
+xref:core/beans/dependencies/factory-properties-detailed.adoc#beans-ref-element[`<ref/>` element>]
 in XML-based metadata or through xref:core/beans/dependencies/factory-autowire.adoc[autowiring].

 However, sometimes dependencies between beans are less direct. An example is when a static
@@ -102,8 +102,8 @@ following snippet:
 ----
 	<bean id="theTargetBean" class="..." />

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

@@ -168,8 +168,8 @@ listings shows how to use the `parent` attribute:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
-	<!-- in the child (descendant) context, bean name is the same as the parent bean -->
-	<bean id="accountService" 
+	<!-- in the child (descendant) context -->
+	<bean id="accountService" <!-- bean name is the same as the parent bean -->
 		class="org.springframework.aop.framework.ProxyFactoryBean">
 		<property name="target">
 			<ref parent="accountService"/> <!-- notice how we refer to the parent bean -->
@@ -64,7 +64,7 @@ This prevents the same `@Bean` method from accidentally being invoked through a
 Java method call, which helps to reduce subtle bugs that can be hard to track down.

 When `@Bean` methods are declared within classes that are not annotated with
-`@Configuration`, or when `@Configuration(proxyBeanMethods=false)` is declared,
+`@Configuration` - or when `@Configuration(proxyBeanMethods=false)` is declared -,
 they are referred to as being processed in a "lite" mode. In such scenarios,
 `@Bean` methods are effectively a general-purpose factory method mechanism without
 special runtime processing (that is, without generating a CGLIB subclass for it).
@@ -444,27 +444,18 @@ component. This section discusses both of these options.
 The compiler can operate in one of three modes, which are captured in the
 `org.springframework.expression.spel.SpelCompilerMode` enum. The modes are as follows.

-`OFF` ::
-  The compiler is switched off, and all expressions will be evaluated in _interpreted_
-  mode. This is the default mode.
-`IMMEDIATE` ::
-  In immediate mode, expressions are compiled as soon as possible, typically after the
-  first interpreted evaluation. If evaluation of the compiled expression fails (for
-  example, due to a type changing, as described earlier), the caller of the expression
-  evaluation receives an exception. If the types of various expression elements change
-  over time, consider switching to `MIXED` mode or turning off the compiler.
-`MIXED` ::
-  In mixed mode, expression evaluation silently switches between _interpreted_ and
-  _compiled_ over time. After some number of successful interpreted runs, the expression
-  gets compiled. If evaluation of the compiled expression fails (for example, due to a
-  type changing), that failure will be caught internally, and the system will switch back
-  to interpreted mode for the given expression. Basically, the exception that the caller
-  receives in `IMMEDIATE` mode is instead handled internally. Sometime later, the
-  compiler may generate another compiled form and switch to it. This cycle of switching
-  between interpreted and compiled mode will continue until the system determines that it
-  does not make sense to continue trying — for example, when a certain failure threshold
-  has been reached — at which point the system will permanently switch to interpreted
-  mode for the given expression.
+* `OFF` (default): The compiler is switched off.
+* `IMMEDIATE`: In immediate mode, the expressions are compiled as soon as possible. This
+  is typically after the first interpreted evaluation. If the compiled expression fails
+  (typically due to a type changing, as described earlier), the caller of the expression
+  evaluation receives an exception.
+* `MIXED`: In mixed mode, the expressions silently switch between interpreted and
+  compiled mode over time. After some number of interpreted runs, they switch to compiled
+  form and, if something goes wrong with the compiled form (such as a type changing, as
+  described earlier), the expression automatically switches back to interpreted form
+  again. Sometime later, it may generate another compiled form and switch to it.
+  Basically, the exception that the user gets in `IMMEDIATE` mode is instead handled
+  internally.

 `IMMEDIATE` mode exists because `MIXED` mode could cause issues for expressions that
 have side effects. If a compiled expression blows up after partially succeeding, it
@@ -3,10 +3,8 @@

 You can invoke constructors by using the `new` operator. You should use the fully
 qualified class name for all types except those located in the `java.lang` package
-(`Integer`, `Float`, `String`, and so on).
-xref:core/expressions/language-ref/varargs.adoc[Varargs] are also supported.
-
-The following example shows how to use the `new` operator to invoke constructors.
+(`Integer`, `Float`, `String`, and so on). The following example shows how to use the
+`new` operator to invoke constructors:

 [tabs]
 ======
@@ -14,29 +12,30 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	Inventor einstein = parser.parseExpression(
-		"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
+	Inventor einstein = p.parseExpression(
+			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor.class);

 	// create new Inventor instance within the add() method of List
-	parser.parseExpression(
-		"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
-			.getValue(societyContext);
+	p.parseExpression(
+			"Members.add(new org.spring.samples.spel.inventor.Inventor(
+				'Albert Einstein', 'German'))").getValue(societyContext);
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes"]
 ----
-	val einstein = parser.parseExpression(
-		"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
+	val einstein = p.parseExpression(
+			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor::class.java)

 	// create new Inventor instance within the add() method of List
-	parser.parseExpression(
-		"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
+	p.parseExpression(
+			"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
 			.getValue(societyContext)
 ----
 ======


+
@@ -2,12 +2,8 @@
 = Functions

 You can extend SpEL by registering user-defined functions that can be called within
-expressions by using the `#functionName(...)` syntax, and like with standard method
-invocations, xref:core/expressions/language-ref/varargs.adoc[varargs] are also supported
-for function invocations.
-
-Functions can be registered as _variables_ in `EvaluationContext` implementations via the
-`setVariable()` method.
+expressions by using the `#functionName(...)` syntax. Functions can be registered as
+variables in `EvaluationContext` implementations via the `setVariable()` method.

 [TIP]
 ====
@@ -114,9 +110,8 @@ potentially more efficient use cases if the `MethodHandle` target and parameters
 been fully bound prior to registration; however, partially bound handles are also
 supported.

-Consider the `String#formatted(Object...)` instance method, which produces a message
-according to a template and a variable number of arguments
-(xref:core/expressions/language-ref/varargs.adoc[varargs]).
+Consider the `String#formatted(String, Object...)` instance method, which produces a
+message according to a template and a variable number of arguments.

 You can register and use the `formatted` method as a `MethodHandle`, as the following
 example shows:
@@ -156,10 +151,10 @@ Kotlin::
 ----
 ======

-As mentioned above, binding a `MethodHandle` and registering the bound `MethodHandle` is
-also supported. This is likely to be more performant if both the target and all the
-arguments are bound. In that case no arguments are necessary in the SpEL expression, as
-the following example shows:
+As hinted above, binding a `MethodHandle` and registering the bound `MethodHandle` is also
+supported. This is likely to be more performant if both the target and all the arguments
+are bound. In that case no arguments are necessary in the SpEL expression, as the
+following example shows:

 [tabs]
 ======
@@ -173,10 +168,9 @@ Java::
 	String template = "This is a %s message with %s words: <%s>";
 	Object varargs = new Object[] { "prerecorded", 3, "Oh Hello World!", "ignored" };
 	MethodHandle mh = MethodHandles.lookup().findVirtual(String.class, "formatted",
-		MethodType.methodType(String.class, Object[].class))
+			MethodType.methodType(String.class, Object[].class))
 			.bindTo(template)
-			// Here we have to provide the arguments in a single array binding:
-			.bindTo(varargs);
+			.bindTo(varargs); //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh);

 	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
@@ -195,10 +189,9 @@ Kotlin::
 	val varargs = arrayOf("prerecorded", 3, "Oh Hello World!", "ignored")

 	val mh = MethodHandles.lookup().findVirtual(String::class.java, "formatted",
-		MethodType.methodType(String::class.java, Array<Any>::class.java))
+			MethodType.methodType(String::class.java, Array<Any>::class.java))
 			.bindTo(template)
-			// Here we have to provide the arguments in a single array binding:
-			.bindTo(varargs)
+			.bindTo(varargs) //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh)

 	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
@@ -208,3 +201,4 @@ Kotlin::
 ======


+
@@ -1,11 +1,9 @@
 [[expressions-methods]]
 = Methods

-You can invoke methods by using the typical Java programming syntax. You can also invoke
-methods directly on literals such as strings or numbers.
-xref:core/expressions/language-ref/varargs.adoc[Varargs] are supported as well.
-
-The following examples show how to invoke methods.
+You can invoke methods by using typical Java programming syntax. You can also invoke methods
+on literals. Variable arguments are also supported. The following examples show how to
+invoke methods:

 [tabs]
 ======
@@ -1,151 +0,0 @@
-[[expressions-varargs]]
-= Varargs Invocations
-
-The Spring Expression Language supports
-https://docs.oracle.com/javase/8/docs/technotes/guides/language/varargs.html[varargs]
-invocations for xref:core/expressions/language-ref/constructors.adoc[constructors],
-xref:core/expressions/language-ref/methods.adoc[methods], and user-defined
-xref:core/expressions/language-ref/functions.adoc[functions].
-
-The following example shows how to invoke the `java.lang.String#formatted(Object...)`
-_varargs_ method within an expression by supplying the variable argument list as separate
-arguments (`'blue', 1`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	String expression = "'%s is color #%d'.formatted('blue', 1)";
-	String message = parser.parseExpression(expression).getValue(String.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	val expression = "'%s is color #%d'.formatted('blue', 1)"
-	val message = parser.parseExpression(expression).getValue(String::class.java)
----
-======
-
-A variable argument list can also be supplied as an array, as demonstrated in the
-following example (`new Object[] {'blue', 1}`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	String expression = "'%s is color #%d'.formatted(new Object[] {'blue', 1})";
-	String message = parser.parseExpression(expression).getValue(String.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	val expression = "'%s is color #%d'.formatted(new Object[] {'blue', 1})"
-	val message = parser.parseExpression(expression).getValue(String::class.java)
----
-======
-
-As an alternative, a variable argument list can be supplied as a `java.util.List` – for
-example, as an xref:core/expressions/language-ref/inline-lists.adoc[inline list]
-(`{'blue', 1}`). The following example shows how to do that.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	String expression = "'%s is color #%d'.formatted({'blue', 1})";
-	String message = parser.parseExpression(expression).getValue(String.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	val expression = "'%s is color #%d'.formatted({'blue', 1})"
-	val message = parser.parseExpression(expression).getValue(String::class.java)
----
-======
-
-[[expressions-varargs-type-conversion]]
-== Varargs Type Conversion
-
-In contrast to the standard support for varargs invocations in Java,
-xref:core/expressions/evaluation.adoc#expressions-type-conversion[type conversion] may be
-applied to the individual arguments when invoking varargs constructors, methods, or
-functions in SpEL.
-
-For example, if we have registered a custom
-xref:core/expressions/language-ref/functions.adoc[function] in the `EvaluationContext`
-under the name `#reverseStrings` for a method with the signature
-`String reverseStrings(String... strings)`, we can invoke that function within a SpEL
-expression with any argument that can be converted to a `String`, as demonstrated in the
-following example.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "3.0, 2.0, 1, SpEL"
-	String expression = "#reverseStrings('SpEL', 1, 10F / 5, 3.0000)";
-	String message = parser.parseExpression(expression)
-			.getValue(evaluationContext, String.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "3.0, 2.0, 1, SpEL"
-	val expression = "#reverseStrings('SpEL', 1, 10F / 5, 3.0000)"
-	val message = parser.parseExpression(expression)
-			.getValue(evaluationContext, String::class.java)
----
-======
-
-Similarly, any array whose component type is a subtype of the required varargs type can
-be supplied as the variable argument list for a varargs invocation. For example, a
-`String[]` array can be supplied to a varargs invocation that accepts an `Object...`
-argument list.
-
-The following listing demonstrates that we can supply a `String[]` array to the
-`java.lang.String#formatted(Object...)` _varargs_ method. It also highlights that `1`
-will be automatically converted to `"1"`.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	String expression = "'%s is color #%s'.formatted(new String[] {'blue', 1})";
-	String message = parser.parseExpression(expression).getValue(String.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes"]
----
-	// evaluates to "blue is color #1"
-	val expression = "'%s is color #%s'.formatted(new String[] {'blue', 1})"
-	val message = parser.parseExpression(expression).getValue(String::class.java)
----
-======
-
@@ -196,7 +196,7 @@ Kotlin::

 When used as `org.springframework.validation.Validator`, `LocalValidatorFactoryBean`
 invokes the underlying `jakarta.validation.Validator`, and then adapts
-``ConstraintViolation``s to ``FieldError``s, and registers them with the `Errors` object
+``ContraintViolation``s to ``FieldError``s, and registers them with the `Errors` object
 passed into the `validate` method.


@@ -281,11 +281,11 @@ Kotlin::

 A portable format annotation API exists in the `org.springframework.format.annotation`
 package. You can use `@NumberFormat` to format `Number` fields such as `Double` and
-`Long`, `@DurationFormat` to format `Duration` fields in ISO-8601 and simplified styles,
-and `@DateTimeFormat` to format fields such as `java.util.Date`, `java.util.Calendar`,
-and `Long` (for millisecond timestamps) as well as JSR-310 `java.time` types.
+`Long`, `@DurationFormat` to format `Duration` fields in ISO8601 and simplified styles,
+and `@DateTimeFormat` to format `java.util.Date`, `java.util.Calendar`, `Long`
+(for millisecond timestamps) as well as JSR-310 `java.time`.

-The following example uses `@DateTimeFormat` to format a `java.util.Date` as an ISO date
+The following example uses `@DateTimeFormat` to format a `java.util.Date` as an ISO Date
 (yyyy-MM-dd):

 [tabs]
@@ -311,29 +311,6 @@ Kotlin::
 ----
 ======

-For further details, see the javadoc for
-{spring-framework-api}/format/annotation/DateTimeFormat.html[`@DateTimeFormat`],
-{spring-framework-api}/format/annotation/DurationFormat.html[`@DurationFormat`], and
-{spring-framework-api}/format/annotation/NumberFormat.html[`@NumberFormat`].
-
-[WARNING]
-====
-Style-based formatting and parsing rely on locale-sensitive patterns which may change
-depending on the Java runtime. Specifically, applications that rely on date, time, or
-number parsing and formatting may encounter incompatible changes in behavior when running
-on JDK 20 or higher.
-
-Using an ISO standardized format or a concrete pattern that you control allows for
-reliable system-independent and locale-independent parsing and formatting of date, time,
-and number values.
-
-For `@DateTimeFormat`, the use of fallback patterns can also help to address
-compatibility issues.
-
-For further details, see the
-https://github.com/spring-projects/spring-framework/wiki/Date-and-Time-Formatting-with-JDK-20-and-higher[Date and Time Formatting with JDK 20 and higher]
-page in the Spring Framework wiki.
-====

 [[format-FormatterRegistry-SPI]]
 == The `FormatterRegistry` SPI
@@ -198,7 +198,7 @@ methods it offers can be found in the {spring-framework-api}/validation/Errors.h
 Validators may also get locally invoked for the immediate validation of a given object,
 not involving a binding process. As of 6.1, this has been simplified through a new
 `Validator.validateObject(Object)` method which is available by default now, returning
-a simple `Errors` representation which can be inspected: typically calling `hasErrors()`
+a simple ´Errors` representation which can be inspected: typically calling `hasErrors()`
 or the new `failOnError` method for turning the error summary message into an exception
 (for example, `validator.validateObject(myObject).failOnError(IllegalArgumentException::new)`).

@@ -6,7 +6,7 @@ the same way as Spring's integration does for the JDBC API.

 JMS can be roughly divided into two areas of functionality, namely the production and
 consumption of messages. The `JmsTemplate` class is used for message production and
-synchronous message receipt. For asynchronous receipt similar to Jakarta EE's
+synchronous message reception. For asynchronous reception similar to Jakarta EE's
 message-driven bean style, Spring provides a number of message-listener containers that
 you can use to create Message-Driven POJOs (MDPs). Spring also provides a declarative way
 to create message listeners.
@@ -5,7 +5,7 @@ This describes how to receive messages with JMS in Spring.


 [[jms-receiving-sync]]
-== Synchronous Receipt
+== Synchronous Reception

 While JMS is typically associated with asynchronous processing, you can
 consume messages synchronously. The overloaded `receive(..)` methods provide this
@@ -16,11 +16,11 @@ the receiver should wait before giving up waiting for a message.


 [[jms-receiving-async]]
-== Asynchronous Receipt: Message-Driven POJOs
+== Asynchronous reception: Message-Driven POJOs

 NOTE: Spring also supports annotated-listener endpoints through the use of the `@JmsListener`
-annotation and provides open infrastructure to register endpoints programmatically.
-This is, by far, the most convenient way to set up an asynchronous receiver.
+annotation and provides an open infrastructure to register endpoints programmatically.
+This is, by far, the most convenient way to setup an asynchronous receiver.
 See xref:integration/jms/annotated.adoc#jms-annotated-support[Enable Listener Endpoint Annotations] for more details.

 In a fashion similar to a Message-Driven Bean (MDB) in the EJB world, the Message-Driven
@@ -154,7 +154,7 @@ listener container.

 You can activate local resource transactions through the `sessionTransacted` flag
 on the listener container definition. Each message listener invocation then operates
-within an active JMS transaction, with message receipt rolled back in case of listener
+within an active JMS transaction, with message reception rolled back in case of listener
 execution failure. Sending a response message (through `SessionAwareMessageListener`) is
 part of the same local transaction, but any other resource operations (such as
 database access) operate independently. This usually requires duplicate message
@@ -173,7 +173,7 @@ To configure a message listener container for XA transaction participation, you
 to configure a `JtaTransactionManager` (which, by default, delegates to the Jakarta EE
 server's transaction subsystem). Note that the underlying JMS `ConnectionFactory` needs to
 be XA-capable and properly registered with your JTA transaction coordinator. (Check your
-Jakarta EE server's configuration of JNDI resources.) This lets message receipt as well
+Jakarta EE server's configuration of JNDI resources.) This lets message reception as well
 as (for example) database access be part of the same transaction (with unified commit
 semantics, at the expense of XA transaction log overhead).

@@ -167,15 +167,13 @@ operations that do not refer to a specific destination.

 One of the most common uses of JMS messages in the EJB world is to drive message-driven
 beans (MDBs). Spring offers a solution to create message-driven POJOs (MDPs) in a way
-that does not tie a user to an EJB container. (See
-xref:integration/jms/receiving.adoc#jms-receiving-async[Asynchronous Receipt: Message-Driven POJOs]
-for detailed coverage of Spring's MDP support.) Endpoint methods can be annotated with
-`@JmsListener` -- see xref:integration/jms/annotated.adoc[Annotation-driven Listener Endpoints]
-for more details.
+that does not tie a user to an EJB container. (See xref:integration/jms/receiving.adoc#jms-receiving-async[Asynchronous reception: Message-Driven POJOs] for detailed
+coverage of Spring's MDP support.) Since Spring Framework 4.1, endpoint methods can be
+annotated with `@JmsListener` -- see xref:integration/jms/annotated.adoc[Annotation-driven Listener Endpoints] for more details.

 A message listener container is used to receive messages from a JMS message queue and
 drive the `MessageListener` that is injected into it. The listener container is
-responsible for all threading of message receipt and dispatches into the listener for
+responsible for all threading of message reception and dispatches into the listener for
 processing. A message listener container is the intermediary between an MDP and a
 messaging provider and takes care of registering to receive messages, participating in
 transactions, resource acquisition and release, exception conversion, and so on. This
@@ -229,7 +227,7 @@ the JMS provider, advanced functionality (such as participation in externally ma
 transactions), and compatibility with Jakarta EE environments.

 You can customize the cache level of the container. Note that, when no caching is enabled,
-a new connection and a new session is created for each message receipt. Combining this
+a new connection and a new session is created for each message reception. Combining this
 with a non-durable subscription with high loads may lead to message loss. Make sure to
 use a proper cache level in such a case.

@@ -248,7 +246,7 @@ in the form of a business entity existence check or a protocol table check.
 Any such arrangements are significantly more efficient than the alternative:
 wrapping your entire processing with an XA transaction (through configuring your
 `DefaultMessageListenerContainer` with an `JtaTransactionManager`) to cover the
-receipt of the JMS message as well as the execution of the business logic in your
+reception of the JMS message as well as the execution of the business logic in your
 message listener (including database operations, etc.).

 IMPORTANT: The default `AUTO_ACKNOWLEDGE` mode does not provide proper reliability guarantees.
@@ -37,7 +37,7 @@ As outlined xref:integration/observability.adoc[at the beginning of this section
 |Processing time for an execution of a `@Scheduled` task
 |===

-NOTE: Observations use Micrometer's official naming convention, but Metrics names will be automatically converted
+NOTE: Observations are using Micrometer's official naming convention, but Metrics names will be automatically converted
 {micrometer-docs}/concepts/naming.html[to the format preferred by the monitoring system backend]
 (Prometheus, Atlas, Graphite, InfluxDB...).

@@ -97,7 +97,7 @@ This can be done by declaring a `SchedulingConfigurer` bean that sets the observ

 include-code::./ObservationSchedulingConfigurer[]

-It uses the `org.springframework.scheduling.support.DefaultScheduledTaskObservationConvention` by default, backed by the `ScheduledTaskObservationContext`.
+It is using the `org.springframework.scheduling.support.DefaultScheduledTaskObservationConvention` by default, backed by the `ScheduledTaskObservationContext`.
 You can configure a custom implementation on the `ObservationRegistry` directly.
 During the execution of the scheduled method, the current observation is restored in the `ThreadLocal` context or the Reactor context (if the scheduled method returns a `Mono` or `Flux` type).

@@ -107,7 +107,7 @@ By default, the following `KeyValues` are created:
 [cols="a,a"]
 |===
 |Name | Description
-|`code.function` _(required)_|Name of the Java `Method` that is scheduled for execution.
+|`code.function` _(required)_|Name of Java `Method` that is scheduled for execution.
 |`code.namespace` _(required)_|Canonical name of the class of the bean instance that holds the scheduled method, or `"ANONYMOUS"` for anonymous classes.
 |`error` _(required)_|Class name of the exception thrown during the execution, or `"none"` if no exception happened.
 |`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
@@ -126,7 +126,7 @@ This instrumentation will create 2 types of observations:
 * `"jms.message.publish"` when a JMS message is sent to the broker, typically with `JmsTemplate`.
 * `"jms.message.process"` when a JMS message is processed by the application, typically with a `MessageListener` or a `@JmsListener` annotated method.

-NOTE: Currently there is no instrumentation for `"jms.message.receive"` observations as there is little value in measuring the time spent waiting for the receipt of a message.
+NOTE: currently there is no instrumentation for `"jms.message.receive"` observations as there is little value in measuring the time spent waiting for the reception of a message.
 Such an integration would typically instrument `MessageConsumer#receive` method calls. But once those return, the processing time is not measured and the trace scope cannot be propagated to the application.

 By default, both observations share the same set of possible `KeyValues`:
@@ -138,7 +138,7 @@ By default, both observations share the same set of possible `KeyValues`:
 |`error` |Class name of the exception thrown during the messaging operation (or "none").
 |`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
 |`messaging.destination.temporary` _(required)_|Whether the destination is a `TemporaryQueue` or `TemporaryTopic` (values: `"true"` or `"false"`).
-|`messaging.operation` _(required)_|Name of the JMS operation being performed (values: `"publish"` or `"process"`).
+|`messaging.operation` _(required)_|Name of JMS operation being performed (values: `"publish"` or `"process"`).
 |===

 .High cardinality Keys
@@ -146,7 +146,7 @@ By default, both observations share the same set of possible `KeyValues`:
 |===
 |Name | Description
 |`messaging.message.conversation_id` |The correlation ID of the JMS message.
-|`messaging.destination.name` |The name of the destination the current message was sent to.
+|`messaging.destination.name` |The name of destination the current message was sent to.
 |`messaging.message.id` |Value used by the messaging system as an identifier for the message.
 |===

@@ -213,7 +213,7 @@ By default, the following `KeyValues` are created:
 |Name | Description
 |`error` _(required)_|Class name of the exception thrown during the exchange, or `"none"` if no exception happened.
 |`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
-|`method` _(required)_|Name of the HTTP request method or `"none"` if not a well-known method.
+|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
 |`outcome` _(required)_|Outcome of the HTTP server exchange.
 |`status` _(required)_|HTTP response raw status code, or `"UNKNOWN"` if no response was created.
 |`uri` _(required)_|URI pattern for the matching handler if available, falling back to `REDIRECTION` for 3xx responses, `NOT_FOUND` for 404 responses, `root` for requests with no path info, and `UNKNOWN` for all other requests.
@@ -235,10 +235,10 @@ This can be done on the `WebHttpHandlerBuilder`, as follows:

 include-code::./HttpHandlerConfiguration[]

-It uses the `org.springframework.http.server.reactive.observation.DefaultServerRequestObservationConvention` by default, backed by the `ServerRequestObservationContext`.
+It is using the `org.springframework.http.server.reactive.observation.DefaultServerRequestObservationConvention` by default, backed by the `ServerRequestObservationContext`.

 This will only record an observation as an error if the `Exception` has not been handled by an application Controller.
-Typically, all exceptions handled by Spring WebFlux's `@ExceptionHandler` and xref:web/webflux/ann-rest-exceptions.adoc[`ProblemDetail` support] will not be recorded with the observation.
+Typically, all exceptions handled by Spring WebFlux's `@ExceptionHandler` and <<web.adoc#webflux-ann-rest-exceptions,`ProblemDetail` support>> will not be recorded with the observation.
 You can, at any point during request processing, set the error field on the `ObservationContext` yourself:

 include-code::./UserController[]
@@ -251,7 +251,7 @@ By default, the following `KeyValues` are created:
 |Name | Description
 |`error` _(required)_|Class name of the exception thrown during the exchange, or `"none"` if no exception happened.
 |`exception` _(deprecated)_|Duplicates the `error` key and might be removed in the future.
-|`method` _(required)_|Name of the HTTP request method or `"none"` if not a well-known method.
+|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
 |`outcome` _(required)_|Outcome of the HTTP server exchange.
 |`status` _(required)_|HTTP response raw status code, or `"UNKNOWN"` if no response was created.
 |`uri` _(required)_|URI pattern for the matching handler if available, falling back to `REDIRECTION` for 3xx responses, `NOT_FOUND` for 404 responses, `root` for requests with no path info, and `UNKNOWN` for all other requests.
@@ -270,7 +270,6 @@ By default, the following `KeyValues` are created:
 == HTTP Client Instrumentation

 HTTP client exchange observations are created with the name `"http.client.requests"` for blocking and reactive clients.
-This observation measures the entire HTTP request/response exchange, from connection establishment up to body deserialization.
 Unlike their server counterparts, the instrumentation is implemented directly in the client so the only required step is to configure an `ObservationRegistry` on the client.

 [[observability.http-client.resttemplate]]
@@ -285,8 +284,8 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 [cols="a,a"]
 |===
 |Name | Description
-|`method` _(required)_|Name of the HTTP request method or `"none"` if not a well-known method.
-|`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. The protocol, host and port part of the URI are not considered.
+|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. Only the path part of the URI is considered.
 |`client.name` _(required)_|Client name derived from the request URI host.
 |`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
 |`outcome` _(required)_|Outcome of the HTTP client exchange.
@@ -313,8 +312,8 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 [cols="a,a"]
 |===
 |Name | Description
-|`method` _(required)_|Name of the HTTP request method or `"none"` if the request could not be created.
-|`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. The protocol, host and port part of the URI are not considered.
+|`method` _(required)_|Name of HTTP request method or `"none"` if the request could not be created.
+|`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. Only the path part of the URI is considered.
 |`client.name` _(required)_|Client name derived from the request URI host.
 |`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
 |`outcome` _(required)_|Outcome of the HTTP client exchange.
@@ -333,7 +332,7 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 [[observability.http-client.webclient]]
 === WebClient

-Applications must configure an `ObservationRegistry` on the `WebClient.Builder` to enable the instrumentation; without that, observations are "no-ops".
+Applications must configure an `ObservationRegistry` on the `WebClient` builder to enable the instrumentation; without that, observations are "no-ops".
 Spring Boot will auto-configure `WebClient.Builder` beans with the observation registry already set.

 Instrumentation uses the `org.springframework.web.reactive.function.client.ClientRequestObservationConvention` by default, backed by the `ClientRequestObservationContext`.
@@ -342,8 +341,8 @@ Instrumentation uses the `org.springframework.web.reactive.function.client.Clien
 [cols="a,a"]
 |===
 |Name | Description
-|`method` _(required)_|Name of the HTTP request method or `"none"` if not a well-known method.
-|`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. The protocol, host and port part of the URI are not considered.
+|`method` _(required)_|Name of HTTP request method or `"none"` if not a well-known method.
+|`uri` _(required)_|URI template used for HTTP request, or `"none"` if none was provided. Only the path part of the URI is considered.
 |`client.name` _(required)_|Client name derived from the request URI host.
 |`status` _(required)_|HTTP response raw status code, or `"IO_ERROR"` in case of `IOException`, or `"CLIENT_ERROR"` if no response was received.
 |`outcome` _(required)_|Outcome of the HTTP client exchange.
@@ -938,10 +938,10 @@ method parameters:
 | Dynamically set the HTTP method for the request, overriding the annotation's `method` attribute

 | `@RequestHeader`
-| Add a request header or multiple headers. The argument may be a single value,
-  a `Collection<?>` of values, `Map<String, ?>`,`MultiValueMap<String, ?>`.
-  Type conversion is supported for non-String values. Header values are added and
-  do not override already added header values.
+| Add a request header or multiple headers. The argument may be a `Map<String, ?>` or
+  `MultiValueMap<String, ?>` with multiple headers, a `Collection<?>` of values, or an
+  individual value. Type conversion is supported for non-String values. This overrides
+  the annotation's `headers` attribute.

 | `@PathVariable`
 | Add a variable for expand a placeholder in the request URL. The argument may be a
@@ -14,13 +14,16 @@ For example, `@Autowired lateinit var thing: Thing` implies that a bean
 of type `Thing` must be registered in the application context, while `@Autowired lateinit var thing: Thing?`
 does not raise an error if such a bean does not exist.

-Following the same principle, `@Bean fun play(toy: Toy, car: Car?) = Baz(toy, car)` implies
+Following the same principle, `@Bean fun play(toy: Toy, car: Car?) = Baz(toy, Car)` implies
 that a bean of type `Toy` must be registered in the application context, while a bean of
 type `Car` may or may not exist. The same behavior applies to autowired constructor parameters.

 NOTE: If you use bean validation on classes with properties or a primary constructor
-with parameters, you may need to use
+parameters, you may need to use
 {kotlin-docs}/annotations.html#annotation-use-site-targets[annotation use-site targets],
 such as `@field:NotNull` or `@get:Size(min=5, max=15)`, as described in
 {stackoverflow-site}/a/35853200/1092077[this Stack Overflow response].

+
+
+
@@ -1,68 +1,46 @@
 [[spring-testing-annotation-beanoverriding-mockitobean]]
 = `@MockitoBean` and `@MockitoSpyBean`

-`@MockitoBean` and `@MockitoSpyBean` are used on non-static fields in test classes to
-override beans in the test's `ApplicationContext` with a Mockito _mock_ or _spy_,
-respectively. In the latter case, an early instance of the original bean is captured and
-wrapped by the spy.
+`@MockitoBean` and `@MockitoSpyBean` are used on fields in test classes to override beans
+in the test's `ApplicationContext` with a Mockito _mock_ or _spy_, respectively. In the
+latter case, an early instance of the original bean is captured and wrapped by the spy.

 By default, the annotated field's type is used to search for candidate beans to override.
 If multiple candidates match, `@Qualifier` can be provided to narrow the candidate to
 override. Alternatively, a candidate whose bean name matches the name of the field will
 match.

+When using `@MockitoBean`, a new bean will be created if a corresponding bean does not
+exist. However, if you would like for the test to fail when a corresponding bean does not
+exist, you can set the `enforceOverride` attribute to `true` – for example,
+`@MockitoBean(enforceOverride = true)`.
+
+To use a by-name override rather than a by-type override, specify the `name` attribute
+of the annotation.
+
 [WARNING]
 ====
 Qualifiers, including the name of the field, are used to determine if a separate
 `ApplicationContext` needs to be created. If you are using this feature to mock or spy
-the same bean in several test classes, make sure to name the field consistently to avoid
+the same bean in several tests, make sure to name the field consistently to avoid
 creating unnecessary contexts.
 ====

-Each annotation also defines Mockito-specific attributes to fine-tune the mocking behavior.
+Each annotation also defines Mockito-specific attributes to fine-tune the mocking details.

-The `@MockitoBean` annotation uses the `REPLACE_OR_CREATE`
+By default, the `@MockitoBean` annotation uses the `REPLACE_OR_CREATE`
 xref:testing/testcontext-framework/bean-overriding.adoc#testcontext-bean-overriding-custom[strategy for test bean overriding].
-If no existing bean matches, a new bean is created on the fly. However, you can switch to
-the `REPLACE` strategy by setting the `enforceOverride` attribute to `true`. See the
-following section for an example.
+If no existing bean matches, a new bean is created on the fly. As mentioned previously,
+you can switch to the `REPLACE` strategy by setting the `enforceOverride` attribute to
+`true`.

 The `@MockitoSpyBean` annotation uses the `WRAP`
 xref:testing/testcontext-framework/bean-overriding.adoc#testcontext-bean-overriding-custom[strategy],
 and the original instance is wrapped in a Mockito spy. This strategy requires that
 exactly one candidate bean exists.

-[TIP]
-====
-Only _singleton_ beans can be overridden. Any attempt to override a non-singleton bean
-will result in an exception.
-
-When using `@MockitoBean` to mock a bean created by a `FactoryBean`, the `FactoryBean`
-will be replaced with a singleton mock of the type of object created by the `FactoryBean`.
-
-When using `@MockitoSpyBean` to create a spy for a `FactoryBean`, a spy will be created
-for the object created by the `FactoryBean`, not for the `FactoryBean` itself.
-====
-
-[NOTE]
-====
-There are no restrictions on the visibility of `@MockitoBean` and `@MockitoSpyBean`
-fields.
-
-Such fields can therefore be `public`, `protected`, package-private (default visibility),
-or `private` depending on the needs or coding practices of the project.
-====
-
-[[spring-testing-annotation-beanoverriding-mockitobean-examples]]
-== `@MockitoBean` Examples
-
-When using `@MockitoBean`, a new bean will be created if a corresponding bean does not
-exist. However, if you would like for the test to fail when a corresponding bean does not
-exist, you can set the `enforceOverride` attribute to `true` – for example,
-`@MockitoBean(enforceOverride = true)`.
-
-To use a by-name override rather than a by-type override, specify the `name` (or `value`)
-attribute of the annotation.
+NOTE: Only _singleton_ beans can be overridden. Any attempt to override a non-singleton
+bean will result in an exception.

 The following example shows how to use the default behavior of the `@MockitoBean` annotation:

@@ -72,13 +50,11 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
+	class OverrideBeanTests {
 		@MockitoBean // <1>
-		CustomService customService;
+		private CustomService customService;

-		// tests...
+		// test case body...
 	}
 ----
 <1> Replace the bean with type `CustomService` with a Mockito `mock`.
@@ -87,8 +63,8 @@ Java::
 In the example above, we are creating a mock for `CustomService`. If more than one bean
 of that type exists, the bean named `customService` is considered. Otherwise, the test
 will fail, and you will need to provide a qualifier of some sort to identify which of the
-`CustomService` beans you want to override. If no such bean exists, a bean will be
-created with an auto-generated bean name.
+`CustomService` beans you want to override. If no such bean exists, a bean definition
+will be created with an auto-generated bean name.

 The following example uses a by-name lookup, rather than a by-type lookup:

@@ -98,43 +74,20 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
+	class OverrideBeanTests {
 		@MockitoBean("service") // <1>
-		CustomService customService;
+		private CustomService customService;

-		// tests...
+		// test case body...

 	}
 ----
 <1> Replace the bean named `service` with a Mockito `mock`.
 ======

-If no bean named `service` exists, one is created.
+If no bean definition named `service` exists, one is created.

-`@MockitoBean` can also be used at the type level:
-
- on a test class or any superclass or implemented interface in the type hierarchy above
-  the test class
- on an enclosing class for a `@Nested` test class or on any class or interface in the
-  type hierarchy or enclosing class hierarchy above the `@Nested` test class
-
-When `@MockitoBean` is declared at the type level, the type of bean (or beans) to mock
-must be supplied via the `types` attribute – for example,
-`@MockitoBean(types = {OrderService.class, UserService.class})`. If multiple candidates
-exist in the application context, you can explicitly specify a bean name to mock by
-setting the `name` attribute. Note, however, that the `types` attribute must contain a
-single type if an explicit bean `name` is configured – for example,
-`@MockitoBean(name = "ps1", types = PrintingService.class)`.
-
-To support reuse of mock configuration, `@MockitoBean` may be used as a meta-annotation
-to create custom _composed annotations_ — for example, to define common mock
-configuration in a single annotation that can be reused across a test suite.
-`@MockitoBean` can also be used as a repeatable annotation at the type level — for
-example, to mock several beans by name.
-
-The following `@SharedMocks` annotation registers two mocks by-type and one mock by-name.
+The following example shows how to use the default behavior of the `@MockitoSpyBean` annotation:

 [tabs]
 ======
@@ -142,70 +95,11 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	@Target(ElementType.TYPE)
-	@Retention(RetentionPolicy.RUNTIME)
-	@MockitoBean(types = {OrderService.class, UserService.class}) // <1>
-	@MockitoBean(name = "ps1", types = PrintingService.class) // <2>
-	public @interface SharedMocks {
-	}
----
-<1> Register `OrderService` and `UserService` mocks by-type.
-<2> Register `PrintingService` mock by-name.
-======
-
-The following demonstrates how `@SharedMocks` can be used on a test class.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig.class)
-	@SharedMocks // <1>
-	class BeanOverrideTests {
-
-		@Autowired OrderService orderService; // <2>
-
-		@Autowired UserService userService; // <2>
-
-		@Autowired PrintingService ps1; // <2>
-
-		// Inject other components that rely on the mocks.
-
-		@Test
-		void testThatDependsOnMocks() {
-			// ...
-		}
-	}
----
-<1> Register common mocks via the custom `@SharedMocks` annotation.
-<2> Optionally inject mocks to _stub_ or _verify_ them.
-======
-
-TIP: The mocks can also be injected into `@Configuration` classes or other test-related
-components in the `ApplicationContext` in order to configure them with Mockito's stubbing
-APIs.
-
-[[spring-testing-annotation-beanoverriding-mockitospybean-examples]]
-== `@MockitoSpyBean` Examples
-
-The following example shows how to use the default behavior of the `@MockitoSpyBean`
-annotation:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes"]
----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
+	class OverrideBeanTests {
 		@MockitoSpyBean // <1>
-		CustomService customService;
+		private CustomService customService;

-		// tests...
+		// test case body...
 	}
 ----
 <1> Wrap the bean with type `CustomService` with a Mockito `spy`.
@@ -224,13 +118,12 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	@SpringJUnitConfig(TestConfig.class)
-	class BeanOverrideTests {
-
+	class OverrideBeanTests {
 		@MockitoSpyBean("service") // <1>
-		CustomService customService;
+		private CustomService customService;
+
+		// test case body...

-		// tests...
 	}
 ----
 <1> Wrap the bean named `service` with a Mockito `spy`.
@@ -1,8 +1,8 @@
 [[spring-testing-annotation-beanoverriding-testbean]]
 = `@TestBean`

-`@TestBean` is used on a non-static field in a test class to override a specific bean in
-the test's `ApplicationContext` with an instance provided by a factory method.
+`@TestBean` is used on a field in a test class to override a specific bean in the test's
+`ApplicationContext` with an instance provided by a factory method.

 The associated factory method name is derived from the annotated field's name, or the
 bean name if specified. The factory method must be `static`, accept no arguments, and
@@ -30,14 +30,6 @@ same bean in several tests, make sure to name the field consistently to avoid cr
 unnecessary contexts.
 ====

-[NOTE]
-====
-There are no restrictions on the visibility of `@TestBean` fields or factory methods.
-
-Such fields and methods can therefore be `public`, `protected`, package-private (default
-visibility), or `private` depending on the needs or coding practices of the project.
-====
-
 The following example shows how to use the default behavior of the `@TestBean` annotation:

 [tabs]
@@ -48,11 +40,11 @@ Java::
 ----
 	class OverrideBeanTests {
 		@TestBean // <1>
-		CustomService customService;
+		private CustomService customService;

 		// test case body...

-		static CustomService customService() { // <2>
+		private static CustomService customService() { // <2>
 			return new MyFakeCustomService();
 		}
 	}
@@ -76,11 +68,11 @@ Java::
 ----
 	class OverrideBeanTests {
 		@TestBean(name = "service", methodName = "createCustomService") // <1>
-		CustomService customService;
+		private CustomService customService;

 		// test case body...

-		static CustomService createCustomService() { // <2>
+		private static CustomService createCustomService() { // <2>
 			return new MyFakeCustomService();
 		}
 	}
@@ -90,24 +82,15 @@ Java::
 <2> The result of this static method will be used as the instance and injected into the field.
 ======

-[TIP]
+[NOTE]
 ====
-To locate the factory method to invoke, Spring searches in the class in which the
-`@TestBean` field is declared, in one of its superclasses, or in any implemented
-interfaces. If the `@TestBean` field is declared in a `@Nested` test class, the enclosing
-class hierarchy will also be searched.
+Spring searches for the factory method to invoke in the test class, in the test class
+hierarchy, and in the enclosing class hierarchy for a `@Nested` test class.

 Alternatively, a factory method in an external class can be referenced via its
 fully-qualified method name following the syntax `<fully-qualified class name>#<method name>`
 – for example, `methodName = "org.example.TestUtils#createCustomService"`.
 ====

-[TIP]
-====
-Only _singleton_ beans can be overridden. Any attempt to override a non-singleton bean
-will result in an exception.
-
-When overriding a bean created by a `FactoryBean`, the `FactoryBean` will be replaced
-with a singleton bean corresponding to the value returned from the `@TestBean` factory
-method.
-====
+NOTE: Only _singleton_ beans can be overridden. Any attempt to override a non-singleton
+bean will result in an exception.
@@ -2,8 +2,7 @@
 = Bean Overriding in Tests

 Bean overriding in tests refers to the ability to override specific beans in the
-`ApplicationContext` for a test class, by annotating one or more non-static fields in the
-test class.
+`ApplicationContext` for a test class, by annotating one or more fields in the test class.

 NOTE: This feature is intended as a less risky alternative to the practice of registering
 a bean via `@Bean` with the `DefaultListableBeanFactory`
@@ -42,10 +41,9 @@ The `spring-test` module registers implementations of the latter two
 {spring-framework-code}/spring-test/src/main/resources/META-INF/spring.factories[`META-INF/spring.factories`
 properties file].

-The bean overriding infrastructure searches in test classes for any non-static field that
-is meta-annotated with `@BeanOverride` and instantiates the corresponding
-`BeanOverrideProcessor` which is responsible for creating an appropriate
-`BeanOverrideHandler`.
+The bean overriding infrastructure searches in test classes for any field meta-annotated
+with `@BeanOverride` and instantiates the corresponding `BeanOverrideProcessor` which is
+responsible for creating an appropriate `BeanOverrideHandler`.

 The internal `BeanOverrideBeanFactoryPostProcessor` then uses bean override handlers to
 alter the test's `ApplicationContext` by creating, replacing, or wrapping beans as
@@ -59,19 +57,6 @@ defined by the corresponding `BeanOverrideStrategy`:
 `WRAP`::
  Retrieves the original bean and wraps it.

-[TIP]
-====
-Only _singleton_ beans can be overridden. Any attempt to override a non-singleton bean
-will result in an exception.
-
-When replacing a bean created by a `FactoryBean`, the `FactoryBean` itself will be
-replaced with a singleton bean corresponding to bean override instance created by the
-applicable `BeanOverrideHandler`.
-
-When wrapping a bean created by a `FactoryBean`, the object created by the `FactoryBean`
-will be wrapped, not the `FactoryBean` itself.
-====
-
 [NOTE]
 ====
 In contrast to Spring's autowiring mechanism (for example, resolution of an `@Autowired`
@@ -86,3 +71,6 @@ Alternatively, the user can directly provide the bean name in the custom annotat
 `BeanOverrideProcessor` implementations may also internally compute a bean name based on
 a convention or some other method.
 ====
+
+NOTE: Only _singleton_ beans can be overridden. Any attempt to override a non-singleton
+bean will result in an exception.
@@ -10,7 +10,6 @@ by default, exactly in the following order:
  annotation for "`before`" modes.
 * `ApplicationEventsTestExecutionListener`: Provides support for
  xref:testing/testcontext-framework/application-events.adoc[`ApplicationEvents`].
-* `BeanOverrideTestExecutionListener`: Provides support for xref:testing/testcontext-framework/bean-overriding.adoc[] .
 * `DependencyInjectionTestExecutionListener`: Provides dependency injection for the test
  instance.
 * `MicrometerObservationRegistryTestExecutionListener`: Provides support for
@@ -26,6 +25,7 @@ by default, exactly in the following order:
 * `EventPublishingTestExecutionListener`: Publishes test execution events to the test's
  `ApplicationContext` (see xref:testing/testcontext-framework/test-execution-events.adoc[Test Execution Events]).
 * `MockitoResetTestExecutionListener`: Resets mocks as configured by `@MockitoBean` or `@MockitoSpyBean`.
+* `BeanOverrideTestExecutionListener`: Provides support for xref:testing/testcontext-framework/bean-overriding.adoc[] .

 [[testcontext-tel-config-registering-tels]]
 == Registering `TestExecutionListener` Implementations
@@ -127,7 +127,7 @@ Kotlin::
 ======

 For Spring MVC, use the following where the Spring `ApplicationContext` is passed to
-{spring-framework-api}/test/web/servlet/setup/MockMvcBuilders.html#webAppContextSetup(org.springframework.web.context.WebApplicationContext)[MockMvcBuilders.webAppContextSetup]
+{spring-framework-api}/test/web/servlet/setup/MockMvcBuilders.html#webAppContextSetup-org.springframework.web.context.WebApplicationContext-[MockMvcBuilders.webAppContextSetup]
 to create a xref:testing/mockmvc.adoc[MockMvc] instance to handle
 requests:

@@ -193,7 +193,7 @@ Kotlin::
 [[webtestclient-fn-config]]
 === Bind to Router Function

-This setup allows you to test xref:web/webflux-functional.adoc[functional endpoints] via
+This setup allows you to test <<web-reactive.adoc#webflux-fn, functional endpoints>> via
 mock request and response objects, without a running server.

 For WebFlux, use the following which delegates to `RouterFunctions.toWebHandler` to
@@ -1,6 +1,5 @@
 [[webflux-cors]]
 = CORS
-
 [.small]#xref:web/webmvc-cors.adoc[See equivalent in the Servlet stack]#

 Spring WebFlux lets you handle CORS (Cross-Origin Resource Sharing). This section
@@ -365,7 +364,7 @@ Kotlin::

 You can apply CORS support through the built-in
 {spring-framework-api}/web/cors/reactive/CorsWebFilter.html[`CorsWebFilter`], which is a
-good fit with xref:web/webflux-functional.adoc[functional endpoints].
+good fit with <<webflux-fn, functional endpoints>>.

 NOTE: If you try to use the `CorsFilter` with Spring Security, keep in mind that Spring
 Security has {docs-spring-security}/servlet/integrations/cors.html[built-in support] for
@@ -1,6 +1,5 @@
 [[webflux-fn]]
 = Functional Endpoints
-
 [.small]#xref:web/webmvc-functional.adoc[See equivalent in the Servlet stack]#

 Spring WebFlux includes WebFlux.fn, a lightweight functional programming model in which functions
@@ -1,6 +1,5 @@
 [[webflux-websocket]]
 = WebSockets
-
 [.small]#xref:web/websocket.adoc[See equivalent in the Servlet stack]#

 This part of the reference documentation covers support for reactive-stack WebSocket
@@ -94,8 +94,7 @@ class WebConfig : WebFluxConfigurer {
 [.small]#xref:web/webmvc/mvc-config/conversion.adoc[See equivalent in the Servlet stack]#

 By default, formatters for various number and date types are installed, along with support
-for customization via `@NumberFormat`, `@DurationFormat`, and `@DateTimeFormat` on fields
-and parameters.
+for customization via `@NumberFormat`, `@DurationFormat` and `@DateTimeFormat` on fields.

 To register custom formatters and converters in Java config, use the following:

@@ -350,6 +349,7 @@ which customizes Jackson's default properties with the following ones:

 It also automatically registers the following well-known modules if they are detected on the classpath:

+* {jackson-github-org}/jackson-datatype-joda[`jackson-datatype-joda`]: Support for Joda-Time types.
 * {jackson-github-org}/jackson-datatype-jsr310[`jackson-datatype-jsr310`]: Support for Java 8 Date and Time API types.
 * {jackson-github-org}/jackson-datatype-jdk8[`jackson-datatype-jdk8`]: Support for other Java 8 types, such as `Optional`.
 * {jackson-github-org}/jackson-module-kotlin[`jackson-module-kotlin`]: Support for Kotlin classes and data classes.
@@ -605,4 +605,9 @@ For method parameters and returns values, generally, `@HttpExchange` supports a
 subset of the method parameters that `@RequestMapping` does. Notably, it excludes any
 server-side specific parameter types. For details, see the list for
 xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[@HttpExchange] and
-xref:web/webflux/controller/ann-methods/arguments.adoc[@RequestMapping].
+xref:web/webflux/controller/ann-methods/arguments.adoc[@RequestMapping].
+
+`@HttpExchange` also supports a `headers()` parameter which accepts `"name=value"`-like
+pairs like in `@RequestMapping(headers={})` on the client side. On the server side,
+this extends to the full syntax that
+xref:#webflux-ann-requestmapping-params-and-headers[`@RequestMapping`] supports.
@@ -101,7 +101,7 @@ On that foundation, Spring WebFlux provides a choice of two programming models:
 from the `spring-web` module. Both Spring MVC and WebFlux controllers support reactive
 (Reactor and RxJava) return types, and, as a result, it is not easy to tell them apart. One notable
 difference is that WebFlux also supports reactive `@RequestBody` arguments.
-* xref:web/webflux-functional.adoc[Functional Endpoints]: Lambda-based, lightweight, and functional programming model. You can think of
+* <<webflux-fn>>: Lambda-based, lightweight, and functional programming model. You can think of
 this as a small library or a set of utilities that an application can use to route and
 handle requests. The big difference with annotated controllers is that the application
 is in charge of request handling from start to finish versus declaring intent through
@@ -419,24 +419,6 @@ controllers. However, when you use it with Spring Security, we advise relying on

 See the section on xref:web/webflux-cors.adoc[CORS] and the xref:web/webflux-cors.adoc#webflux-cors-webfilter[CORS `WebFilter`] for more details.

-[[filters.url-handler]]
-=== URL Handler
-[.small]#xref:web/webmvc/filters.adoc#filters.url-handler[See equivalent in the Servlet 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")`.
-
-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 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]
-
-

 [[webflux-exception-handler]]
 == Exceptions
@@ -1,6 +1,5 @@
 [[mvc-cors]]
 = CORS
-
 [.small]#xref:web/webflux-cors.adoc[See equivalent in the Reactive stack]#

 Spring MVC lets you handle CORS (Cross-Origin Resource Sharing). This section
@@ -1,7 +1,6 @@
 [[webmvc-fn]]
 = Functional Endpoints
-
-[.small]#xref:web/webflux-functional.adoc[See equivalent in the Reactive stack]#
+[.small]#<<web-reactive.adoc#webflux-fn, See equivalent in the Reactive stack>>#

 Spring Web MVC includes WebMvc.fn, a lightweight functional programming model in which functions
 are used to route and handle requests and contracts are designed for immutability.
@@ -9,11 +9,7 @@ The `spring-web` module provides some useful filters:
 * xref:web/webmvc/filters.adoc#filters-forwarded-headers[Forwarded Headers]
 * xref:web/webmvc/filters.adoc#filters-shallow-etag[Shallow ETag]
 * xref:web/webmvc/filters.adoc#filters-cors[CORS]
-* xref:web/webmvc/filters.adoc#filters.url-handler[URL Handler]

-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]]
@@ -30,7 +26,7 @@ available through the `ServletRequest.getParameter{asterisk}()` family of method



-[[filters-forwarded-headers]]
+[[forwarded-headers]]
 == Forwarded Headers
 [.small]#xref:web/webflux/reactive-spring.adoc#webflux-forwarded-headers[See equivalent in the Reactive stack]#

@@ -113,22 +109,4 @@ See the sections on xref:web/webmvc-cors.adoc[CORS] and the xref:web/webmvc-cors



-[[filters.url-handler]]
-== URL Handler
-[.small]#xref:web/webflux/reactive-spring.adoc#filters.url-handler[See equivalent in the Reactive stack]#
-
-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")`.
-
-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 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]

@@ -4,8 +4,7 @@
 [.small]#xref:web/webflux/config.adoc#webflux-config-conversion[See equivalent in the Reactive stack]#

 By default, formatters for various number and date types are installed, along with support
-for customization via `@NumberFormat`, `@DurationFormat`, and `@DateTimeFormat` on fields
-and parameters.
+for customization via `@NumberFormat`, `@DurationFormat` and `@DateTimeFormat` on fields.

 To register custom formatters and converters, use the following:

@@ -35,6 +35,7 @@ This builder customizes Jackson's default properties as follows:

 It also automatically registers the following well-known modules if they are detected on the classpath:

+* {jackson-github-org}/jackson-datatype-joda[jackson-datatype-joda]: Support for Joda-Time types.
 * {jackson-github-org}/jackson-datatype-jsr310[jackson-datatype-jsr310]: Support for Java 8 Date and Time API types.
 * {jackson-github-org}/jackson-datatype-jdk8[jackson-datatype-jdk8]: Support for other Java 8 types, such as `Optional`.
 * {jackson-github-org}/jackson-module-kotlin[jackson-module-kotlin]: Support for Kotlin classes and data classes.
@@ -1,7 +1,6 @@
 [[websocket]]
 = WebSockets
 :page-section-summary-toc: 1
-
 [.small]#xref:web/webflux-websocket.adoc[See equivalent in the Reactive stack]#

 This part of the reference documentation covers support for Servlet stack, WebSocket
@@ -45,7 +45,7 @@ input is ignored. This is in contrast to property binding which by default binds
 request parameter for which there is a matching property.

 If neither a dedicated model object nor constructor binding is sufficient, and you must
-use property binding, we strongly recommend registering `allowedFields` patterns (case
+use property binding, we strongy recommend registering `allowedFields` patterns (case
 sensitive) on `WebDataBinder` in order to prevent unexpected properties from being set.
 For example:

@@ -1,34 +0,0 @@
-/*
- * Copyright 2002-2024 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.docs.web.webflux.filters.urlhandler;
-
-import org.springframework.http.HttpStatus;
-import org.springframework.web.filter.reactive.UrlHandlerFilter;
-
-public class UrlHandlerFilterConfiguration {
-
-	public void configureUrlHandlerFilter() {
-		// tag::config[]
-		UrlHandlerFilter urlHandlerFilter = UrlHandlerFilter
-				// will HTTP 308 redirect "/blog/my-blog-post/" -> "/blog/my-blog-post"
-				.trailingSlashHandler("/blog/**").redirect(HttpStatus.PERMANENT_REDIRECT)
-				// will mutate the request to "/admin/user/account/" and make it as "/admin/user/account"
-				.trailingSlashHandler("/admin/**").mutateRequest()
-				.build();
-		// end::config[]
-	}
-}
@@ -1,34 +0,0 @@
-/*
- * Copyright 2002-2024 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.docs.web.webmvc.filters.urlhandler;
-
-import org.springframework.http.HttpStatus;
-import org.springframework.web.filter.UrlHandlerFilter;
-
-public class UrlHandlerFilterConfiguration {
-
-	public void configureUrlHandlerFilter() {
-		// tag::config[]
-		UrlHandlerFilter urlHandlerFilter = UrlHandlerFilter
-				// will HTTP 308 redirect "/blog/my-blog-post/" -> "/blog/my-blog-post"
-				.trailingSlashHandler("/blog/**").redirect(HttpStatus.PERMANENT_REDIRECT)
-				// will wrap the request to "/admin/user/account/" and make it as "/admin/user/account"
-				.trailingSlashHandler("/admin/**").wrapRequest()
-				.build();
-		// end::config[]
-	}
-}
@@ -1,35 +0,0 @@
-/*
- * Copyright 2002-2024 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.docs.web.webflux.filters.urlhandler
-
-import org.springframework.http.HttpStatus
-import org.springframework.web.filter.reactive.UrlHandlerFilter
-
-class UrlHandlerFilterConfiguration {
-
-	@Suppress("UNUSED_VARIABLE")
-	fun configureUrlHandlerFilter() {
-		// tag::config[]
-		val urlHandlerFilter = UrlHandlerFilter
-			// will HTTP 308 redirect "/blog/my-blog-post/" -> "/blog/my-blog-post"
-			.trailingSlashHandler("/blog/**").redirect(HttpStatus.PERMANENT_REDIRECT)
-			// will mutate the request to "/admin/user/account/" and make it as "/admin/user/account"
-			.trailingSlashHandler("/admin/**").mutateRequest()
-			.build()
-		// end::config[]
-	}
-}
@@ -1,35 +0,0 @@
-/*
- * Copyright 2002-2024 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.docs.web.webmvc.filters.urlhandler
-
-import org.springframework.http.HttpStatus
-import org.springframework.web.filter.UrlHandlerFilter
-
-class UrlHandlerFilterConfiguration {
-
-	@Suppress("UNUSED_VARIABLE")
-	fun configureUrlHandlerFilter() {
-		// tag::config[]
-		val urlHandlerFilter = UrlHandlerFilter
-				// will HTTP 308 redirect "/blog/my-blog-post/" -> "/blog/my-blog-post"
-				.trailingSlashHandler("/blog/**").redirect(HttpStatus.PERMANENT_REDIRECT)
-				// will wrap the request to "/admin/user/account/" and make it as "/admin/user/account"
-				.trailingSlashHandler("/admin/**").wrapRequest()
-				.build()
-		// end::config[]
-	}
-}
@@ -7,32 +7,32 @@ javaPlatform {
 }

 dependencies {
-	api(platform("com.fasterxml.jackson:jackson-bom:2.18.2"))
-	api(platform("io.micrometer:micrometer-bom:1.14.3"))
-	api(platform("io.netty:netty-bom:4.1.117.Final"))
+	api(platform("com.fasterxml.jackson:jackson-bom:2.18.0"))
+	api(platform("io.micrometer:micrometer-bom:1.14.0-RC1"))
+	api(platform("io.netty:netty-bom:4.1.113.Final"))
 	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2024.0.2"))
-	api(platform("io.rsocket:rsocket-bom:1.1.4"))
-	api(platform("org.apache.groovy:groovy-bom:4.0.24"))
+	api(platform("io.projectreactor:reactor-bom:2024.0.0-RC1"))
+	api(platform("io.rsocket:rsocket-bom:1.1.3"))
+	api(platform("org.apache.groovy:groovy-bom:4.0.23"))
 	api(platform("org.apache.logging.log4j:log4j-bom:2.21.1"))
-	api(platform("org.assertj:assertj-bom:3.27.2"))
-	api(platform("org.eclipse.jetty:jetty-bom:12.0.16"))
-	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.16"))
+	api(platform("org.assertj:assertj-bom:3.26.3"))
+	api(platform("org.eclipse.jetty:jetty-bom:12.0.13"))
+	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.13"))
 	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.11.4"))
-	api(platform("org.mockito:mockito-bom:5.15.2"))
+	api(platform("org.junit:junit-bom:5.11.3"))
+	api(platform("org.mockito:mockito-bom:5.14.1"))

 	constraints {
 		api("com.fasterxml:aalto-xml:1.3.2")
-		api("com.fasterxml.woodstox:woodstox-core:6.7.0")
+		api("com.fasterxml.woodstox:woodstox-core:6.6.2")
 		api("com.github.ben-manes.caffeine:caffeine:3.1.8")
 		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.11.0")
-		api("com.google.protobuf:protobuf-java-util:4.29.3")
-		api("com.h2database:h2:2.3.232")
+		api("com.google.code.gson:gson:2.10.1")
+		api("com.google.protobuf:protobuf-java-util:4.27.1")
+		api("com.h2database:h2:2.2.224")
 		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")
@@ -44,7 +44,7 @@ dependencies {
 		api("com.sun.xml.bind:jaxb-impl:3.0.2")
 		api("com.sun.xml.bind:jaxb-xjc:3.0.2")
 		api("com.thoughtworks.qdox:qdox:2.1.0")
-		api("com.thoughtworks.xstream:xstream:1.4.21")
+		api("com.thoughtworks.xstream:xstream:1.4.20")
 		api("commons-io:commons-io:2.15.0")
 		api("de.bechte.junit:junit-hierarchicalcontextrunner:4.12.2")
 		api("io.micrometer:context-propagation:1.1.1")
@@ -54,11 +54,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.10")
+		api("io.reactivex.rxjava3:rxjava:3.1.8")
 		api("io.smallrye.reactive:mutiny:1.10.0")
-		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.undertow:undertow-core:2.3.17.Final")
+		api("io.undertow:undertow-servlet:2.3.17.Final")
+		api("io.undertow:undertow-websockets-jsr:2.3.17.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")
@@ -100,8 +100,8 @@ dependencies {
 		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.4.1")
-		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.3.1")
+		api("org.apache.httpcomponents.client5:httpclient5:5.4")
+		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.3")
 		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")
@@ -116,7 +116,7 @@ dependencies {
 		api("org.crac:crac:1.4.0")
 		api("org.dom4j:dom4j:2.1.4")
 		api("org.easymock:easymock:5.4.0")
-		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.8")
+		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.7")
 		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,25 +129,25 @@ dependencies {
 		api("org.hamcrest:hamcrest:2.2")
 		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.6.0")
+		api("org.hsqldb:hsqldb:2.7.2")
+		api("org.htmlunit:htmlunit:4.2.0")
 		api("org.javamoney:moneta:1.4.4")
-		api("org.jruby:jruby:9.4.9.0")
+		api("org.jruby:jruby:9.4.8.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.3")
 		api("org.quartz-scheduler:quartz:2.3.2")
-		api("org.seleniumhq.selenium:htmlunit3-driver:4.26.0")
-		api("org.seleniumhq.selenium:selenium-java:4.26.0")
+		api("org.seleniumhq.selenium:htmlunit3-driver:4.20.0")
+		api("org.seleniumhq.selenium:selenium-java:4.20.0")
 		api("org.skyscreamer:jsonassert:1.5.3")
 		api("org.slf4j:slf4j-api:2.0.16")
-		api("org.testng:testng:7.10.2")
+		api("org.testng:testng:7.9.0")
 		api("org.webjars:underscorejs:1.8.3")
 		api("org.webjars:webjars-locator-core:0.55")
 		api("org.webjars:webjars-locator-lite:1.0.0")
-		api("org.xmlunit:xmlunit-assertj:2.10.0")
-		api("org.xmlunit:xmlunit-matchers:2.10.0")
-		api("org.yaml:snakeyaml:2.3")
+		api("org.xmlunit:xmlunit-assertj:2.9.1")
+		api("org.xmlunit:xmlunit-matchers:2.9.1")
+		api("org.yaml:snakeyaml:2.2")
 	}
 }
@@ -1,4 +1,4 @@
-version=6.2.2
+version=6.2.0-RC3

 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m
@@ -55,9 +55,8 @@ plugins.withType(JavaPlugin).configureEach {
 				languageVersion = testLanguageVersion
 			}
 			// Enable Java experimental support in Bytebuddy
-			// Bytebuddy 1.15.4 supports JDK <= 24
-			// see https://github.com/raphw/byte-buddy/blob/master/release-notes.md
-			if (testLanguageVersion.compareTo(JavaLanguageVersion.of(24)) > 0 ) {
+			// Remove when JDK 22 is supported by Mockito
+			if (testLanguageVersion == JavaLanguageVersion.of(22)) {
 				jvmArgs("-Dnet.bytebuddy.experimental=true")
 			}
 		}
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
@@ -86,7 +86,8 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit

 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -56,33 +56,33 @@ import kotlin.annotation.AnnotationTarget.TYPE
@SpringJUnitConfig(InterceptorConfig::class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
 class AspectJAutoProxyInterceptorKotlinIntegrationTests(
-	@Autowired val echo: Echo,
-	@Autowired val firstAdvisor: TestPointcutAdvisor,
-	@Autowired val secondAdvisor: TestPointcutAdvisor,
-	@Autowired val countingAspect: CountingAspect,
-	@Autowired val reactiveTransactionManager: ReactiveCallCountingTransactionManager) {
+    @Autowired val echo: Echo,
+    @Autowired val firstAdvisor: TestPointcutAdvisor,
+    @Autowired val secondAdvisor: TestPointcutAdvisor,
+    @Autowired val countingAspect: CountingAspect,
+    @Autowired val reactiveTransactionManager: ReactiveCallCountingTransactionManager) {

-	@Test
-	fun `Multiple interceptors with regular function`() {
-		assertThat(firstAdvisor.interceptor.invocations).isEmpty()
-		assertThat(secondAdvisor.interceptor.invocations).isEmpty()
-		val value = "Hello!"
-		assertThat(echo.echo(value)).isEqualTo(value)
+    @Test
+    fun `Multiple interceptors with regular function`() {
+        assertThat(firstAdvisor.interceptor.invocations).isEmpty()
+        assertThat(secondAdvisor.interceptor.invocations).isEmpty()
+        val value = "Hello!"
+        assertThat(echo.echo(value)).isEqualTo(value)
 		assertThat(firstAdvisor.interceptor.invocations).singleElement().matches { String::class.java.isAssignableFrom(it) }
 		assertThat(secondAdvisor.interceptor.invocations).singleElement().matches { String::class.java.isAssignableFrom(it) }
-	}
+    }

-	@Test
-	fun `Multiple interceptors with suspending function`() {
-		assertThat(firstAdvisor.interceptor.invocations).isEmpty()
-		assertThat(secondAdvisor.interceptor.invocations).isEmpty()
-		val value = "Hello!"
-		runBlocking {
-			assertThat(echo.suspendingEcho(value)).isEqualTo(value)
-		}
+    @Test
+    fun `Multiple interceptors with suspending function`() {
+        assertThat(firstAdvisor.interceptor.invocations).isEmpty()
+        assertThat(secondAdvisor.interceptor.invocations).isEmpty()
+        val value = "Hello!"
+        runBlocking {
+            assertThat(echo.suspendingEcho(value)).isEqualTo(value)
+        }
 		assertThat(firstAdvisor.interceptor.invocations).singleElement().matches { Mono::class.java.isAssignableFrom(it) }
 		assertThat(secondAdvisor.interceptor.invocations).singleElement().matches { Mono::class.java.isAssignableFrom(it) }
-	}
+    }

 	@Test // gh-33095
 	fun `Aspect and reactive transactional with suspending function`() {
@@ -113,17 +113,17 @@ class AspectJAutoProxyInterceptorKotlinIntegrationTests(
 		assertThat(countingAspect.counter).`as`("aspect applied once per key").isEqualTo(2)
 	}

-	@Configuration
-	@EnableAspectJAutoProxy
-	@EnableTransactionManagement
+    @Configuration
+    @EnableAspectJAutoProxy
+    @EnableTransactionManagement
 	@EnableCaching
-	open class InterceptorConfig {
+    open class InterceptorConfig {

-		@Bean
-		open fun firstAdvisor() = TestPointcutAdvisor().apply { order = 0 }
+        @Bean
+        open fun firstAdvisor() = TestPointcutAdvisor().apply { order = 0 }

-		@Bean
-		open fun secondAdvisor() = TestPointcutAdvisor().apply { order = 1 }
+        @Bean
+        open fun secondAdvisor() = TestPointcutAdvisor().apply { order = 1 }

 		@Bean
 		open fun countingAspect() = CountingAspect()
@@ -138,34 +138,34 @@ class AspectJAutoProxyInterceptorKotlinIntegrationTests(
 			return ConcurrentMapCacheManager()
 		}

-		@Bean
-		open fun echo(): Echo {
-			return Echo()
-		}
-	}
+        @Bean
+        open fun echo(): Echo {
+            return Echo()
+        }
+    }

-	class TestMethodInterceptor: MethodInterceptor {
+    class TestMethodInterceptor: MethodInterceptor {

-		var invocations: MutableList<Class<*>> = mutableListOf()
+        var invocations: MutableList<Class<*>> = mutableListOf()

-		@Suppress("RedundantNullableReturnType")
-		override fun invoke(invocation: MethodInvocation): Any? {
-			val result = invocation.proceed()
-			invocations.add(result!!.javaClass)
-			return result
-		}
+        @Suppress("RedundantNullableReturnType")
+        override fun invoke(invocation: MethodInvocation): Any? {
+            val result = invocation.proceed()
+            invocations.add(result!!.javaClass)
+            return result
+        }

-	}
+    }

-	class TestPointcutAdvisor : StaticMethodMatcherPointcutAdvisor(TestMethodInterceptor()) {
+    class TestPointcutAdvisor : StaticMethodMatcherPointcutAdvisor(TestMethodInterceptor()) {

-		val interceptor: TestMethodInterceptor
-			get() = advice as TestMethodInterceptor
+        val interceptor: TestMethodInterceptor
+            get() = advice as TestMethodInterceptor

-		override fun matches(method: Method, targetClass: Class<*>): Boolean {
-			return targetClass == Echo::class.java && method.name.lowercase().endsWith("echo")
-		}
-	}
+        override fun matches(method: Method, targetClass: Class<*>): Boolean {
+            return targetClass == Echo::class.java && method.name.lowercase().endsWith("echo")
+        }
+    }

 	@Target(CLASS, FUNCTION, ANNOTATION_CLASS, TYPE)
 	@Retention(AnnotationRetention.RUNTIME)
@@ -185,16 +185,16 @@ class AspectJAutoProxyInterceptorKotlinIntegrationTests(
 		}
 	}

-	open class Echo {
+    open class Echo {

-		open fun echo(value: String): String {
-			return value
-		}
+        open fun echo(value: String): String {
+            return value
+        }

-		open suspend fun suspendingEcho(value: String): String {
-			delay(1)
-			return value
-		}
+        open suspend fun suspendingEcho(value: String): String {
+            delay(1)
+            return value
+        }

 		@Transactional
 		@Counting
@@ -212,6 +212,6 @@ class AspectJAutoProxyInterceptorKotlinIntegrationTests(
 			return "$value ${cacheCounter++}"
 		}

-	}
+    }

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2008 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.
@@ -27,11 +27,11 @@ package org.springframework.aop;
 * <p>Some examples of valid methods would be:
 *
 * <pre class="code">public void afterThrowing(Exception ex)</pre>
- * <pre class="code">public void afterThrowing(RemoteException ex)</pre>
+ * <pre class="code">public void afterThrowing(RemoteException)</pre>
 * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, Exception ex)</pre>
 * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)</pre>
 *
- * <p>The first three arguments are optional, and only useful if we want further
+ * The first three arguments are optional, and only useful if we want further
 * information about the joinpoint, as in AspectJ <b>after-throwing</b> advice.
 *
 * <p><b>Note:</b> If a throws-advice method throws an exception itself, it will
@@ -18,7 +18,6 @@ package org.springframework.aop.aspectj.annotation;

 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Map;
 import java.util.StringTokenizer;
@@ -38,7 +37,6 @@ import org.aspectj.lang.reflect.PerClauseKind;

 import org.springframework.aop.framework.AopConfigException;
 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.core.SpringProperties;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.lang.Nullable;

@@ -60,23 +58,6 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[] {
 			Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};

-	private static final String AJC_MAGIC = "ajc$";
-
-	/**
-	 * System property that instructs Spring to ignore ajc-compiled aspects
-	 * for Spring AOP proxying, restoring traditional Spring behavior for
-	 * scenarios where both weaving and AspectJ auto-proxying are enabled.
-	 * <p>The default is "false". Consider switching this to "true" if you
-	 * encounter double execution of your aspects in a given build setup.
-	 * Note that we recommend restructuring your AspectJ configuration to
-	 * avoid such double exposure of an AspectJ aspect to begin with.
-	 * @since 6.1.15
-	 */
-	public static final String IGNORE_AJC_PROPERTY_NAME = "spring.aop.ajc.ignore";
-
-	private static final boolean shouldIgnoreAjcCompiledAspects =
-			SpringProperties.getFlag(IGNORE_AJC_PROPERTY_NAME);
-

 	/** Logger available to subclasses. */
 	protected final Log logger = LogFactory.getLog(getClass());
@@ -86,8 +67,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac

 	@Override
 	public boolean isAspect(Class<?> clazz) {
-		return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null &&
-				(!shouldIgnoreAjcCompiledAspects || !compiledByAjc(clazz)));
+		return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
 	}

 	@Override
@@ -134,15 +114,6 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		}
 	}

-	private static boolean compiledByAjc(Class<?> clazz) {
-		for (Field field : clazz.getDeclaredFields()) {
-			if (field.getName().startsWith(AJC_MAGIC)) {
-				return true;
-			}
-		}
-		return false;
-	}
-

 	/**
 	 * Enum for AspectJ annotation types.
@@ -668,8 +668,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {

 		@Override
 		public boolean equals(@Nullable Object other) {
-			return (this == other || (other instanceof MethodCacheKey that &&
-					(this.method == that.method || this.method.equals(that.method))));
+			return (this == other || (other instanceof MethodCacheKey that && this.method == that.method));
 		}

 		@Override
@@ -60,12 +60,11 @@ public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
 	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
 		if (config.isOptimize() || config.isProxyTargetClass() || !config.hasUserSuppliedInterfaces()) {
 			Class<?> targetClass = config.getTargetClass();
-			if (targetClass == null && config.getProxiedInterfaces().length == 0) {
+			if (targetClass == null) {
 				throw new AopConfigException("TargetSource cannot determine target class: " +
 						"Either an interface or a target is required for proxy creation.");
 			}
-			if (targetClass == null || targetClass.isInterface() ||
-					Proxy.isProxyClass(targetClass) || ClassUtils.isLambdaClass(targetClass)) {
+			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || ClassUtils.isLambdaClass(targetClass)) {
 				return new JdkDynamicAopProxy(config);
 			}
 			return new ObjenesisCglibAopProxy(config);
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -281,8 +281,8 @@ public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
 	 * @param returnType the declared return type (potentially a {@link Future} variant)
 	 * @return the execution result (potentially a corresponding {@link Future} handle)
 	 */
-	@SuppressWarnings("removal")
 	@Nullable
+	@SuppressWarnings("deprecation")
 	protected Object doSubmit(Callable<Object> task, AsyncTaskExecutor executor, Class<?> returnType) {
 		if (CompletableFuture.class.isAssignableFrom(returnType)) {
 			return executor.submitCompletable(task);
@@ -1,42 +0,0 @@
-/*
- * Copyright 2002-2024 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.aop.framework;
-
-import org.junit.jupiter.api.BeforeEach;
-
-import org.springframework.cglib.proxy.Enhancer;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author Mikaël Francoeur
- * @since 6.2
- * @see JdkProxyExceptionHandlingTests
- */
-class CglibProxyExceptionHandlingTests extends AbstractProxyExceptionHandlingTests {
-
-	@BeforeEach
-	void setup() {
-		proxyFactory.setProxyTargetClass(true);
-	}
-
-	@Override
-	protected void assertProxyType(Object proxy) {
-		assertThat(Enhancer.isEnhanced(proxy.getClass())).isTrue();
-	}
-
-}
@@ -1,35 +0,0 @@
-/*
- * Copyright 2002-2024 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.aop.framework;
-
-import java.lang.reflect.Proxy;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author Mikaël Francoeur
- * @since 6.2
- * @see CglibProxyExceptionHandlingTests
- */
-class JdkProxyExceptionHandlingTests extends AbstractProxyExceptionHandlingTests {
-
-	@Override
-	protected void assertProxyType(Object proxy) {
-		assertThat(Proxy.isProxyClass(proxy.getClass())).isTrue();
-	}
-
-}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,32 +16,30 @@

 package org.springframework.aop.framework;

+import java.lang.reflect.Proxy;
 import java.lang.reflect.UndeclaredThrowableException;
 import java.util.Objects;

 import org.aopalliance.intercept.MethodInterceptor;
+import org.assertj.core.api.WithAssertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import org.mockito.stubbing.Answer;

+import org.springframework.cglib.proxy.Enhancer;
 import org.springframework.lang.Nullable;

-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.catchThrowable;
-import static org.mockito.BDDMockito.willAnswer;
-import static org.mockito.BDDMockito.willThrow;
-import static org.mockito.Mockito.mock;
+import static org.mockito.BDDMockito.doAnswer;
+import static org.mockito.BDDMockito.doThrow;
+import static org.mockito.BDDMockito.mock;

 /**
 * @author Mikaël Francoeur
- * @author Sam Brannen
 * @since 6.2
- * @see JdkProxyExceptionHandlingTests
- * @see CglibProxyExceptionHandlingTests
 */
-abstract class AbstractProxyExceptionHandlingTests {
+abstract class ProxyExceptionHandlingTests implements WithAssertions {

 	private static final RuntimeException uncheckedException = new RuntimeException();

@@ -49,12 +47,14 @@ abstract class AbstractProxyExceptionHandlingTests {

 	private static final UndeclaredCheckedException undeclaredCheckedException = new UndeclaredCheckedException();

-	protected final MyClass target = mock();
+	protected final MyClass target = mock(MyClass.class);

 	protected final ProxyFactory proxyFactory = new ProxyFactory(target);

+	@Nullable
 	protected MyInterface proxy;

+	@Nullable
 	private Throwable throwableSeenByCaller;


@@ -63,24 +63,46 @@ abstract class AbstractProxyExceptionHandlingTests {
 		Mockito.clearInvocations(target);
 	}

-
-	protected abstract void assertProxyType(Object proxy);
-
+	protected void assertProxyType(Object proxy) {
+	}

 	private void invokeProxy() {
 		throwableSeenByCaller = catchThrowable(() -> Objects.requireNonNull(proxy).doSomething());
 	}

 	@SuppressWarnings("SameParameterValue")
-	private static Answer<?> sneakyThrow(Throwable throwable) {
+	private Answer<?> sneakyThrow(Throwable throwable) {
 		return invocation -> {
 			throw throwable;
 		};
 	}


+	static class JdkAopProxyTests extends ProxyExceptionHandlingTests {
+
+		@Override
+		protected void assertProxyType(Object proxy) {
+			assertThat(Proxy.isProxyClass(proxy.getClass())).isTrue();
+		}
+	}
+
+
+	static class CglibAopProxyTests extends ProxyExceptionHandlingTests {
+
+		@BeforeEach
+		void setup() {
+			proxyFactory.setProxyTargetClass(true);
+		}
+
+		@Override
+		protected void assertProxyType(Object proxy) {
+			assertThat(Enhancer.isEnhanced(proxy.getClass())).isTrue();
+		}
+	}
+
+
 	@Nested
-	class WhenThereIsOneInterceptorTests {
+	class WhenThereIsOneInterceptor {

 		@Nullable
 		private Throwable throwableSeenByInterceptor;
@@ -88,23 +110,23 @@ abstract class AbstractProxyExceptionHandlingTests {
 		@BeforeEach
 		void beforeEach() {
 			proxyFactory.addAdvice(captureThrowable());
-			proxy = (MyInterface) proxyFactory.getProxy(getClass().getClassLoader());
+			proxy = (MyInterface) proxyFactory.getProxy(ProxyExceptionHandlingTests.class.getClassLoader());
 			assertProxyType(proxy);
 		}

 		@Test
 		void targetThrowsUndeclaredCheckedException() throws DeclaredCheckedException {
-			willAnswer(sneakyThrow(undeclaredCheckedException)).given(target).doSomething();
+			doAnswer(sneakyThrow(undeclaredCheckedException)).when(target).doSomething();
 			invokeProxy();
 			assertThat(throwableSeenByInterceptor).isSameAs(undeclaredCheckedException);
 			assertThat(throwableSeenByCaller)
 					.isInstanceOf(UndeclaredThrowableException.class)
-					.cause().isSameAs(undeclaredCheckedException);
+					.hasCauseReference(undeclaredCheckedException);
 		}

 		@Test
 		void targetThrowsDeclaredCheckedException() throws DeclaredCheckedException {
-			willThrow(declaredCheckedException).given(target).doSomething();
+			doThrow(declaredCheckedException).when(target).doSomething();
 			invokeProxy();
 			assertThat(throwableSeenByInterceptor).isSameAs(declaredCheckedException);
 			assertThat(throwableSeenByCaller).isSameAs(declaredCheckedException);
@@ -112,7 +134,7 @@ abstract class AbstractProxyExceptionHandlingTests {

 		@Test
 		void targetThrowsUncheckedException() throws DeclaredCheckedException {
-			willThrow(uncheckedException).given(target).doSomething();
+			doThrow(uncheckedException).when(target).doSomething();
 			invokeProxy();
 			assertThat(throwableSeenByInterceptor).isSameAs(uncheckedException);
 			assertThat(throwableSeenByCaller).isSameAs(uncheckedException);
@@ -133,40 +155,40 @@ abstract class AbstractProxyExceptionHandlingTests {


 	@Nested
-	class WhenThereAreNoInterceptorsTests {
+	class WhenThereAreNoInterceptors {

 		@BeforeEach
 		void beforeEach() {
-			proxy = (MyInterface) proxyFactory.getProxy(getClass().getClassLoader());
+			proxy = (MyInterface) proxyFactory.getProxy(ProxyExceptionHandlingTests.class.getClassLoader());
 			assertProxyType(proxy);
 		}

 		@Test
 		void targetThrowsUndeclaredCheckedException() throws DeclaredCheckedException {
-			willAnswer(sneakyThrow(undeclaredCheckedException)).given(target).doSomething();
+			doAnswer(sneakyThrow(undeclaredCheckedException)).when(target).doSomething();
 			invokeProxy();
 			assertThat(throwableSeenByCaller)
 					.isInstanceOf(UndeclaredThrowableException.class)
-					.cause().isSameAs(undeclaredCheckedException);
+					.hasCauseReference(undeclaredCheckedException);
 		}

 		@Test
 		void targetThrowsDeclaredCheckedException() throws DeclaredCheckedException {
-			willThrow(declaredCheckedException).given(target).doSomething();
+			doThrow(declaredCheckedException).when(target).doSomething();
 			invokeProxy();
 			assertThat(throwableSeenByCaller).isSameAs(declaredCheckedException);
 		}

 		@Test
 		void targetThrowsUncheckedException() throws DeclaredCheckedException {
-			willThrow(uncheckedException).given(target).doSomething();
+			doThrow(uncheckedException).when(target).doSomething();
 			invokeProxy();
 			assertThat(throwableSeenByCaller).isSameAs(uncheckedException);
 		}
 	}


-	interface MyInterface {
+	protected interface MyInterface {

 		void doSomething() throws DeclaredCheckedException;
 	}
@@ -180,11 +202,11 @@ abstract class AbstractProxyExceptionHandlingTests {
 	}

 	@SuppressWarnings("serial")
-	private static class UndeclaredCheckedException extends Exception {
+	protected static class UndeclaredCheckedException extends Exception {
 	}

 	@SuppressWarnings("serial")
-	private static class DeclaredCheckedException extends Exception {
+	protected static class DeclaredCheckedException extends Exception {
 	}

 }
@@ -340,18 +340,6 @@ class ProxyFactoryTests {
 		assertThat(AopProxyUtils.ultimateTargetClass(proxy)).isEqualTo(MyDate.class);
 	}

-	@Test
-	void proxyInterfaceInCaseOfIntroducedInterfaceOnly() {
-		ProxyFactory pf = new ProxyFactory();
-		pf.addInterface(TimeStamped.class);
-		TimestampIntroductionInterceptor ti = new TimestampIntroductionInterceptor(0L);
-		pf.addAdvisor(new DefaultIntroductionAdvisor(ti, TimeStamped.class));
-		Object proxy = pf.getProxy();
-		assertThat(AopUtils.isJdkDynamicProxy(proxy)).as("Proxy is a JDK proxy").isTrue();
-		assertThat(proxy).isInstanceOf(TimeStamped.class);
-		assertThat(AopProxyUtils.ultimateTargetClass(proxy)).isEqualTo(proxy.getClass());
-	}
-
 	@Test
 	void proxyInterfaceInCaseOfNonTargetInterface() {
 		ProxyFactory pf = new ProxyFactory();
@@ -31,17 +31,17 @@ import kotlin.coroutines.Continuation
 */
 class AopUtilsKotlinTests {

-	@Test
-	fun `Invoking suspending function should return Mono`() {
-		val value = "foo"
-		val method = ReflectionUtils.findMethod(WithoutInterface::class.java, "handle",
+    @Test
+    fun `Invoking suspending function should return Mono`() {
+        val value = "foo"
+        val method = ReflectionUtils.findMethod(WithoutInterface::class.java, "handle",
 			String::class. java, Continuation::class.java)!!
-		val continuation = Continuation<Any>(CoroutineName("test")) { }
+        val continuation = Continuation<Any>(CoroutineName("test")) { }
 		val result = AopUtils.invokeJoinpointUsingReflection(WithoutInterface(), method, arrayOf(value, continuation))
-		assertThat(result).isInstanceOfSatisfying(Mono::class.java) {
-			assertThat(it.block()).isEqualTo(value)
-		}
-	}
+        assertThat(result).isInstanceOfSatisfying(Mono::class.java) {
+            assertThat(it.block()).isEqualTo(value)
+        }
+    }

 	@Test
 	fun `Invoking suspending function on bridged method should return Mono`() {
@@ -54,11 +54,11 @@ class AopUtilsKotlinTests {
 		}
 	}

-	@Suppress("unused")
-	suspend fun suspendingFunction(value: String): String {
-		delay(1)
-		return value
-	}
+    @Suppress("unused")
+    suspend fun suspendingFunction(value: String): String {
+        delay(1)
+        return value
+    }

 	class WithoutInterface {
 		suspend fun handle(value: String): String {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2016 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -28,10 +28,10 @@ import org.springframework.scheduling.annotation.Async;
 * <p>This aspect routes methods marked with the {@link Async} annotation as well as methods
 * in classes marked with the same. Any method expected to be routed asynchronously must
 * return either {@code void}, {@link Future}, or a subtype of {@link Future} (in particular,
- * {@link java.util.concurrent.CompletableFuture}). This aspect, therefore, will produce a
- * compile-time error for methods that violate this constraint on the return type. If,
- * however, a class marked with {@code @Async} contains a method that violates this
- * constraint, it produces only a warning.
+ * Spring's {@link org.springframework.util.concurrent.ListenableFuture}). This aspect,
+ * therefore, will produce a compile-time error for methods that violate this constraint
+ * on the return type. If, however, a class marked with {@code @Async} contains a method
+ * that violates this constraint, it produces only a warning.
 *
 * <p>This aspect needs to be injected with an implementation of a task-oriented
 * {@link java.util.concurrent.Executor} to activate it for a specific thread pool,
@@ -32,8 +32,6 @@ import org.springframework.lang.Nullable;
 * <p>In a {@link BeanFactory} environment, every {@code ObjectProvider} obtained
 * from the factory will be bound to its {@code BeanFactory} for a specific bean
 * type, matching all provider calls against factory-registered bean definitions.
- * Note that all such calls dynamically operate on the underlying factory state,
- * freshly resolving the requested target object on every call.
 *
 * <p>As of 5.1, this interface extends {@link Iterable} and provides {@link Stream}
 * support. It can be therefore be used in {@code for} loops, provides {@link #forEach}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -95,7 +95,7 @@ public abstract class BeanFactoryAnnotationUtils {
 			// Full qualifier matching supported.
 			return qualifiedBeanOfType(lbf, beanType, qualifier);
 		}
-		else if (beanFactory.containsBean(qualifier) && beanFactory.isTypeMatch(qualifier, beanType)) {
+		else if (beanFactory.containsBean(qualifier)) {
 			// Fallback: target bean at least found by bean name.
 			return beanFactory.getBean(qualifier, beanType);
 		}
@@ -110,16 +110,16 @@ public abstract class BeanFactoryAnnotationUtils {
 	/**
 	 * Obtain a bean of type {@code T} from the given {@code BeanFactory} declaring a qualifier
 	 * (for example, {@code <qualifier>} or {@code @Qualifier}) matching the given qualifier).
-	 * @param beanFactory the factory to get the target bean from
+	 * @param bf the factory to get the target bean from
 	 * @param beanType the type of bean to retrieve
 	 * @param qualifier the qualifier for selecting between multiple bean matches
 	 * @return the matching bean of type {@code T} (never {@code null})
 	 */
-	private static <T> T qualifiedBeanOfType(ListableBeanFactory beanFactory, Class<T> beanType, String qualifier) {
-		String[] candidateBeans = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, beanType);
+	private static <T> T qualifiedBeanOfType(ListableBeanFactory bf, Class<T> beanType, String qualifier) {
+		String[] candidateBeans = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(bf, beanType);
 		String matchingBean = null;
 		for (String beanName : candidateBeans) {
-			if (isQualifierMatch(qualifier::equals, beanName, beanFactory)) {
+			if (isQualifierMatch(qualifier::equals, beanName, bf)) {
 				if (matchingBean != null) {
 					throw new NoUniqueBeanDefinitionException(beanType, matchingBean, beanName);
 				}
@@ -127,11 +127,11 @@ public abstract class BeanFactoryAnnotationUtils {
 			}
 		}
 		if (matchingBean != null) {
-			return beanFactory.getBean(matchingBean, beanType);
+			return bf.getBean(matchingBean, beanType);
 		}
-		else if (beanFactory.containsBean(qualifier) && beanFactory.isTypeMatch(qualifier, beanType)) {
+		else if (bf.containsBean(qualifier)) {
 			// Fallback: target bean at least found by bean name - probably a manually registered singleton.
-			return beanFactory.getBean(qualifier, beanType);
+			return bf.getBean(qualifier, beanType);
 		}
 		else {
 			throw new NoSuchBeanDefinitionException(qualifier, "No matching " + beanType.getSimpleName() +
@@ -123,7 +123,7 @@ class DefaultBeanRegistrationCodeFragments implements BeanRegistrationCodeFragme

 		CodeBlock.Builder code = CodeBlock.builder();
 		RootBeanDefinition mbd = this.registeredBean.getMergedBeanDefinition();
-		Class<?> beanClass = (mbd.hasBeanClass() ? ClassUtils.getUserClass(mbd.getBeanClass()) : null);
+		Class<?> beanClass = (mbd.hasBeanClass() ? mbd.getBeanClass() : null);
 		CodeBlock beanClassCode = generateBeanClassCode(
 				beanRegistrationCode.getClassName().packageName(),
 				(beanClass != null ? beanClass : beanType.toClass()));
@@ -156,96 +156,91 @@ public class InstanceSupplierCodeGenerator {
 	}

 	private CodeBlock generateCodeForConstructor(RegisteredBean registeredBean, Constructor<?> constructor) {
-		ConstructorDescriptor descriptor = new ConstructorDescriptor(
-				registeredBean.getBeanName(), constructor, registeredBean.getBeanClass());
+		String beanName = registeredBean.getBeanName();
+		Class<?> beanClass = registeredBean.getBeanClass();

-		Class<?> publicType = descriptor.publicType();
-		if (KotlinDetector.isKotlinReflectPresent() && KotlinDelegate.hasConstructorWithOptionalParameter(publicType)) {
-			return generateCodeForInaccessibleConstructor(descriptor,
-					hints -> hints.registerType(publicType, MemberCategory.INVOKE_DECLARED_CONSTRUCTORS));
+		if (KotlinDetector.isKotlinReflectPresent() && KotlinDelegate.hasConstructorWithOptionalParameter(beanClass)) {
+			return generateCodeForInaccessibleConstructor(beanName, constructor,
+					hints -> hints.registerType(beanClass, MemberCategory.INVOKE_DECLARED_CONSTRUCTORS));
 		}

 		if (!isVisible(constructor, constructor.getDeclaringClass())) {
-			return generateCodeForInaccessibleConstructor(descriptor,
+			return generateCodeForInaccessibleConstructor(beanName, constructor,
 					hints -> hints.registerConstructor(constructor, ExecutableMode.INVOKE));
 		}
-		return generateCodeForAccessibleConstructor(descriptor);
+		return generateCodeForAccessibleConstructor(beanName, constructor);
 	}

-	private CodeBlock generateCodeForAccessibleConstructor(ConstructorDescriptor descriptor) {
-		Constructor<?> constructor = descriptor.constructor();
+	private CodeBlock generateCodeForAccessibleConstructor(String beanName, Constructor<?> constructor) {
 		this.generationContext.getRuntimeHints().reflection().registerConstructor(
 				constructor, ExecutableMode.INTROSPECT);

 		if (constructor.getParameterCount() == 0) {
 			if (!this.allowDirectSupplierShortcut) {
-				return CodeBlock.of("$T.using($T::new)", InstanceSupplier.class, descriptor.actualType());
+				return CodeBlock.of("$T.using($T::new)", InstanceSupplier.class, constructor.getDeclaringClass());
 			}
 			if (!isThrowingCheckedException(constructor)) {
-				return CodeBlock.of("$T::new", descriptor.actualType());
+				return CodeBlock.of("$T::new", constructor.getDeclaringClass());
 			}
-			return CodeBlock.of("$T.of($T::new)", ThrowingSupplier.class, descriptor.actualType());
+			return CodeBlock.of("$T.of($T::new)", ThrowingSupplier.class, constructor.getDeclaringClass());
 		}

 		GeneratedMethod generatedMethod = generateGetInstanceSupplierMethod(method ->
-				buildGetInstanceMethodForConstructor(method, descriptor, PRIVATE_STATIC));
+				buildGetInstanceMethodForConstructor(method, beanName, constructor, PRIVATE_STATIC));
 		return generateReturnStatement(generatedMethod);
 	}

-	private CodeBlock generateCodeForInaccessibleConstructor(ConstructorDescriptor descriptor,
-			Consumer<ReflectionHints> hints) {
+	private CodeBlock generateCodeForInaccessibleConstructor(String beanName,
+			Constructor<?> constructor, Consumer<ReflectionHints> hints) {

-		Constructor<?> constructor = descriptor.constructor();
 		CodeWarnings codeWarnings = new CodeWarnings();
 		codeWarnings.detectDeprecation(constructor.getDeclaringClass(), constructor)
 				.detectDeprecation(Arrays.stream(constructor.getParameters()).map(Parameter::getType));
 		hints.accept(this.generationContext.getRuntimeHints().reflection());

 		GeneratedMethod generatedMethod = generateGetInstanceSupplierMethod(method -> {
-			method.addJavadoc("Get the bean instance supplier for '$L'.", descriptor.beanName());
+			method.addJavadoc("Get the bean instance supplier for '$L'.", beanName);
 			method.addModifiers(PRIVATE_STATIC);
 			codeWarnings.suppress(method);
-			method.returns(ParameterizedTypeName.get(BeanInstanceSupplier.class, descriptor.publicType()));
-			method.addStatement(generateResolverForConstructor(descriptor));
+			method.returns(ParameterizedTypeName.get(BeanInstanceSupplier.class, constructor.getDeclaringClass()));
+			method.addStatement(generateResolverForConstructor(constructor));
 		});

 		return generateReturnStatement(generatedMethod);
 	}

-	private void buildGetInstanceMethodForConstructor(MethodSpec.Builder method, ConstructorDescriptor descriptor,
-			javax.lang.model.element.Modifier... modifiers) {
+	private void buildGetInstanceMethodForConstructor(MethodSpec.Builder method, String beanName,
+			Constructor<?> constructor, javax.lang.model.element.Modifier... modifiers) {

-		Constructor<?> constructor = descriptor.constructor();
-		Class<?> publicType = descriptor.publicType();
-		Class<?> actualType = descriptor.actualType();
+		Class<?> declaringClass = constructor.getDeclaringClass();

 		CodeWarnings codeWarnings = new CodeWarnings();
-		codeWarnings.detectDeprecation(actualType, constructor)
+		codeWarnings.detectDeprecation(declaringClass, constructor)
 				.detectDeprecation(Arrays.stream(constructor.getParameters()).map(Parameter::getType));
-		method.addJavadoc("Get the bean instance supplier for '$L'.", descriptor.beanName());
+		method.addJavadoc("Get the bean instance supplier for '$L'.", beanName);
 		method.addModifiers(modifiers);
 		codeWarnings.suppress(method);
-		method.returns(ParameterizedTypeName.get(BeanInstanceSupplier.class, publicType));
+		method.returns(ParameterizedTypeName.get(BeanInstanceSupplier.class, declaringClass));

 		CodeBlock.Builder code = CodeBlock.builder();
-		code.add(generateResolverForConstructor(descriptor));
+		code.add(generateResolverForConstructor(constructor));
 		boolean hasArguments = constructor.getParameterCount() > 0;
-		boolean onInnerClass = ClassUtils.isInnerClass(actualType);
+		boolean onInnerClass = ClassUtils.isInnerClass(declaringClass);

 		CodeBlock arguments = hasArguments ?
-				new AutowiredArgumentsCodeGenerator(actualType, constructor)
+				new AutowiredArgumentsCodeGenerator(declaringClass, constructor)
 						.generateCode(constructor.getParameterTypes(), (onInnerClass ? 1 : 0))
 				: NO_ARGS;

-		CodeBlock newInstance = generateNewInstanceCodeForConstructor(actualType, arguments);
+		CodeBlock newInstance = generateNewInstanceCodeForConstructor(declaringClass, arguments);
 		code.add(generateWithGeneratorCode(hasArguments, newInstance));
 		method.addStatement(code.build());
 	}

-	private CodeBlock generateResolverForConstructor(ConstructorDescriptor descriptor) {
-		CodeBlock parameterTypes = generateParameterTypesCode(descriptor.constructor().getParameterTypes());
+	private CodeBlock generateResolverForConstructor(Constructor<?> constructor) {
+		CodeBlock parameterTypes = generateParameterTypesCode(constructor.getParameterTypes());
 		return CodeBlock.of("return $T.<$T>forConstructor($L)", BeanInstanceSupplier.class,
-				descriptor.publicType(), parameterTypes);
+				constructor.getDeclaringClass(), parameterTypes);
 	}

 	private CodeBlock generateNewInstanceCodeForConstructor(Class<?> declaringClass, CodeBlock args) {
@@ -443,11 +438,4 @@ public class InstanceSupplierCodeGenerator {
 		}
 	}

-	record ConstructorDescriptor(String beanName, Constructor<?> constructor, Class<?> publicType) {
-
-		Class<?> actualType() {
-			return this.constructor.getDeclaringClass();
-		}
-	}
-
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -991,64 +991,54 @@ public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFac
 	 */
 	@Nullable
 	private FactoryBean<?> getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
-		boolean locked = this.singletonLock.tryLock();
-		if (!locked) {
+		BeanWrapper bw = this.factoryBeanInstanceCache.get(beanName);
+		if (bw != null) {
+			return (FactoryBean<?>) bw.getWrappedInstance();
+		}
+		Object beanInstance = getSingleton(beanName, false);
+		if (beanInstance instanceof FactoryBean<?> factoryBean) {
+			return factoryBean;
+		}
+		if (isSingletonCurrentlyInCreation(beanName) ||
+				(mbd.getFactoryBeanName() != null && isSingletonCurrentlyInCreation(mbd.getFactoryBeanName()))) {
 			return null;
 		}

+		Object instance;
 		try {
-			BeanWrapper bw = this.factoryBeanInstanceCache.get(beanName);
-			if (bw != null) {
-				return (FactoryBean<?>) bw.getWrappedInstance();
+			// Mark this bean as currently in creation, even if just partially.
+			beforeSingletonCreation(beanName);
+			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
+			instance = resolveBeforeInstantiation(beanName, mbd);
+			if (instance == null) {
+				bw = createBeanInstance(beanName, mbd, null);
+				instance = bw.getWrappedInstance();
+				this.factoryBeanInstanceCache.put(beanName, bw);
 			}
-			Object beanInstance = getSingleton(beanName, false);
-			if (beanInstance instanceof FactoryBean<?> factoryBean) {
-				return factoryBean;
-			}
-			if (isSingletonCurrentlyInCreation(beanName) ||
-					(mbd.getFactoryBeanName() != null && isSingletonCurrentlyInCreation(mbd.getFactoryBeanName()))) {
-				return null;
-			}
-
-			Object instance;
-			try {
-				// Mark this bean as currently in creation, even if just partially.
-				beforeSingletonCreation(beanName);
-				// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
-				instance = resolveBeforeInstantiation(beanName, mbd);
-				if (instance == null) {
-					bw = createBeanInstance(beanName, mbd, null);
-					instance = bw.getWrappedInstance();
-					this.factoryBeanInstanceCache.put(beanName, bw);
-				}
-			}
-			catch (UnsatisfiedDependencyException ex) {
-				// Don't swallow, probably misconfiguration...
+		}
+		catch (UnsatisfiedDependencyException ex) {
+			// Don't swallow, probably misconfiguration...
+			throw ex;
+		}
+		catch (BeanCreationException ex) {
+			// Don't swallow a linkage error since it contains a full stacktrace on
+			// first occurrence... and just a plain NoClassDefFoundError afterwards.
+			if (ex.contains(LinkageError.class)) {
 				throw ex;
 			}
-			catch (BeanCreationException ex) {
-				// Don't swallow a linkage error since it contains a full stacktrace on
-				// first occurrence... and just a plain NoClassDefFoundError afterwards.
-				if (ex.contains(LinkageError.class)) {
-					throw ex;
-				}
-				// Instantiation failure, maybe too early...
-				if (logger.isDebugEnabled()) {
-					logger.debug("Bean creation exception on singleton FactoryBean type check: " + ex);
-				}
-				onSuppressedException(ex);
-				return null;
+			// Instantiation failure, maybe too early...
+			if (logger.isDebugEnabled()) {
+				logger.debug("Bean creation exception on singleton FactoryBean type check: " + ex);
 			}
-			finally {
-				// Finished partial creation of this bean.
-				afterSingletonCreation(beanName);
-			}
-
-			return getFactoryBean(beanName, instance);
+			onSuppressedException(ex);
+			return null;
 		}
 		finally {
-			this.singletonLock.unlock();
+			// Finished partial creation of this bean.
+			afterSingletonCreation(beanName);
 		}
+
+		return getFactoryBean(beanName, instance);
 	}

 	/**
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2022 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -54,22 +54,6 @@ public class BeanDefinitionOverrideException extends BeanDefinitionStoreExceptio
 		this.existingDefinition = existingDefinition;
 	}

-	/**
-	 * Create a new BeanDefinitionOverrideException for the given new and existing definition.
-	 * @param beanName the name of the bean
-	 * @param beanDefinition the newly registered bean definition
-	 * @param existingDefinition the existing bean definition for the same name
-	 * @param msg the detail message to include
-	 * @since 6.2.1
-	 */
-	public BeanDefinitionOverrideException(
-			String beanName, BeanDefinition beanDefinition, BeanDefinition existingDefinition, String msg) {
-
-		super(beanDefinition.getResourceDescription(), beanName, msg);
-		this.beanDefinition = beanDefinition;
-		this.existingDefinition = existingDefinition;
-	}
-

 	/**
 	 * Return the description of the resource that the bean definition came from.
@@ -177,7 +177,7 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 	/** Map from bean name to merged BeanDefinitionHolder. */
 	private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256);

-	/** Set of bean definition names with a primary marker. */
+	// 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. */
@@ -1170,11 +1170,6 @@ public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFacto
 					}
 				}
 				else {
-					if (logger.isInfoEnabled()) {
-						logger.info("Removing alias '" + beanName + "' for bean '" + aliasedName +
-								"' due to registration of bean definition for bean '" + beanName + "': [" +
-								beanDefinition + "]");
-					}
 					removeAlias(beanName);
 				}
 			}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -76,9 +76,6 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;


-	/** Common lock for singleton creation. */
-	final Lock singletonLock = new ReentrantLock();
-
 	/** Cache of singleton objects: bean name to bean instance. */
 	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

@@ -94,6 +91,8 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 	/** Set of registered singletons, containing the bean names in registration order. */
 	private final Set<String> registeredSingletons = Collections.synchronizedSet(new LinkedHashSet<>(256));

+	private final Lock singletonLock = new ReentrantLock();
+
 	/** Names of beans that are currently in creation. */
 	private final Set<String> singletonsCurrentlyInCreation = ConcurrentHashMap.newKeySet(16);

@@ -279,25 +278,7 @@ public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements
 				if (logger.isDebugEnabled()) {
 					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
 				}
-
-				try {
-					beforeSingletonCreation(beanName);
-				}
-				catch (BeanCurrentlyInCreationException ex) {
-					if (locked) {
-						throw ex;
-					}
-					// Try late locking for waiting on specific bean to be finished.
-					this.singletonLock.lock();
-					locked = true;
-					// Singleton object should have appeared in the meantime.
-					singletonObject = this.singletonObjects.get(beanName);
-					if (singletonObject != null) {
-						return singletonObject;
-					}
-					beforeSingletonCreation(beanName);
-				}
-
+				beforeSingletonCreation(beanName);
 				boolean newSingleton = false;
 				boolean recordSuppressedExceptions = (locked && this.suppressedExceptions == null);
 				if (recordSuppressedExceptions) {
@@ -118,45 +118,39 @@ public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanReg
 	 */
 	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
 		if (factory.isSingleton() && containsSingleton(beanName)) {
-			this.singletonLock.lock();
-			try {
-				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;
+			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 (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 {
+							afterSingletonCreation(beanName);
+						}
 					}
-					else {
-						if (shouldPostProcess) {
-							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 {
-								afterSingletonCreation(beanName);
-							}
-						}
-						if (containsSingleton(beanName)) {
-							this.factoryBeanObjectCache.put(beanName, object);
-						}
+					if (containsSingleton(beanName)) {
+						this.factoryBeanObjectCache.put(beanName, object);
 					}
 				}
-				return object;
-			}
-			finally {
-				this.singletonLock.unlock();
 			}
+			return object;
 		}
 		else {
 			Object object = doGetObjectFromFactoryBean(factory, beanName);
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2024 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.beans.testfixture.beans.TestBean;

 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

 /**
 * @author Juergen Hoeller
@@ -55,6 +56,9 @@ class BeanFactoryLockingTests {
 		@Override
 		public void afterPropertiesSet() throws Exception {
 			Thread thread = new Thread(() -> {
+				// Fail for circular reference from other thread
+				assertThatExceptionOfType(BeanCurrentlyInCreationException.class).isThrownBy(() ->
+						beanFactory.getBean(ThreadDuringInitialization.class));
 				// Leniently create unrelated other bean outside of singleton lock
 				assertThat(beanFactory.getBean(TestBean.class).getName()).isEqualTo("tb");
 				// Creation attempt in other thread was successful
@@ -870,15 +870,10 @@ class DefaultListableBeanFactoryTests {
 	void beanDefinitionOverriding() {
 		lbf.setAllowBeanDefinitionOverriding(true);
 		lbf.registerBeanDefinition("test", new RootBeanDefinition(TestBean.class));
-		// Override "test" bean definition.
 		lbf.registerBeanDefinition("test", new RootBeanDefinition(NestedTestBean.class));
-		// Temporary "test2" alias for nonexistent bean.
 		lbf.registerAlias("otherTest", "test2");
-		// Reassign "test2" alias to "test".
 		lbf.registerAlias("test", "test2");
-		// Assign "testX" alias to "test" as well.
 		lbf.registerAlias("test", "testX");
-		// Register new "testX" bean definition which also removes the "testX" alias for "test".
 		lbf.registerBeanDefinition("testX", new RootBeanDefinition(TestBean.class));

 		assertThat(lbf.getBean("test")).isInstanceOf(NestedTestBean.class);
@@ -43,36 +43,36 @@ import javax.lang.model.element.Modifier
 */
 class InstanceSupplierCodeGeneratorKotlinTests {

-	private val generationContext = TestGenerationContext()
+    private val generationContext = TestGenerationContext()

 	private val beanFactory = DefaultListableBeanFactory()

-	@Test
-	fun generateWhenHasDefaultConstructor() {
-		val beanDefinition: BeanDefinition = RootBeanDefinition(KotlinTestBean::class.java)
-		val beanFactory = DefaultListableBeanFactory()
-		compile(beanFactory, beanDefinition) { instanceSupplier, compiled ->
-			val bean = getBean<KotlinTestBean>(beanFactory, beanDefinition, instanceSupplier)
-			Assertions.assertThat(bean).isInstanceOf(KotlinTestBean::class.java)
-			Assertions.assertThat(compiled.sourceFile).contains("InstanceSupplier.using(KotlinTestBean::new)")
-		}
-		Assertions.assertThat(getReflectionHints().getTypeHint(KotlinTestBean::class.java))
-			.satisfies(hasConstructorWithMode(ExecutableMode.INTROSPECT))
-	}
+    @Test
+    fun generateWhenHasDefaultConstructor() {
+        val beanDefinition: BeanDefinition = RootBeanDefinition(KotlinTestBean::class.java)
+        val beanFactory = DefaultListableBeanFactory()
+        compile(beanFactory, beanDefinition) { instanceSupplier, compiled ->
+            val bean = getBean<KotlinTestBean>(beanFactory, beanDefinition, instanceSupplier)
+            Assertions.assertThat(bean).isInstanceOf(KotlinTestBean::class.java)
+            Assertions.assertThat(compiled.sourceFile).contains("InstanceSupplier.using(KotlinTestBean::new)")
+        }
+        Assertions.assertThat(getReflectionHints().getTypeHint(KotlinTestBean::class.java))
+            .satisfies(hasConstructorWithMode(ExecutableMode.INTROSPECT))
+    }

-	@Test
-	fun generateWhenConstructorHasOptionalParameter() {
-		val beanDefinition: BeanDefinition = RootBeanDefinition(KotlinTestBeanWithOptionalParameter::class.java)
-		val beanFactory = DefaultListableBeanFactory()
-		compile(beanFactory, beanDefinition) { instanceSupplier, compiled ->
-				val bean: KotlinTestBeanWithOptionalParameter = getBean(beanFactory, beanDefinition, instanceSupplier)
-				Assertions.assertThat(bean).isInstanceOf(KotlinTestBeanWithOptionalParameter::class.java)
-				Assertions.assertThat(compiled.sourceFile)
-					.contains("return BeanInstanceSupplier.<KotlinTestBeanWithOptionalParameter>forConstructor();")
-			}
-		Assertions.assertThat<TypeHint>(getReflectionHints().getTypeHint(KotlinTestBeanWithOptionalParameter::class.java))
-			.satisfies(hasMemberCategory(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS))
-	}
+    @Test
+    fun generateWhenConstructorHasOptionalParameter() {
+        val beanDefinition: BeanDefinition = RootBeanDefinition(KotlinTestBeanWithOptionalParameter::class.java)
+        val beanFactory = DefaultListableBeanFactory()
+        compile(beanFactory, beanDefinition) { instanceSupplier, compiled ->
+                val bean: KotlinTestBeanWithOptionalParameter = getBean(beanFactory, beanDefinition, instanceSupplier)
+                Assertions.assertThat(bean).isInstanceOf(KotlinTestBeanWithOptionalParameter::class.java)
+                Assertions.assertThat(compiled.sourceFile)
+                    .contains("return BeanInstanceSupplier.<KotlinTestBeanWithOptionalParameter>forConstructor();")
+            }
+        Assertions.assertThat<TypeHint>(getReflectionHints().getTypeHint(KotlinTestBeanWithOptionalParameter::class.java))
+            .satisfies(hasMemberCategory(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS))
+    }

 	@Test
 	fun generateWhenHasFactoryMethodWithNoArg() {
@@ -107,27 +107,27 @@ class InstanceSupplierCodeGeneratorKotlinTests {
 		}
 	}

-	private fun getReflectionHints(): ReflectionHints {
-		return generationContext.runtimeHints.reflection()
-	}
+    private fun getReflectionHints(): ReflectionHints {
+        return generationContext.runtimeHints.reflection()
+    }

-	private fun hasConstructorWithMode(mode: ExecutableMode): ThrowingConsumer<TypeHint> {
-		return ThrowingConsumer {
-			Assertions.assertThat(it.constructors()).anySatisfy(hasMode(mode))
-		}
-	}
+    private fun hasConstructorWithMode(mode: ExecutableMode): ThrowingConsumer<TypeHint> {
+        return ThrowingConsumer {
+            Assertions.assertThat(it.constructors()).anySatisfy(hasMode(mode))
+        }
+    }

-	private fun hasMemberCategory(category: MemberCategory): ThrowingConsumer<TypeHint> {
-		return ThrowingConsumer {
-			Assertions.assertThat(it.memberCategories).contains(category)
-		}
-	}
+    private fun hasMemberCategory(category: MemberCategory): ThrowingConsumer<TypeHint> {
+        return ThrowingConsumer {
+            Assertions.assertThat(it.memberCategories).contains(category)
+        }
+    }

-	private fun hasMode(mode: ExecutableMode): ThrowingConsumer<ExecutableHint> {
-		return ThrowingConsumer {
-			Assertions.assertThat(it.mode).isEqualTo(mode)
-		}
-	}
+    private fun hasMode(mode: ExecutableMode): ThrowingConsumer<ExecutableHint> {
+        return ThrowingConsumer {
+            Assertions.assertThat(it.mode).isEqualTo(mode)
+        }
+    }

 	private fun hasMethodWithMode(mode: ExecutableMode): ThrowingConsumer<TypeHint> {
 		return ThrowingConsumer { hint: TypeHint ->
@@ -135,48 +135,48 @@ class InstanceSupplierCodeGeneratorKotlinTests {
 		}
 	}

-	@Suppress("UNCHECKED_CAST")
-	private fun <T> getBean(beanFactory: DefaultListableBeanFactory, beanDefinition: BeanDefinition,
-							instanceSupplier: InstanceSupplier<*>): T {
-		(beanDefinition as RootBeanDefinition).instanceSupplier = instanceSupplier
-		beanFactory.registerBeanDefinition("testBean", beanDefinition)
-		return beanFactory.getBean("testBean") as T
-	}
+    @Suppress("UNCHECKED_CAST")
+    private fun <T> getBean(beanFactory: DefaultListableBeanFactory, beanDefinition: BeanDefinition,
+                            instanceSupplier: InstanceSupplier<*>): T {
+        (beanDefinition as RootBeanDefinition).instanceSupplier = instanceSupplier
+        beanFactory.registerBeanDefinition("testBean", beanDefinition)
+        return beanFactory.getBean("testBean") as T
+    }

-	private fun compile(beanFactory: DefaultListableBeanFactory, beanDefinition: BeanDefinition,
-						result: BiConsumer<InstanceSupplier<*>, Compiled>) {
+    private fun compile(beanFactory: DefaultListableBeanFactory, beanDefinition: BeanDefinition,
+                        result: BiConsumer<InstanceSupplier<*>, Compiled>) {

-		val freshBeanFactory = DefaultListableBeanFactory(beanFactory)
-		freshBeanFactory.registerBeanDefinition("testBean", beanDefinition)
-		val registeredBean = RegisteredBean.of(freshBeanFactory, "testBean")
-		val typeBuilder = DeferredTypeBuilder()
-		val generateClass = generationContext.generatedClasses.addForFeature("TestCode", typeBuilder)
-		val generator = InstanceSupplierCodeGenerator(
-			generationContext, generateClass.name,
-			generateClass.methods, false
-		)
-		val instantiationDescriptor = registeredBean.resolveInstantiationDescriptor()
-		Assertions.assertThat(instantiationDescriptor).isNotNull()
-		val generatedCode = generator.generateCode(registeredBean, instantiationDescriptor)
-		typeBuilder.set { type: TypeSpec.Builder ->
-			type.addModifiers(Modifier.PUBLIC)
-			type.addSuperinterface(
-				ParameterizedTypeName.get(
-					Supplier::class.java,
-					InstanceSupplier::class.java
-				)
-			)
-			type.addMethod(
-				MethodSpec.methodBuilder("get")
-					.addModifiers(Modifier.PUBLIC)
-					.returns(InstanceSupplier::class.java)
-					.addStatement("return \$L", generatedCode).build()
-			)
-		}
-		generationContext.writeGeneratedContent()
-		TestCompiler.forSystem().with(generationContext).compile {
-			result.accept(it.getInstance(Supplier::class.java).get() as InstanceSupplier<*>, it)
-		}
-	}
+        val freshBeanFactory = DefaultListableBeanFactory(beanFactory)
+        freshBeanFactory.registerBeanDefinition("testBean", beanDefinition)
+        val registeredBean = RegisteredBean.of(freshBeanFactory, "testBean")
+        val typeBuilder = DeferredTypeBuilder()
+        val generateClass = generationContext.generatedClasses.addForFeature("TestCode", typeBuilder)
+        val generator = InstanceSupplierCodeGenerator(
+            generationContext, generateClass.name,
+            generateClass.methods, false
+        )
+        val instantiationDescriptor = registeredBean.resolveInstantiationDescriptor()
+        Assertions.assertThat(instantiationDescriptor).isNotNull()
+        val generatedCode = generator.generateCode(registeredBean, instantiationDescriptor)
+        typeBuilder.set { type: TypeSpec.Builder ->
+            type.addModifiers(Modifier.PUBLIC)
+            type.addSuperinterface(
+                ParameterizedTypeName.get(
+                    Supplier::class.java,
+                    InstanceSupplier::class.java
+                )
+            )
+            type.addMethod(
+                MethodSpec.methodBuilder("get")
+                    .addModifiers(Modifier.PUBLIC)
+                    .returns(InstanceSupplier::class.java)
+                    .addStatement("return \$L", generatedCode).build()
+            )
+        }
+        generationContext.writeGeneratedContent()
+        TestCompiler.forSystem().with(generationContext).compile {
+            result.accept(it.getInstance(Supplier::class.java).get() as InstanceSupplier<*>, it)
+        }
+    }

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -303,17 +303,6 @@ public class CaffeineCacheManager implements CacheManager {
 		this.cacheMap.put(name, adaptCaffeineCache(name, cache));
 	}

-	/**
-	 * Remove the specified cache from this cache manager, applying to
-	 * custom caches as well as dynamically registered caches at runtime.
-	 * @param name the name of the cache
-	 * @since 6.1.15
-	 */
-	public void removeCache(String name) {
-		this.customCacheNames.remove(name);
-		this.cacheMap.remove(name);
-	}
-
 	/**
 	 * Adapt the given new native Caffeine Cache instance to Spring's {@link Cache}
 	 * abstraction for the specified cache name.
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -47,7 +47,7 @@ import org.springframework.util.concurrent.ListenableFutureTask;
 * @see org.springframework.core.task.TaskExecutor
 * @see SchedulerFactoryBean#setTaskExecutor
 */
-@SuppressWarnings({"deprecation", "removal"})
+@SuppressWarnings("deprecation")
 public class SimpleThreadPoolTaskExecutor extends SimpleThreadPool
 		implements AsyncListenableTaskExecutor, SchedulingTaskExecutor, InitializingBean, DisposableBean {

@@ -32,10 +32,6 @@ import org.springframework.lang.Nullable;
 * {@link #cacheManager()}, {@link #cacheResolver()}, {@link #keyGenerator()}, and
 * {@link #errorHandler()} for detailed instructions.
 *
- * <p><b>NOTE: A {@code CachingConfigurer} will get initialized early.</b>
- * Do not inject common dependencies into autowired fields directly; instead, consider
- * declaring a lazy {@link org.springframework.beans.factory.ObjectProvider} for those.
- *
 * @author Chris Beams
 * @author Stephane Nicoll
 * @since 3.1
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -175,15 +175,6 @@ public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderA
 		return cache;
 	}

-	/**
-	 * Remove the specified cache from this cache manager.
-	 * @param name the name of the cache
-	 * @since 6.1.15
-	 */
-	public void removeCache(String name) {
-		this.cacheMap.remove(name);
-	}
-
 	private void recreateCaches() {
 		for (Map.Entry<String, Cache> entry : this.cacheMap.entrySet()) {
 			entry.setValue(createConcurrentMapCache(entry.getKey()));
@@ -36,10 +36,10 @@ import org.springframework.beans.factory.groovy.GroovyBeanDefinitionReader;
 import org.springframework.beans.factory.parsing.SourceExtractor;
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.AbstractBeanDefinitionReader;
-import org.springframework.beans.factory.support.BeanDefinitionOverrideException;
 import org.springframework.beans.factory.support.BeanDefinitionReader;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.BeanNameGenerator;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
 import org.springframework.context.annotation.ConfigurationCondition.ConfigurationPhase;
@@ -297,21 +297,13 @@ class ConfigurationClassBeanDefinitionReader {
 			return false;
 		}
 		BeanDefinition existingBeanDef = this.registry.getBeanDefinition(beanName);
-		ConfigurationClass configClass = beanMethod.getConfigurationClass();

 		// If the bean method is an overloaded case on the same configuration class,
 		// preserve the existing bean definition and mark it as overloaded.
 		if (existingBeanDef instanceof ConfigurationClassBeanDefinition ccbd) {
-			if (ccbd.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
-				if (ccbd.getFactoryMethodMetadata().getMethodName().equals(beanMethod.getMetadata().getMethodName())) {
-					ccbd.setNonUniqueFactoryMethodName(ccbd.getFactoryMethodMetadata().getMethodName());
-				}
-				else if (!this.registry.isBeanDefinitionOverridable(beanName)) {
-					throw new BeanDefinitionOverrideException(beanName,
-							new ConfigurationClassBeanDefinition(configClass, beanMethod.getMetadata(), beanName),
-							existingBeanDef,
-							"@Bean method override with same bean name but different method name: " + existingBeanDef);
-				}
+			if (ccbd.getMetadata().getClassName().equals(beanMethod.getConfigurationClass().getMetadata().getClassName()) &&
+					ccbd.getFactoryMethodMetadata().getMethodName().equals(beanMethod.getMetadata().getMethodName())) {
+				ccbd.setNonUniqueFactoryMethodName(ccbd.getFactoryMethodMetadata().getMethodName());
 				return true;
 			}
 			else {
@@ -337,11 +329,9 @@ class ConfigurationClassBeanDefinitionReader {

 		// At this point, it's a top-level override (probably XML), just having been parsed
 		// before configuration class processing kicks in...
-		if (!this.registry.isBeanDefinitionOverridable(beanName)) {
-			throw new BeanDefinitionOverrideException(beanName,
-					new ConfigurationClassBeanDefinition(configClass, beanMethod.getMetadata(), beanName),
-					existingBeanDef,
-					"@Bean definition illegally overridden by existing bean definition: " + existingBeanDef);
+		if (this.registry instanceof DefaultListableBeanFactory dlbf && !dlbf.isBeanDefinitionOverridable(beanName)) {
+			throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
+					beanName, "@Bean definition illegally overridden by existing bean definition: " + existingBeanDef);
 		}
 		if (logger.isDebugEnabled()) {
 			logger.debug(String.format("Skipping bean definition for %s: a definition for bean '%s' " +
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@

 package org.springframework.context.annotation;

-import java.io.Serializable;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.Collection;
@@ -28,6 +27,7 @@ import java.util.Set;

 import org.springframework.aop.TargetSource;
 import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver;
 import org.springframework.beans.factory.config.DependencyDescriptor;
@@ -35,6 +35,7 @@ import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.core.MethodParameter;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;

 /**
 * Complete implementation of the
@@ -84,13 +85,47 @@ public class ContextAnnotationAutowireCandidateResolver extends QualifierAnnotat
 	}

 	private Object buildLazyResolutionProxy(
-			DependencyDescriptor descriptor, @Nullable String beanName, boolean classOnly) {
+			final DependencyDescriptor descriptor, @Nullable final String beanName, boolean classOnly) {

-		if (!(getBeanFactory() instanceof DefaultListableBeanFactory dlbf)) {
-			throw new IllegalStateException("Lazy resolution only supported with DefaultListableBeanFactory");
-		}
+		BeanFactory beanFactory = getBeanFactory();
+		Assert.state(beanFactory instanceof DefaultListableBeanFactory,
+				"BeanFactory needs to be a DefaultListableBeanFactory");
+		final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;

-		TargetSource ts = new LazyDependencyTargetSource(dlbf, descriptor, beanName);
+		TargetSource ts = new TargetSource() {
+			@Override
+			public Class<?> getTargetClass() {
+				return descriptor.getDependencyType();
+			}
+			@Override
+			@SuppressWarnings("NullAway")
+			public Object getTarget() {
+				Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
+				Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);
+				if (target == null) {
+					Class<?> type = getTargetClass();
+					if (Map.class == type) {
+						return Collections.emptyMap();
+					}
+					else if (List.class == type) {
+						return Collections.emptyList();
+					}
+					else if (Set.class == type || Collection.class == type) {
+						return Collections.emptySet();
+					}
+					throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
+							"Optional dependency not present for lazy injection point");
+				}
+				if (autowiredBeanNames != null) {
+					for (String autowiredBeanName : autowiredBeanNames) {
+						if (dlbf.containsBean(autowiredBeanName)) {
+							dlbf.registerDependentBean(autowiredBeanName, beanName);
+						}
+					}
+				}
+				return target;
+			}
+		};

 		ProxyFactory pf = new ProxyFactory();
 		pf.setTargetSource(ts);
@@ -102,96 +137,4 @@ public class ContextAnnotationAutowireCandidateResolver extends QualifierAnnotat
 		return (classOnly ? pf.getProxyClass(classLoader) : pf.getProxy(classLoader));
 	}

-
-	@SuppressWarnings("serial")
-	private static class LazyDependencyTargetSource implements TargetSource, Serializable {
-
-		private final DefaultListableBeanFactory beanFactory;
-
-		private final DependencyDescriptor descriptor;
-
-		@Nullable
-		private final String beanName;
-
-		@Nullable
-		private transient volatile Object cachedTarget;
-
-		public LazyDependencyTargetSource(DefaultListableBeanFactory beanFactory,
-				DependencyDescriptor descriptor, @Nullable String beanName) {
-
-			this.beanFactory = beanFactory;
-			this.descriptor = descriptor;
-			this.beanName = beanName;
-		}
-
-		@Override
-		public Class<?> getTargetClass() {
-			return this.descriptor.getDependencyType();
-		}
-
-		@Override
-		@SuppressWarnings("NullAway")
-		public Object getTarget() {
-			Object cachedTarget = this.cachedTarget;
-			if (cachedTarget != null) {
-				return cachedTarget;
-			}
-
-			Set<String> autowiredBeanNames = new LinkedHashSet<>(2);
-			Object target = this.beanFactory.doResolveDependency(
-					this.descriptor, this.beanName, autowiredBeanNames, null);
-
-			if (target == null) {
-				Class<?> type = getTargetClass();
-				if (Map.class == type) {
-					target = Collections.emptyMap();
-				}
-				else if (List.class == type) {
-					target = Collections.emptyList();
-				}
-				else if (Set.class == type || Collection.class == type) {
-					target = Collections.emptySet();
-				}
-				else {
-					throw new NoSuchBeanDefinitionException(this.descriptor.getResolvableType(),
-							"Optional dependency not present for lazy injection point");
-				}
-			}
-			else {
-				if (target instanceof Map<?, ?> map && Map.class == getTargetClass()) {
-					target = Collections.unmodifiableMap(map);
-				}
-				else if (target instanceof List<?> list && List.class == getTargetClass()) {
-					target = Collections.unmodifiableList(list);
-				}
-				else if (target instanceof Set<?> set && Set.class == getTargetClass()) {
-					target = Collections.unmodifiableSet(set);
-				}
-				else if (target instanceof Collection<?> coll && Collection.class == getTargetClass()) {
-					target = Collections.unmodifiableCollection(coll);
-				}
-			}
-
-			boolean cacheable = true;
-			for (String autowiredBeanName : autowiredBeanNames) {
-				if (!this.beanFactory.containsBean(autowiredBeanName)) {
-					cacheable = false;
-				}
-				else {
-					if (this.beanName != null) {
-						this.beanFactory.registerDependentBean(autowiredBeanName, this.beanName);
-					}
-					if (!this.beanFactory.isSingleton(autowiredBeanName)) {
-						cacheable = false;
-					}
-				}
-				if (cacheable) {
-					this.cachedTarget = target;
-				}
-			}
-
-			return target;
-		}
-	}
-
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -45,8 +45,7 @@ import java.lang.annotation.Target;
 * <p>In addition to its role for component initialization, this annotation may also be placed
 * on injection points marked with {@link org.springframework.beans.factory.annotation.Autowired}
 * or {@link jakarta.inject.Inject}: In that context, it leads to the creation of a
- * lazy-resolution proxy for the affected dependency, caching it on first access in case of
- * a singleton or re-resolving it on every access otherwise. This is an alternative to using
+ * lazy-resolution proxy for all affected dependencies, as an alternative to using
 * {@link org.springframework.beans.factory.ObjectFactory} or {@link jakarta.inject.Provider}.
 * Please note that such a lazy-resolution proxy will always be injected; if the target
 * dependency does not exist, you will only be able to find out through an exception on
@@ -310,7 +310,7 @@ public class ApplicationListenerMethodAdapter implements GenericApplicationListe
 		return new Object[] {event};
 	}

-	@SuppressWarnings({"removal", "unchecked", "deprecation"})
+	@SuppressWarnings({"deprecation", "unchecked"})
 	protected void handleResult(Object result) {
 		if (reactiveStreamsPresent && new ReactiveResultHandler().subscribeToPublisher(result)) {
 			if (logger.isTraceEnabled()) {
@@ -28,27 +28,17 @@ import java.lang.annotation.Target;
 * <p>Formatting applies to parsing a date/time object from a string as well as printing a
 * date/time object to a string.
 *
- * <p>Supports formatting by style pattern, ISO date/time pattern, or custom format pattern string.
+ * <p>Supports formatting by style pattern, ISO date time pattern, or custom format pattern string.
 * Can be applied to {@link java.util.Date}, {@link java.util.Calendar}, {@link Long} (for
 * millisecond timestamps) as well as JSR-310 {@code java.time} value types.
 *
 * <p>For style-based formatting, set the {@link #style} attribute to the desired style pattern code.
 * The first character of the code is the date style, and the second character is the time style.
 * Specify a character of 'S' for short style, 'M' for medium, 'L' for long, and 'F' for full.
- * The date or time may be omitted by specifying the style character '-'. For example,
+ * The date or time may be omitted by specifying the style character '-' &mdash; for example,
 * 'M-' specifies a medium format for the date with no time. The supported style pattern codes
 * correlate to the enum constants defined in {@link java.time.format.FormatStyle}.
 *
- * <p><strong>WARNING</strong>: Style-based formatting and parsing rely on locale-sensitive
- * patterns which may change depending on the Java runtime. Specifically, applications that
- * rely on date/time parsing and formatting may encounter incompatible changes in behavior
- * when running on JDK 20 or higher. Using an ISO standardized format or a concrete pattern
- * that you control allows for reliable system-independent and locale-independent parsing and
- * formatting of date/time values. The use of {@linkplain #fallbackPatterns() fallback patterns}
- * can also help to address compatibility issues. For further details, see the
- * <a href="https://github.com/spring-projects/spring-framework/wiki/Date-and-Time-Formatting-with-JDK-20-and-higher">
- * Date and Time Formatting with JDK 20 and higher</a> page in the Spring Framework wiki.
- *
 * <p>For ISO-based formatting, set the {@link #iso} attribute to the desired {@link ISO} format,
 * such as {@link ISO#DATE}.
 *
@@ -111,13 +101,13 @@ public @interface DateTimeFormat {

 	/**
 	 * The custom pattern to use to format the field or method parameter.
-	 * <p>Defaults to an empty String, indicating no custom pattern String has been
+	 * <p>Defaults to empty String, indicating no custom pattern String has been
 	 * specified. Set this attribute when you wish to format your field or method
 	 * parameter in accordance with a custom date time pattern not represented by
 	 * a style or ISO format.
-	 * <p>Note: This pattern follows the original {@link java.text.SimpleDateFormat}
-	 * style, with strict parsing semantics towards overflows (for example, rejecting
-	 * a {@code Feb 29} value for a non-leap-year). As a consequence, 'yy'
+	 * <p>Note: This pattern follows the original {@link java.text.SimpleDateFormat} style,
+	 * as also supported by Joda-Time, with strict parsing semantics towards overflows
+	 * (for example, rejecting a Feb 29 value for a non-leap-year). As a consequence, 'yy'
 	 * characters indicate a year in the traditional style, not a "year-of-era" as in the
 	 * {@link java.time.format.DateTimeFormatter} specification (i.e. 'yy' turns into 'uu'
 	 * when going through a {@code DateTimeFormatter} with strict resolution mode).
@@ -139,6 +129,7 @@ public @interface DateTimeFormat {
 	 * or {@link #style} attribute is always used for printing. For details on
 	 * which time zone is used for fallback patterns, see the
 	 * {@linkplain DateTimeFormat class-level documentation}.
+	 * <p>Fallback patterns are not supported for Joda-Time value types.
 	 * @since 5.3.5
 	 */
 	String[] fallbackPatterns() default {};
--- a/Show More
+++ b/Show More