Release v6.0.19

This commit refines the expressions for the scheme, user info, host and
port parts of the URL in UriComponentsBuilder to better conform to
RFC 3986.

Fixes gh-32617

.github/actions/send-notification/action.yml

@@ -0,0 +1,33 @@
+name: Send notification
+description: Sends a Google Chat message as a notification of the job's outcome
+inputs:
+  webhook-url:
+    description: 'Google Chat Webhook URL'
+    required: true
+  status:
+    description: 'Status of the job'
+    required: true
+  build-scan-url:
+    description: 'URL of the build scan to include in the notification'
+  run-name:
+    description: 'Name of the run to include in the notification'
+    default: ${{ format('{0} {1}', github.ref_name, github.job) }}
+runs:
+  using: composite
+  steps:
+    - shell: bash
+      run: |
+        echo "BUILD_SCAN=${{ inputs.build-scan-url == '' && ' [build scan unavailable]' || format(' [<{0}|Build Scan>]', inputs.build-scan-url) }}" >> "$GITHUB_ENV"
+        echo "RUN_URL=${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" >> "$GITHUB_ENV"
+    - shell: bash
+      if: ${{ inputs.status == 'success' }}
+      run: |
+        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was successful ${{ env.BUILD_SCAN }}"}' || true
+    - shell: bash
+      if: ${{ inputs.status == 'failure' }}
+      run: |
+        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<users/all> *<${{ env.RUN_URL }}|${{ inputs.run-name }}> failed* ${{ env.BUILD_SCAN }}"}' || true
+    - shell: bash
+      if: ${{ inputs.status == 'cancelled' }}
+      run: |
+        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was cancelled"}' || true

.github/workflows/backport-bot.yml

@@ -18,11 +18,13 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-java@v3
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Set up Java
+        uses: actions/setup-java@v4
         with:
-          distribution: 'temurin'
-          java-version: '17'
+          distribution: 'liberica'
+          java-version: 17
       - name: Download BackportBot
         run: wget https://github.com/spring-io/backport-bot/releases/download/latest/backport-bot-0.0.1-SNAPSHOT.jar
       - name: Backport

.github/workflows/build-and-deploy-snapshot.yml

@@ -0,0 +1,64 @@
+name: Build and deploy snapshot
+on:
+  push:
+    branches:
+      - 6.0.x
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build-and-deploy-snapshot:
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    name: Build and deploy snapshot
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'liberica'
+          java-version: 17
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
+        with:
+          cache-read-only: false
+      - name: Configure Gradle properties
+        shell: bash
+        run: |
+          mkdir -p $HOME/.gradle
+          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
+          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
+      - name: Build and publish
+        id: build
+        env:
+          CI: 'true'
+          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
+          GRADLE_ENTERPRISE_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+          GRADLE_ENTERPRISE_CACHE_USERNAME: ${{ secrets.GRADLE_ENTERPRISE_CACHE_USER }}
+          GRADLE_ENTERPRISE_CACHE_PASSWORD: ${{ secrets.GRADLE_ENTERPRISE_CACHE_PASSWORD }}
+        run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
+      - name: Deploy
+        uses: spring-io/artifactory-deploy-action@v0.0.1
+        with:
+          uri: 'https://repo.spring.io'
+          username: ${{ secrets.ARTIFACTORY_USERNAME }}
+          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          build-name: ${{ format('spring-framework-{0}', github.ref_name)}}
+          repository: 'libs-snapshot-local'
+          folder: 'deployment-repository'
+          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
+          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
+      - name: Send notification
+        uses: ./.github/actions/send-notification
+        if: always()
+        with:
+          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+          status: ${{ job.status }}
+          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
+          run-name: ${{ format('{0} | Linux | Java 17', github.ref_name) }}

.github/workflows/ci.yml

@@ -0,0 +1,80 @@
+name: CI
+on:
+  push:
+    branches:
+      - 6.0.x
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  ci:
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    strategy:
+      matrix:
+        os:
+          - id: ubuntu-latest
+            name: Linux
+        java:
+          - version: 17
+            toolchain: false
+          - version: 21
+            toolchain: true
+        exclude:
+          - os:
+              name: Linux
+            java:
+              version: 17
+    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
+    runs-on: ${{ matrix.os.id }}
+    steps:
+      - name: Set up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'liberica'
+          java-version: |
+            ${{ matrix.java.version }}
+            ${{ matrix.java.toolchain && '17' || '' }}
+      - name: Prepare Windows runner
+        if: ${{ runner.os == 'Windows' }}
+        run: |
+          git config --global core.autocrlf true
+          git config --global core.longPaths true
+          Stop-Service -name Docker
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
+        with:
+          cache-read-only: false
+      - name: Configure Gradle properties
+        shell: bash
+        run: |
+          mkdir -p $HOME/.gradle
+          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
+          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
+          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
+      - name: Configure toolchain properties
+        if: ${{ matrix.java.toolchain }}
+        shell: bash
+        run: |
+          echo toolchainVersion=${{ matrix.java.version }} >> $HOME/.gradle/gradle.properties
+          echo systemProp.org.gradle.java.installations.auto-detect=false >> $HOME/.gradle/gradle.properties
+          echo systemProp.org.gradle.java.installations.auto-download=false >> $HOME/.gradle/gradle.properties
+          echo systemProp.org.gradle.java.installations.paths=${{ format('$JAVA_HOME_{0}_X64', matrix.java.version) }} >> $HOME/.gradle/gradle.properties
+      - name: Build
+        id: build
+        env:
+          CI: 'true'
+          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
+          GRADLE_ENTERPRISE_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+          GRADLE_ENTERPRISE_CACHE_USERNAME: ${{ secrets.GRADLE_ENTERPRISE_CACHE_USER }}
+          GRADLE_ENTERPRISE_CACHE_PASSWORD: ${{ secrets.GRADLE_ENTERPRISE_CACHE_PASSWORD }}
+        run: ./gradlew check antora
+      - name: Send notification
+        uses: ./.github/actions/send-notification
+        if: always()
+        with:
+          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+          status: ${{ job.status }}
+          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
+          run-name: ${{ format('{0} | {1} | Java {2}', github.ref_name, matrix.os.name, matrix.java.version) }}

.github/workflows/deploy-docs.yml

@@ -1,12 +1,14 @@
 name: Deploy Docs
 on:
   push:
-    branches-ignore: [ gh-pages ]
-    tags: '**'
+    branches:
+      - 'main'
+      - '*.x'
+      - '!gh-pages'
+    tags:
+      - 'v*'
   repository_dispatch:
     types: request-build-reference # legacy
-  schedule:
-  - cron: '0 10 * * *' # Once per day at 10am UTC
   workflow_dispatch:
 permissions:
   actions: write
@@ -15,8 +17,8 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository_owner == 'spring-projects'
     steps:
-    - name: Checkout
-      uses: actions/checkout@v3
+    - name: Check out code
+      uses: actions/checkout@v4
       with:
         ref: docs-build
         fetch-depth: 1

.github/workflows/gradle-wrapper-validation.yml

@@ -9,5 +9,5 @@ jobs:
     name: "Validation"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: gradle/wrapper-validation-action@v1
+      - uses: actions/checkout@v4
+      - uses: gradle/wrapper-validation-action@v2

.mailmap

@@ -1,36 +0,0 @@
-Juergen Hoeller <jhoeller@vmware.com>
-Juergen Hoeller <jhoeller@vmware.com> <jhoeller@pivotal.io>
-Juergen Hoeller <jhoeller@vmware.com> <jhoeller@gopivotal.com>
-Rossen Stoyanchev <rstoyanchev@vmware.com>
-Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@pivotal.io>
-Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@gopivotal.com>
-Phillip Webb <pwebb@vmware.com>
-Phillip Webb <pwebb@vmware.com> <pwebb@pivotal.io>
-Phillip Webb <pwebb@vmware.com> <pwebb@gopivotal.com>
-Chris Beams <cbeams@vmware.com>
-Chris Beams <cbeams@vmware.com> <cbeams@pivotal.io>
-Chris Beams <cbeams@vmware.com> <cbeams@gopivotal.com>
-Arjen Poutsma <poutsmaa@vmware.com>
-Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@pivotal.io>
-Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@gopivotal.com>
-Arjen Poutsma <poutsmaa@vmware.com> <poutsma@mac.com>
-Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@vmware.com>
-Oliver Drotbohm <odrotbohm@vmware.com>
-Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@vmware.com>
-Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@pivotal.io>
-Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@gopivotal.com>
-Dave Syer <dsyer@vmware.com>
-Dave Syer <dsyer@vmware.com> <dsyer@pivotal.io>
-Dave Syer <dsyer@vmware.com> <dsyer@gopivotal.com>
-Dave Syer <dsyer@vmware.com> <david_syer@hotmail.com>
-Andy Clement <aclement@vmware.com>
-Andy Clement <aclement@vmware.com> <aclement@pivotal.io>
-Andy Clement <aclement@vmware.com> <aclement@gopivotal.com>
-Andy Clement <aclement@vmware.com> <andrew.clement@gmail.com>
-Sam Brannen <sbrannen@vmware.com>
-Sam Brannen <sbrannen@vmware.com> <sbrannen@pivotal.io>
-Sam Brannen <sbrannen@vmware.com> <sam@sambrannen.com>
-Simon Basle <sbasle@vmware.com>
-Simon Baslé <sbasle@vmware.com>
-<dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
-Nick Williams <nicholas@nicholaswilliams.net>

CONTRIBUTING.md

@@ -123,13 +123,13 @@ define the source file coding standards we use along with some IDEA editor setti
 
 ### Reference Docs
 
-The reference documentation is authored in [Asciidoctor](https://asciidoctor.org/) format
-using [Antora](https://docs.antora.org/antora/latest/). The source files for the documentation
-reside in the [framework-docs/modules/ROOT](framework-docs/modules/ROOT) directory. For
-trivial changes, you may be able to browse, edit source files, and submit directly from GitHub.
+The reference documentation is in the [framework-docs/src/docs/asciidoc](framework-docs/src/docs/asciidoc) directory, in
+[Asciidoctor](https://asciidoctor.org/) format. For trivial changes, you may be able to browse,
+edit source files, and submit directly from GitHub.
 
-When making changes locally, execute `./gradlew antora` and then browse the results under
-`framework-docs/build/site/index.html`.
+When making changes locally, execute `./gradlew :framework-docs:asciidoctor` and then browse the result under
+`framework-docs/build/docs/ref-docs/html5/index.html`.
 
 Asciidoctor also supports live editing. For more details see
 [AsciiDoc Tooling](https://docs.asciidoctor.org/asciidoctor/latest/tooling/).
+

README.md

@@ -1,8 +1,8 @@
-# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-6.0.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
+# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml/badge.svg?branch=6.0.x)](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml?query=branch%3A6.0.x) [![Revved up by Develocity](https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
 
 This is the home of the Spring Framework: the foundation for all [Spring projects](https://spring.io/projects). Collectively the Spring Framework and the family of Spring projects are often referred to simply as "Spring". 
 
-Spring provides everything required beyond the Java programming language for creating enterprise applications for a wide range of scenarios and architectures. Please read the [Overview](https://docs.spring.io/spring-framework/reference/overview.html) section of the reference documentation for a more complete introduction.
+Spring provides everything required beyond the Java programming language for creating enterprise applications for a wide range of scenarios and architectures. Please read the [Overview](https://docs.spring.io/spring/docs/current/spring-framework-reference/overview.html#spring-introduction) section as reference for a more complete introduction.
 
 ## Code of Conduct
 
@@ -14,7 +14,7 @@ For access to artifacts or a distribution zip, see the [Spring Framework Artifac
 
 ## Documentation
 
-The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/reference/) and [source](framework-docs/modules/ROOT)), GitHub [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
+The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/) and [source](framework-docs/src/docs/asciidoc)), GitHub [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
 [API reference](https://docs.spring.io/spring-framework/docs/current/javadoc-api/). There are also [guides and tutorials](https://spring.io/guides) across Spring projects.
 
 ## Micro-Benchmarks
@@ -31,7 +31,7 @@ Information regarding CI builds can be found in the [Spring Framework Concourse
 
 ## Stay in Touch
 
-Follow [@SpringCentral](https://twitter.com/springcentral), [@SpringFramework](https://twitter.com/springframework), and its [team members](https://twitter.com/springframework/lists/team/members) on Twitter. In-depth articles can be found at [The Spring Blog](https://spring.io/blog/), and releases are announced via our [releases feed](https://spring.io/blog/category/releases).
+Follow [@SpringCentral](https://twitter.com/springcentral), [@SpringFramework](https://twitter.com/springframework), and its [team members](https://twitter.com/springframework/lists/team/members) on Twitter. In-depth articles can be found at [The Spring Blog](https://spring.io/blog/), and releases are announced via our [news feed](https://spring.io/blog/category/news).
 
 ## License
 

build.gradle

@@ -1,24 +1,22 @@
 plugins {
-	id 'io.freefair.aspectj' version '8.4' apply false
+	id 'io.spring.nohttp' version '0.0.11'
+	id 'io.freefair.aspectj' version '8.0.1' apply false
 	// kotlinVersion is managed in gradle.properties
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
-	id 'org.jetbrains.dokka' version '1.8.20'
+	id 'org.jetbrains.dokka' version '1.8.10'
 	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
 	id 'com.github.ben-manes.versions' version '0.49.0'
 	id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
 	id 'de.undercouch.download' version '5.4.0'
-	id 'me.champeau.jmh' version '0.7.2' apply false
-	id 'me.champeau.mrjar' version '0.1.1'
+	id 'me.champeau.jmh' version '0.7.1' apply false
 }
 
 ext {
 	moduleProjects = subprojects.findAll { it.name.startsWith("spring-") }
-	javaProjects = subprojects.findAll { !it.name.startsWith("framework-") }
+	javaProjects = subprojects - project(":framework-bom") - project(":framework-platform")
 }
 
 configure(allprojects) { project ->
-	apply plugin: "org.springframework.build.localdev"
-	group = "org.springframework"
 	repositories {
 		mavenCentral()
 		maven {
@@ -43,7 +41,16 @@ configure(allprojects) { project ->
 	}
 }
 
-configure(allprojects - project(":framework-platform")) {
+configure([rootProject] + javaProjects) { project ->
+	group = "org.springframework"
+
+	apply plugin: "java"
+	apply plugin: "java-test-fixtures"
+	apply plugin: "checkstyle"
+	apply plugin: 'org.springframework.build.conventions'
+	apply from: "${rootDir}/gradle/toolchains.gradle"
+	apply from: "${rootDir}/gradle/ide.gradle"
+
 	configurations {
 		dependencyManagement {
 			canBeConsumed = false
@@ -52,19 +59,36 @@ configure(allprojects - project(":framework-platform")) {
 		}
 		matching { it.name.endsWith("Classpath") }.all { it.extendsFrom(dependencyManagement) }
 	}
+
+	test {
+		useJUnitPlatform()
+		include(["**/*Tests.class", "**/*Test.class"])
+		systemProperty("java.awt.headless", "true")
+		systemProperty("testGroups", project.properties.get("testGroups"))
+		systemProperty("io.netty.leakDetection.level", "paranoid")
+		systemProperty("io.netty5.leakDetectionLevel", "paranoid")
+		systemProperty("io.netty5.leakDetection.targetRecords", "32")
+		systemProperty("io.netty5.buffer.lifecycleTracingEnabled", "true")
+		systemProperty("io.netty5.buffer.leakDetectionEnabled", "true")
+		jvmArgs(["--add-opens=java.base/java.lang=ALL-UNNAMED",
+				 "--add-opens=java.base/java.util=ALL-UNNAMED"])
+	}
+
+	checkstyle {
+		toolVersion = "10.12.7"
+		configDirectory.set(rootProject.file("src/checkstyle"))
+	}
+
+	tasks.named("checkstyleMain").configure {
+		maxHeapSize = "1g"
+	}
+
+	tasks.named("checkstyleTest").configure {
+		maxHeapSize = "1g"
+	}
+
 	dependencies {
 		dependencyManagement(enforcedPlatform(dependencies.project(path: ":framework-platform")))
-	}
-}
-
-configure([rootProject] + javaProjects) { project ->
-	apply plugin: "java"
-	apply plugin: "java-test-fixtures"
-	apply plugin: 'org.springframework.build.conventions'
-	apply from: "${rootDir}/gradle/toolchains.gradle"
-	apply from: "${rootDir}/gradle/ide.gradle"
-
-	dependencies {
 		testImplementation("org.junit.jupiter:junit-jupiter-api")
 		testImplementation("org.junit.jupiter:junit-jupiter-params")
 		testImplementation("org.junit.platform:junit-platform-suite-api")
@@ -82,34 +106,34 @@ configure([rootProject] + javaProjects) { project ->
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.41")
 	}
 
 	ext.javadocLinks = [
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
 			"https://jakarta.ee/specifications/platform/9/apidocs/",
 			"https://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/",  // CommonJ and weblogic.* packages
-			"https://www.ibm.com/docs/api/v1/content/SSEQTP_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/", // com.ibm.*
 			"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/", // org.jboss.resource.*
 			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
 			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
-			"https://fasterxml.github.io/jackson-core/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-databind/javadoc/2.14/",
-			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.14/",
+			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/2.14.1/",
+			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.14.1/",
+			"https://www.javadoc.io/doc/com.fasterxml.jackson.dataformat/jackson-dataformat-xml/2.14.1/",
 			"https://hc.apache.org/httpcomponents-client-5.2.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
 			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
 			// See https://github.com/spring-projects/spring-framework/issues/27497
 			//
-			// "https://junit.org/junit5/docs/5.10.1/api/",
+			// "https://junit.org/junit5/docs/5.9.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://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
 			// Previously there could be a split-package issue between JSR250 and JSR305 javax.annotation packages,
 			// but since 6.0 JSR 250 annotations such as @Resource and @PostConstruct have been replaced by their
 			// JakartaEE equivalents in the jakarta.annotation package.
-			//"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
+			"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
 	] as String[]
 }
 
@@ -119,5 +143,27 @@ configure(moduleProjects) { project ->
 
 configure(rootProject) {
 	description = "Spring Framework"
-	apply plugin: 'org.springframework.build.api-diff'
+
+	apply plugin: "io.spring.nohttp"
+
+	nohttp {
+		source.exclude "**/test-output/**"
+		source.exclude "**/.gradle/**"
+		allowlistFile = project.file("src/nohttp/allowlist.lines")
+		def rootPath = file(rootDir).toPath()
+		def projectDirs = allprojects.collect { it.projectDir } + "${rootDir}/buildSrc"
+		projectDirs.forEach { dir ->
+			[ 'bin', 'build', 'out', '.settings' ]
+				.collect { rootPath.relativize(new File(dir, it).toPath()) }
+				.forEach { source.exclude "$it/**" }
+			[ '.classpath', '.project' ]
+				.collect { rootPath.relativize(new File(dir, it).toPath()) }
+				.forEach { source.exclude "$it" }
+		}
+	}
+
+	tasks.named("checkstyleNohttp").configure {
+		maxHeapSize = "1g"
+	}
+
 }

buildSrc/README.md

@@ -22,21 +22,6 @@ but doesn't affect the classpath of dependent projects.
 This plugin does not provide a `provided` configuration, as the native `compileOnly` and `testCompileOnly`
 configurations are preferred.
 
-### API Diff
-
-This plugin uses the [Gradle JApiCmp](https://github.com/melix/japicmp-gradle-plugin) plugin
-to generate API Diff reports for each Spring Framework module. This plugin is applied once on the root
-project and creates tasks in each framework module. Unlike previous versions of this part of the build,
-there is no need for checking out a specific tag. The plugin will fetch the JARs we want to compare the
-current working version with. You can generate the reports for all modules or a single module:
-
-```
-./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE
-./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE
-```      
-
-The reports are located under `build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/`.
-                                                                                       
 
 ### RuntimeHints Java Agent
 

buildSrc/build.gradle

@@ -1,6 +1,5 @@
 plugins {
 	id 'java-gradle-plugin'
-	id 'checkstyle'
 }
 
 repositories {
@@ -18,29 +17,17 @@ ext {
 }
 
 dependencies {
-	checkstyle "io.spring.javaformat:spring-javaformat-checkstyle:${javaFormatVersion}"
-	implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
-	implementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}"
-	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.3.0"
-	implementation "org.gradle:test-retry-gradle-plugin:1.4.1"
-	implementation "io.spring.javaformat:spring-javaformat-gradle-plugin:${javaFormatVersion}"
-	implementation "io.spring.nohttp:nohttp-gradle:0.0.11"
+	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
+	implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}")
+	implementation "org.gradle:test-retry-gradle-plugin:1.5.6"
 }
 
 gradlePlugin {
 	plugins {
-		apiDiffPlugin {
-			id = "org.springframework.build.api-diff"
-			implementationClass = "org.springframework.build.api.ApiDiffPlugin"
-		}
 		conventionsPlugin {
 			id = "org.springframework.build.conventions"
 			implementationClass = "org.springframework.build.ConventionsPlugin"
 		}
-		localDevPlugin {
-			id = "org.springframework.build.localdev"
-			implementationClass = "org.springframework.build.dev.LocalDevelopmentPlugin"
-		}
 		optionalDependenciesPlugin {
 			id = "org.springframework.build.optional-dependencies"
 			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"

buildSrc/config/checkstyle/checkstyle.xml

@@ -1,27 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN" "https://checkstyle.org/dtds/configuration_1_3.dtd">
-<module name="com.puppycrawl.tools.checkstyle.Checker">
-
-	<!-- Root Checks -->
-	<module name="io.spring.javaformat.checkstyle.check.SpringHeaderCheck">
-		<property name="fileExtensions" value="java"/>
-		<property name="headerType" value="apache2"/>
-		<property name="headerCopyrightPattern" value="20\d\d-20\d\d"/>
-		<property name="packageInfoHeaderType" value="none"/>
-	</module>
-	<module name="com.puppycrawl.tools.checkstyle.checks.NewlineAtEndOfFileCheck"/>
-
-	<!-- TreeWalker Checks -->
-	<module name="com.puppycrawl.tools.checkstyle.TreeWalker">
-
-		<!-- Imports -->
-		<module name="com.puppycrawl.tools.checkstyle.checks.imports.UnusedImportsCheck">
-			<property name="processJavadoc" value="true"/>
-		</module>
-
-		<!-- Modifiers -->
-		<module name="com.puppycrawl.tools.checkstyle.checks.modifier.ModifierOrderCheck"/>
-
-	</module>
-
-</module>

buildSrc/gradle.properties

@@ -1,2 +1 @@
 org.gradle.caching=true
-javaFormatVersion=0.0.39

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

@@ -1,79 +0,0 @@
-/*
- * 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.
- * 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.build;
-
-import java.io.File;
-import java.nio.file.Path;
-import java.util.List;
-
-import io.spring.javaformat.gradle.SpringJavaFormatPlugin;
-import io.spring.nohttp.gradle.NoHttpExtension;
-import io.spring.nohttp.gradle.NoHttpPlugin;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.DependencySet;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.quality.Checkstyle;
-import org.gradle.api.plugins.quality.CheckstyleExtension;
-import org.gradle.api.plugins.quality.CheckstylePlugin;
-
-/**
- * {@link Plugin} that applies conventions for checkstyle.
- *
- * @author Brian Clozel
- */
-public class CheckstyleConventions {
-
-	/**
-	 * Applies the Spring Java Format and Checkstyle plugins with the project conventions.
-	 * @param project the current project
-	 */
-	public void apply(Project project) {
-		project.getPlugins().withType(JavaBasePlugin.class, (java) -> {
-			if (project.getRootProject() == project) {
-				configureNoHttpPlugin(project);
-			}
-			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.12.5");
-			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
-			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
-			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
-			checkstyleDependencies
-				.add(project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
-		});
-	}
-
-	private static void configureNoHttpPlugin(Project project) {
-		project.getPlugins().apply(NoHttpPlugin.class);
-		NoHttpExtension noHttp = project.getExtensions().getByType(NoHttpExtension.class);
-		noHttp.setAllowlistFile(project.file("src/nohttp/allowlist.lines"));
-		noHttp.getSource().exclude("**/test-output/**", "**/.settings/**",
-				"**/.classpath", "**/.project", "**/.gradle/**");
-		List<String> buildFolders = List.of("bin", "build", "out");
-		project.allprojects(subproject -> {
-			Path rootPath = project.getRootDir().toPath();
-			Path projectPath = rootPath.relativize(subproject.getProjectDir().toPath());
-			for (String buildFolder : buildFolders) {
-				Path innerBuildDir = projectPath.resolve(buildFolder);
-				noHttp.getSource().exclude(innerBuildDir + File.separator + "**");
-			}
-		});
-	}
-
-}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 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.
@@ -25,8 +25,10 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin;
  * Plugin to apply conventions to projects that are part of Spring Framework's build.
  * Conventions are applied in response to various plugins being applied.
  *
- * <p>When the {@link JavaBasePlugin} is applied, the conventions in {@link CheckstyleConventions},
- * {@link TestConventions} and {@link JavaConventions} are applied.
+ * When the {@link JavaBasePlugin} is applied, the conventions in {@link TestConventions}
+ * are applied.
+ * When the {@link JavaBasePlugin} is applied, the conventions in {@link JavaConventions}
+ * are applied.
  * When the {@link KotlinBasePlugin} is applied, the conventions in {@link KotlinConventions}
  * are applied.
  *
@@ -36,10 +38,8 @@ public class ConventionsPlugin implements Plugin<Project> {
 
 	@Override
 	public void apply(Project project) {
-		new CheckstyleConventions().apply(project);
 		new JavaConventions().apply(project);
 		new KotlinConventions().apply(project);
 		new TestConventions().apply(project);
 	}
-
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 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.
@@ -24,10 +24,7 @@ import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.compile.JavaCompile;
-import org.gradle.jvm.toolchain.JavaLanguageVersion;
-import org.gradle.jvm.toolchain.JvmVendorSpec;
 
 /**
  * {@link Plugin} that applies conventions for compiling Java sources in Spring Framework.
@@ -71,10 +68,6 @@ public class JavaConventions {
 	 * @param project the current project
 	 */
 	private void applyJavaCompileConventions(Project project) {
-		project.getExtensions().getByType(JavaPluginExtension.class).toolchain(toolchain -> {
-			toolchain.getVendor().set(JvmVendorSpec.BELLSOFT);
-			toolchain.getLanguageVersion().set(JavaLanguageVersion.of(17));
-		});
 		project.getTasks().withType(JavaCompile.class)
 				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
 				.forEach(compileTask -> {

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

@@ -16,8 +16,6 @@
 
 package org.springframework.build;
 
-import java.util.Map;
-
 import org.gradle.api.Project;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.tasks.testing.Test;
@@ -43,36 +41,11 @@ class TestConventions {
 
 	private void configureTestConventions(Project project) {
 		project.getTasks().withType(Test.class,
-				test -> {
-					configureTests(project, test);
-					configureTestRetryPlugin(project, test);
-				});
-	}
-
-	private void configureTests(Project project, Test test) {
-		test.useJUnitPlatform();
-		test.include("**/*Tests.class", "**/*Test.class");
-		test.setSystemProperties(Map.of(
-				"java.awt.headless", "true",
-				"io.netty.leakDetection.level", "paranoid",
-				"io.netty5.leakDetectionLevel", "paranoid",
-				"io.netty5.leakDetection.targetRecords", "32",
-				"io.netty5.buffer.lifecycleTracingEnabled", "true"
-		));
-		if (project.hasProperty("testGroups")) {
-			test.systemProperty("testGroups", project.getProperties().get("testGroups"));
-		}
-		test.jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED",
-				"--add-opens=java.base/java.util=ALL-UNNAMED",
-				"-Djava.locale.providers=COMPAT");
-	}
-
-	private void configureTestRetryPlugin(Project project, Test test) {
-		project.getPlugins().withType(TestRetryPlugin.class, testRetryPlugin -> {
-			TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
-			testRetry.getFailOnPassedAfterRetry().set(true);
-			testRetry.getMaxRetries().set(isCi() ? 3 : 0);
-		});
+				test -> project.getPlugins().withType(TestRetryPlugin.class, testRetryPlugin -> {
+					TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
+					testRetry.getFailOnPassedAfterRetry().set(true);
+					testRetry.getMaxRetries().set(isCi() ? 3 : 0);
+				}));
 	}
 
 	private boolean isCi() {

buildSrc/src/main/java/org/springframework/build/api/ApiDiffPlugin.java

@@ -1,142 +0,0 @@
-/*
- * 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.
- * 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.build.api;
-
-import java.io.File;
-import java.net.URI;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Collections;
-import java.util.List;
-
-import me.champeau.gradle.japicmp.JapicmpPlugin;
-import me.champeau.gradle.japicmp.JapicmpTask;
-import org.gradle.api.GradleException;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
-import org.gradle.api.tasks.TaskProvider;
-import org.gradle.jvm.tasks.Jar;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * {@link Plugin} that applies the {@code "japicmp-gradle-plugin"}
- * and create tasks for all subprojects named {@code "spring-*"}, diffing the public API one by one
- * and creating the reports in {@code "build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/"}.
- * <p>{@code "./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE"} will output the
- * reports for the API diff between the baseline version and the current one for all modules.
- * You can limit the report to a single module with
- * {@code "./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE"}.
- *
- * @author Brian Clozel
- */
-public class ApiDiffPlugin implements Plugin<Project> {
-
-	private static final Logger logger = LoggerFactory.getLogger(ApiDiffPlugin.class);
-
-	public static final String TASK_NAME = "apiDiff";
-
-	private static final String BASELINE_VERSION_PROPERTY = "baselineVersion";
-
-	private static final List<String> PACKAGE_INCLUDES = Collections.singletonList("org.springframework.*");
-
-	private static final URI SPRING_MILESTONE_REPOSITORY = URI.create("https://repo.spring.io/milestone");
-
-	@Override
-	public void apply(Project project) {
-		if (project.hasProperty(BASELINE_VERSION_PROPERTY) && project.equals(project.getRootProject())) {
-			project.getPluginManager().apply(JapicmpPlugin.class);
-			project.getPlugins().withType(JapicmpPlugin.class,
-					plugin -> applyApiDiffConventions(project));
-		}
-	}
-
-	private void applyApiDiffConventions(Project project) {
-		String baselineVersion = project.property(BASELINE_VERSION_PROPERTY).toString();
-		project.subprojects(subProject -> {
-			if (subProject.getName().startsWith("spring-")) {
-				createApiDiffTask(baselineVersion, subProject);
-			}
-		});
-	}
-
-	private void createApiDiffTask(String baselineVersion, Project project) {
-		if (isProjectEligible(project)) {
-			// Add Spring Milestone repository for generating diffs against previous milestones
-			project.getRootProject()
-					.getRepositories()
-					.maven(mavenArtifactRepository -> mavenArtifactRepository.setUrl(SPRING_MILESTONE_REPOSITORY));
-			JapicmpTask apiDiff = project.getTasks().create(TASK_NAME, JapicmpTask.class);
-			apiDiff.setDescription("Generates an API diff report with japicmp");
-			apiDiff.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP);
-
-			apiDiff.setOldClasspath(createBaselineConfiguration(baselineVersion, project));
-			TaskProvider<Jar> jar = project.getTasks().withType(Jar.class).named("jar");
-			apiDiff.setNewArchives(project.getLayout().files(jar.get().getArchiveFile().get().getAsFile()));
-			apiDiff.setNewClasspath(getRuntimeClassPath(project));
-			apiDiff.setPackageIncludes(PACKAGE_INCLUDES);
-			apiDiff.setOnlyModified(true);
-			apiDiff.setIgnoreMissingClasses(true);
-			// Ignore Kotlin metadata annotations since they contain
-			// illegal HTML characters and fail the report generation
-			apiDiff.setAnnotationExcludes(Collections.singletonList("@kotlin.Metadata"));
-
-			apiDiff.setHtmlOutputFile(getOutputFile(baselineVersion, project));
-
-			apiDiff.dependsOn(project.getTasks().getByName("jar"));
-		}
-	}
-
-	private boolean isProjectEligible(Project project) {
-		return project.getPlugins().hasPlugin(JavaPlugin.class)
-				&& project.getPlugins().hasPlugin(MavenPublishPlugin.class);
-	}
-
-	private Configuration createBaselineConfiguration(String baselineVersion, Project project) {
-		String baseline = String.join(":",
-				project.getGroup().toString(), project.getName(), baselineVersion);
-		Dependency baselineDependency = project.getDependencies().create(baseline + "@jar");
-		Configuration baselineConfiguration = project.getRootProject().getConfigurations().detachedConfiguration(baselineDependency);
-		try {
-			// eagerly resolve the baseline configuration to check whether this is a new Spring module
-			baselineConfiguration.resolve();
-			return baselineConfiguration;
-		}
-		catch (GradleException exception) {
-			logger.warn("Could not resolve {} - assuming this is a new Spring module.", baseline);
-		}
-		return project.getRootProject().getConfigurations().detachedConfiguration();
-	}
-
-	private Configuration getRuntimeClassPath(Project project) {
-		return project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME);
-	}
-
-	private File getOutputFile(String baseLineVersion, Project project) {
-		String buildDirectoryPath = project.getRootProject()
-				.getLayout().getBuildDirectory().getAsFile().get().getAbsolutePath();
-		Path outDir = Paths.get(buildDirectoryPath, "reports", "api-diff",
-				baseLineVersion + "_to_" + project.getRootProject().getVersion());
-		return project.file(outDir.resolve(project.getName() + ".html").toString());
-	}
-
-}

buildSrc/src/main/java/org/springframework/build/dev/LocalDevelopmentPlugin.java

@@ -1,49 +0,0 @@
-/*
- * 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.
- * 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.build.dev;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaBasePlugin;
-
-/**
- * {@link Plugin} that skips documentation tasks when the {@code "-PskipDocs"} property is defined.
- *
- * @author Brian Clozel
- */
-public class LocalDevelopmentPlugin implements Plugin<Project> {
-
-	private static final String SKIP_DOCS_PROPERTY = "skipDocs";
-
-	@Override
-	public void apply(Project target) {
-		if (target.hasProperty(SKIP_DOCS_PROPERTY)) {
-			skipDocumentationTasks(target);
-			target.subprojects(this::skipDocumentationTasks);
-		}
-	}
-
-	private void skipDocumentationTasks(Project project) {
-		project.afterEvaluate(p -> {
-			p.getTasks().matching(task -> {
-						return JavaBasePlugin.DOCUMENTATION_GROUP.equals(task.getGroup())
-								|| "distribution".equals(task.getGroup());
-					})
-					.forEach(task -> task.setEnabled(false));
-		});
-	}
-}

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

@@ -1,48 +0,0 @@
-/*
- * 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.
- * 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.build.hint;
-
-import java.util.Collections;
-
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.provider.SetProperty;
-import org.gradle.api.tasks.Classpath;
-import org.gradle.api.tasks.Input;
-import org.gradle.process.CommandLineArgumentProvider;
-
-/**
- * Argument provider for registering the runtime hints agent with a Java process.
- */
-public interface RuntimeHintsAgentArgumentProvider extends CommandLineArgumentProvider {
-
-	@Classpath
-	ConfigurableFileCollection getAgentJar();
-
-    @Input
-    SetProperty<String> getIncludedPackages();
-
-    @Input
-    SetProperty<String> getExcludedPackages();
-
-    @Override
-    default Iterable<String> asArguments() {
-        StringBuilder packages = new StringBuilder();
-        getIncludedPackages().get().forEach(packageName -> packages.append('+').append(packageName).append(','));
-        getExcludedPackages().get().forEach(packageName -> packages.append('-').append(packageName).append(','));
-        return Collections.singleton("-javaagent:" + getAgentJar().getSingleFile() + "=" + packages);
-    }
-}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 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.
@@ -16,15 +16,38 @@
 
 package org.springframework.build.hint;
 
+import java.util.Collections;
+
+import org.gradle.api.model.ObjectFactory;
 import org.gradle.api.provider.SetProperty;
 
 /**
  * Entry point to the DSL extension for the {@link RuntimeHintsAgentPlugin} Gradle plugin.
  * @author Brian Clozel
  */
-public interface RuntimeHintsAgentExtension {
+public class RuntimeHintsAgentExtension {
 
-	SetProperty<String> getIncludedPackages();
+	private final SetProperty<String> includedPackages;
 
-	SetProperty<String> getExcludedPackages();
+	private final SetProperty<String> excludedPackages;
+
+	public RuntimeHintsAgentExtension(ObjectFactory objectFactory) {
+		this.includedPackages = objectFactory.setProperty(String.class).convention(Collections.singleton("org.springframework"));
+		this.excludedPackages = objectFactory.setProperty(String.class).convention(Collections.emptySet());
+	}
+
+	public SetProperty<String> getIncludedPackages() {
+		return this.includedPackages;
+	}
+
+	public SetProperty<String> getExcludedPackages() {
+		return this.excludedPackages;
+	}
+
+	String asJavaAgentArgument() {
+		StringBuilder builder = new StringBuilder();
+		this.includedPackages.get().forEach(packageName -> builder.append('+').append(packageName).append(','));
+		this.excludedPackages.get().forEach(packageName -> builder.append('-').append(packageName).append(','));
+		return builder.toString();
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 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.
@@ -16,79 +16,41 @@
 
 package org.springframework.build.hint;
 
-import org.gradle.api.JavaVersion;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.attributes.Bundling;
-import org.gradle.api.attributes.Category;
-import org.gradle.api.attributes.LibraryElements;
-import org.gradle.api.attributes.Usage;
-import org.gradle.api.attributes.java.TargetJvmVersion;
 import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.tasks.bundling.Jar;
 import org.gradle.api.tasks.testing.Test;
 
-import java.util.Collections;
-
 /**
  * {@link Plugin} that configures the {@code RuntimeHints} Java agent to test tasks.
  *
  * @author Brian Clozel
- * @author Sebastien Deleuze
  */
 public class RuntimeHintsAgentPlugin implements Plugin<Project> {
 
 	public static final String RUNTIMEHINTS_TEST_TASK = "runtimeHintsTest";
 	private static final String EXTENSION_NAME = "runtimeHintsAgent";
-	private static final String CONFIGURATION_NAME = "testRuntimeHintsAgentJar";
 
 
 	@Override
 	public void apply(Project project) {
 
 		project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
-			RuntimeHintsAgentExtension agentExtension = createRuntimeHintsAgentExtension(project);
+			RuntimeHintsAgentExtension agentExtension = project.getExtensions().create(EXTENSION_NAME,
+					RuntimeHintsAgentExtension.class, project.getObjects());
 			Test agentTest = project.getTasks().create(RUNTIMEHINTS_TEST_TASK, Test.class, test -> {
 				test.useJUnitPlatform(options -> {
 					options.includeTags("RuntimeHintsTests");
 				});
 				test.include("**/*Tests.class", "**/*Test.class");
 				test.systemProperty("java.awt.headless", "true");
-				test.systemProperty("org.graalvm.nativeimage.imagecode", "runtime");
-				test.getJvmArgumentProviders().add(createRuntimeHintsAgentArgumentProvider(project, agentExtension));
+			});
+			project.afterEvaluate(p -> {
+				Jar jar = project.getRootProject().project("spring-core-test").getTasks().withType(Jar.class).named("jar").get();
+				agentTest.jvmArgs("-javaagent:" + jar.getArchiveFile().get().getAsFile() + "=" + agentExtension.asJavaAgentArgument());
 			});
 			project.getTasks().getByName("check", task -> task.dependsOn(agentTest));
-			project.getDependencies().add(CONFIGURATION_NAME, project.project(":spring-core-test"));
-		});
-	}
-
-	private static RuntimeHintsAgentExtension createRuntimeHintsAgentExtension(Project project) {
-		RuntimeHintsAgentExtension agentExtension = project.getExtensions().create(EXTENSION_NAME, RuntimeHintsAgentExtension.class);
-		agentExtension.getIncludedPackages().convention(Collections.singleton("org.springframework"));
-		agentExtension.getExcludedPackages().convention(Collections.emptySet());
-		return agentExtension;
-	}
-
-	private static RuntimeHintsAgentArgumentProvider createRuntimeHintsAgentArgumentProvider(
-			Project project, RuntimeHintsAgentExtension agentExtension) {
-		RuntimeHintsAgentArgumentProvider agentArgumentProvider = project.getObjects().newInstance(RuntimeHintsAgentArgumentProvider.class);
-		agentArgumentProvider.getAgentJar().from(createRuntimeHintsAgentConfiguration(project));
-		agentArgumentProvider.getIncludedPackages().set(agentExtension.getIncludedPackages());
-		agentArgumentProvider.getExcludedPackages().set(agentExtension.getExcludedPackages());
-		return agentArgumentProvider;
-	}
-
-	private static Configuration createRuntimeHintsAgentConfiguration(Project project) {
-		return project.getConfigurations().create(CONFIGURATION_NAME, configuration -> {
-			configuration.setCanBeConsumed(false);
-			configuration.setTransitive(false); // Only the built artifact is required
-			configuration.attributes(attributes -> {
-				attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, project.getObjects().named(Bundling.class, Bundling.EXTERNAL));
-				attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, Category.LIBRARY));
-				attributes.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.getObjects().named(LibraryElements.class, LibraryElements.JAR));
-				attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, Integer.valueOf(JavaVersion.current().getMajorVersion()));
-				attributes.attribute(Usage.USAGE_ATTRIBUTE, project.getObjects().named(Usage.class, Usage.JAVA_RUNTIME));
-			});
 		});
 	}
 }

buildSrc/src/main/java/org/springframework/build/optional/OptionalDependenciesPlugin.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2021 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,7 @@ package org.springframework.build.optional;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.SourceSetContainer;
 
@@ -40,10 +40,10 @@ public class OptionalDependenciesPlugin implements Plugin<Project> {
 
 	@Override
 	public void apply(Project project) {
-		Configuration optional = project.getConfigurations().create(OPTIONAL_CONFIGURATION_NAME);
+		Configuration optional = project.getConfigurations().create("optional");
 		optional.setCanBeConsumed(false);
 		optional.setCanBeResolved(false);
-		project.getPlugins().withType(JavaBasePlugin.class, (javaBasePlugin) -> {
+		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> {
 			SourceSetContainer sourceSets = project.getExtensions().getByType(JavaPluginExtension.class)
 					.getSourceSets();
 			sourceSets.all((sourceSet) -> {
@@ -53,4 +53,4 @@ public class OptionalDependenciesPlugin implements Plugin<Project> {
 		});
 	}
 
-}
+}

buildSrc/src/main/java/org/springframework/build/shadow/ShadowSource.java

@@ -1,19 +1,3 @@
-/*
- * 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.
- * 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.build.shadow;
 
 import java.io.File;

ci/README.adoc

@@ -1,5 +1,7 @@
 == Spring Framework Concourse pipeline
 
+NOTE: CI is being migrated to GitHub Actions.
+
 The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
 The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
 for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].

ci/images/ci-image/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:jammy-20231004
+FROM ubuntu:jammy-20240125
 
 ADD setup.sh /setup.sh
 ADD get-jdk-url.sh /get-jdk-url.sh
@@ -6,7 +6,5 @@ RUN ./setup.sh
 
 ENV JAVA_HOME /opt/openjdk/java17
 ENV JDK17 /opt/openjdk/java17
-ENV JDK21 /opt/openjdk/java21
-ENV JDK22 /opt/openjdk/java22
 
 ENV PATH $JAVA_HOME/bin:$PATH

ci/images/get-jdk-url.sh

@@ -3,13 +3,7 @@ set -e
 
 case "$1" in
 	java17)
-		echo "https://download.bell-sw.com/java/17.0.9+11/bellsoft-jdk17.0.9+11-linux-amd64.tar.gz"
-	;;
-	java21)
-		echo "https://download.bell-sw.com/java/21.0.1+12/bellsoft-jdk21.0.1+12-linux-amd64.tar.gz"
-	;;
-	java22)
-		echo "https://download.java.net/java/early_access/jdk22/19/GPL/openjdk-22-ea+19_linux-x64_bin.tar.gz"
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.10%2B13/bellsoft-jdk17.0.10+13-linux-amd64.tar.gz"
 	;;
 	*)
 		echo $"Unknown java version"

ci/images/setup.sh

@@ -20,7 +20,7 @@ curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/c
 
 mkdir -p /opt/openjdk
 pushd /opt/openjdk > /dev/null
-for jdk in java17 java21 java22
+for jdk in java17
 do
   JDK_URL=$( /get-jdk-url.sh $jdk )
   mkdir $jdk

ci/parameters.yml

@@ -3,9 +3,8 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "main"
-milestone: "6.1.x"
+branch: "6.0.x"
+milestone: "6.0.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
-task-timeout: 1h00m

ci/pipeline.yml

@@ -23,14 +23,6 @@ anchors:
   docker-resource-source: &docker-resource-source
     username: ((docker-hub-username))
     password: ((docker-hub-password))
-  slack-fail-params: &slack-fail-params
-    text: >
-      :concourse-failed: <https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}|${BUILD_PIPELINE_NAME} ${BUILD_JOB_NAME} failed!>
-      [$TEXT_FILE_CONTENT]
-    text_file: git-repo/build/build-scan-uri.txt
-    silent: true
-    icon_emoji: ":concourse:"
-    username: concourse-ci
   changelog-task-params: &changelog-task-params
     name: generated-changelog/tag
     tag: generated-changelog/tag
@@ -64,12 +56,6 @@ resource_types:
     <<: *docker-resource-source
     repository: dpb587/github-status-resource
     tag: master
-- name: slack-notification
-  type: registry-image
-  source:
-    <<: *docker-resource-source
-    repository: cfcommunity/slack-notification-resource
-    tag: latest
 resources:
 - name: git-repo
   type: git
@@ -90,13 +76,6 @@ resources:
     <<: *docker-resource-source
     repository: ((docker-hub-organization))/spring-framework-ci
     tag: ((milestone))
-- name: every-morning
-  type: time
-  icon: alarm
-  source:
-    start: 8:00 AM
-    stop: 9:00 AM
-    location: Europe/Vienna
 - name: artifactory-repo
   type: artifactory-resource
   icon: package-variant
@@ -105,35 +84,6 @@ resources:
     username: ((artifactory-username))
     password: ((artifactory-password))
     build_name: ((build-name))
-- name: repo-status-build
-  type: github-status-resource
-  icon: eye-check-outline
-  source:
-    repository: ((github-repo-name))
-    access_token: ((github-ci-status-token))
-    branch: ((branch))
-    context: build
-- name: repo-status-jdk21-build
-  type: github-status-resource
-  icon: eye-check-outline
-  source:
-    repository: ((github-repo-name))
-    access_token: ((github-ci-status-token))
-    branch: ((branch))
-    context: jdk21-build
-- name: repo-status-jdk22-build
-  type: github-status-resource
-  icon: eye-check-outline
-  source:
-    repository: ((github-repo-name))
-    access_token: ((github-ci-status-token))
-    branch: ((branch))
-    context: jdk22-build
-- name: slack-alert
-  type: slack-notification
-  icon: slack
-  source:
-    url: ((slack-webhook-url))
 - name: github-pre-release
   type: github-release
   icon: briefcase-download-outline
@@ -168,37 +118,23 @@ jobs:
     - put: ci-image
       params:
         image: ci-image/image.tar
-- name: build
+- name: stage-milestone
   serial: true
-  public: true
   plan:
   - get: ci-image
   - get: git-repo
-    trigger: true
-  - put: repo-status-build
-    params: { state: "pending", commit: "git-repo" }
-  - do:
-    - task: build-project
-      image: ci-image
-      file: git-repo/ci/tasks/build-project.yml
-      privileged: true
-      timeout: ((task-timeout))
-      params:
-        <<: *build-project-task-params
-    on_failure:
-      do:
-      - put: repo-status-build
-        params: { state: "failure", commit: "git-repo" }
-      - put: slack-alert
-        params:
-          <<: *slack-fail-params
-  - put: repo-status-build
-    params: { state: "success", commit: "git-repo" }
+    trigger: false
+  - task: stage
+    image: ci-image
+    file: git-repo/ci/tasks/stage-version.yml
+    params:
+      RELEASE_TYPE: M
+      <<: *gradle-enterprise-task-params
   - put: artifactory-repo
     params: &artifactory-params
       signing_key: ((signing-key))
       signing_passphrase: ((signing-passphrase))
-      repo: libs-snapshot-local
+      repo: libs-staging-local
       folder: distribution-repository
       build_uri: "https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}"
       build_number: "${BUILD_PIPELINE_NAME}-${BUILD_JOB_NAME}-${BUILD_NAME}"
@@ -206,94 +142,26 @@ jobs:
       threads: 8
       artifact_set:
       - include:
-        - "/**/framework-api-*.zip"
+        - "/**/framework-docs-*.zip"
         properties:
           "zip.name": "spring-framework"
           "zip.displayname": "Spring Framework"
           "zip.deployed": "false"
       - include:
-        - "/**/framework-api-*-docs.zip"
+        - "/**/framework-docs-*-docs.zip"
         properties:
           "zip.type": "docs"
       - include:
-        - "/**/framework-api-*-schema.zip"
+        - "/**/framework-docs-*-dist.zip"
+        properties:
+          "zip.type": "dist"
+      - include:
+        - "/**/framework-docs-*-schema.zip"
         properties:
           "zip.type": "schema"
-    get_params:
-      threads: 8
-- name: jdk21-build
-  serial: true
-  public: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-    - get: every-morning
-      trigger: true
-    - put: repo-status-jdk21-build
-      params: { state: "pending", commit: "git-repo" }
-    - do:
-        - task: check-project
-          image: ci-image
-          file: git-repo/ci/tasks/check-project.yml
-          privileged: true
-          timeout: ((task-timeout))
-          params:
-            TEST_TOOLCHAIN: 21
-            <<: *build-project-task-params
-      on_failure:
-        do:
-          - put: repo-status-jdk21-build
-            params: { state: "failure", commit: "git-repo" }
-          - put: slack-alert
-            params:
-              <<: *slack-fail-params
-    - put: repo-status-jdk21-build
-      params: { state: "success", commit: "git-repo" }
-- name: jdk22-build
-  serial: true
-  public: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-    - put: repo-status-jdk22-build
-      params: { state: "pending", commit: "git-repo" }
-    - do:
-        - task: check-project
-          image: ci-image
-          file: git-repo/ci/tasks/check-project.yml
-          privileged: true
-          timeout: ((task-timeout))
-          params:
-            TEST_TOOLCHAIN: 22
-            <<: *build-project-task-params
-      on_failure:
-        do:
-          - put: repo-status-jdk22-build
-            params: { state: "failure", commit: "git-repo" }
-          - put: slack-alert
-            params:
-              <<: *slack-fail-params
-    - put: repo-status-jdk22-build
-      params: { state: "success", commit: "git-repo" }
-- name: stage-milestone
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      trigger: false
-    - task: stage
-      image: ci-image
-      file: git-repo/ci/tasks/stage-version.yml
-      params:
-        RELEASE_TYPE: M
-        <<: *gradle-enterprise-task-params
-    - put: artifactory-repo
-      params:
-        <<: *artifactory-params
-        repo: libs-staging-local
-    - put: git-repo
-      params:
-        repository: stage-git-repo
+  - put: git-repo
+    params:
+      repository: stage-git-repo
 - name: promote-milestone
   serial: true
   plan:
@@ -335,7 +203,6 @@ jobs:
     - put: artifactory-repo
       params:
         <<: *artifactory-params
-        repo: libs-staging-local
     - put: git-repo
       params:
         repository: stage-git-repo
@@ -380,7 +247,6 @@ jobs:
     - put: artifactory-repo
       params:
         <<: *artifactory-params
-        repo: libs-staging-local
     - put: git-repo
       params:
         repository: stage-git-repo
@@ -425,8 +291,6 @@ jobs:
         <<: *changelog-task-params
 
 groups:
-- name: "builds"
-  jobs: ["build", "jdk21-build", "jdk22-build"]
 - name: "releases"
   jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
 - name: "ci-images"

ci/scripts/build-pr.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-set -e
-
-source $(dirname $0)/common.sh
-
-pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
-  --no-daemon --max-workers=4 check
-popd > /dev/null

ci/scripts/build-project.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-set -e
-
-source $(dirname $0)/common.sh
-repository=$(pwd)/distribution-repository
-
-pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21,JDK22 \
-  --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
-popd > /dev/null

ci/scripts/check-project.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-set -e
-
-source $(dirname $0)/common.sh
-
-pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
-  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check antora
-popd > /dev/null

ci/scripts/stage-version.sh

@@ -35,8 +35,7 @@ git add gradle.properties > /dev/null
 git commit -m"Release v$stageVersion" > /dev/null
 git tag -a "v$stageVersion" -m"Release v$stageVersion" > /dev/null
 
-./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
-  build publishAllPublicationsToDeploymentRepository
+./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
 
 git reset --hard HEAD^ > /dev/null
 if [[ $nextVersion != $snapshotVersion ]]; then

ci/tasks/build-pr.yml

@@ -1,19 +0,0 @@
----
-platform: linux
-inputs:
-- name: git-repo
-caches:
-- path: gradle
-params:
-  BRANCH:
-  CI: true
-  GRADLE_ENTERPRISE_ACCESS_KEY:
-  GRADLE_ENTERPRISE_CACHE_USERNAME:
-  GRADLE_ENTERPRISE_CACHE_PASSWORD:
-  GRADLE_ENTERPRISE_URL: https://ge.spring.io
-run:
-  path: bash
-  args:
-    - -ec
-    - |
-      ${PWD}/git-repo/ci/scripts/build-pr.sh

ci/tasks/build-project.yml

@@ -1,22 +0,0 @@
----
-platform: linux
-inputs:
-- name: git-repo
-outputs:
-- name: distribution-repository
-- name: git-repo
-caches:
-- path: gradle
-params:
-  BRANCH:
-  CI: true
-  GRADLE_ENTERPRISE_ACCESS_KEY:
-  GRADLE_ENTERPRISE_CACHE_USERNAME:
-  GRADLE_ENTERPRISE_CACHE_PASSWORD:
-  GRADLE_ENTERPRISE_URL: https://ge.spring.io
-run:
-  path: bash
-  args:
-    - -ec
-    - |
-      ${PWD}/git-repo/ci/scripts/build-project.sh

ci/tasks/check-project.yml

@@ -1,24 +0,0 @@
----
-platform: linux
-inputs:
-- name: git-repo
-outputs:
-- name: distribution-repository
-- name: git-repo
-caches:
-- path: gradle
-params:
-  BRANCH:
-  CI: true
-  MAIN_TOOLCHAIN:
-  TEST_TOOLCHAIN:
-  GRADLE_ENTERPRISE_ACCESS_KEY:
-  GRADLE_ENTERPRISE_CACHE_USERNAME:
-  GRADLE_ENTERPRISE_CACHE_PASSWORD:
-  GRADLE_ENTERPRISE_URL: https://ge.spring.io
-run:
-  path: bash
-  args:
-    - -ec
-    - |
-      ${PWD}/git-repo/ci/scripts/check-project.sh

framework-api/framework-api.gradle

@@ -1,119 +0,0 @@
-plugins {
-	id 'java-platform'
-	id 'io.freefair.aggregate-javadoc' version '8.3'
-}
-
-description = "Spring Framework API Docs"
-
-apply from: "${rootDir}/gradle/publications.gradle"
-
-repositories {
-	maven {
-		url "https://repo.spring.io/release"
-	}
-}
-
-dependencies {
-	moduleProjects.each { moduleProject ->
-		javadoc moduleProject
-	}
-}
-
-javadoc {
-	title = "${rootProject.description} ${version} API"
-	options {
-		encoding = "UTF-8"
-		memberLevel = JavadocMemberLevel.PROTECTED
-		author = true
-		header = rootProject.description
-		use = true
-		overview = "$rootProject.rootDir/framework-docs/src/docs/api/overview.html"
-		destinationDir = file("${project.buildDir}/docs/javadoc-api")
-		splitIndex = true
-		links(rootProject.ext.javadocLinks)
-		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
-		addBooleanOption('Werror', true) // fail build on Javadoc warnings
-	}
-	maxMemory = "1024m"
-	doFirst {
-		classpath += files(
-				// ensure the javadoc process can resolve types compiled from .aj sources
-				project(":spring-aspects").sourceSets.main.output
-		)
-		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-	}
-}
-
-/**
- * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
- */
-rootProject.tasks.dokkaHtmlMultiModule.configure {
-	dependsOn {
-		tasks.named("javadoc")
-	}
-	moduleName.set("spring-framework")
-	outputDirectory.set(project.file("$buildDir/docs/kdoc-api"))
-	includes.from("$rootProject.rootDir/framework-docs/src/docs/api/dokka-overview.md")
-}
-
-/**
- * Zip all Java docs (javadoc & kdoc) into a single archive
- */
-tasks.register('docsZip', Zip) {
-	dependsOn = ['javadoc', rootProject.tasks.dokkaHtmlMultiModule]
-	group = "distribution"
-	description = "Builds -${archiveClassifier} archive containing api and reference " +
-			"for deployment at https://docs.spring.io/spring-framework/docs/."
-
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("docs")
-	from("src/dist") {
-		include "changelog.txt"
-	}
-	from(javadoc) {
-		into "javadoc-api"
-	}
-	from(rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
-		into "kdoc-api"
-	}
-}
-
-/**
- * Zip all Spring Framework schemas into a single archive
- */
-tasks.register('schemaZip', Zip) {
-	group = "distribution"
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("schema")
-	description = "Builds -${archiveClassifier} archive containing all " +
-			"XSDs for deployment at https://springframework.org/schema."
-	duplicatesStrategy DuplicatesStrategy.EXCLUDE
-	moduleProjects.each { module ->
-		def Properties schemas = new Properties();
-
-		module.sourceSets.main.resources.find {
-			(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
-		}?.withInputStream { schemas.load(it) }
-
-		for (def key : schemas.keySet()) {
-			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
-			assert shortName != key
-			File xsdFile = module.sourceSets.main.resources.find {
-				(it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/', '\\\\')))
-			}
-			assert xsdFile != null
-			into(shortName) {
-				from xsdFile.path
-			}
-		}
-	}
-}
-
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			artifact docsZip
-			artifact schemaZip
-		}
-	}
-}

framework-docs/framework-docs.gradle

@@ -6,9 +6,9 @@ plugins {
 
 description = "Spring Framework Docs"
 
-apply from: "${rootDir}/gradle/ide.gradle"
 apply from: "${rootDir}/gradle/publications.gradle"
 
+
 antora {
 	version = '3.2.0-alpha.2'
 	playbook = 'cached-antora-playbook.yml'
@@ -34,16 +34,23 @@ antora {
 	]
 }
 
+
 tasks.named("generateAntoraYml") {
 	asciidocAttributes = project.provider( {
 		return  ["spring-version": project.version ]
 	} )
 }
 
-tasks.register("generateAntoraResources") {
+tasks.create("generateAntoraResources") {
 	dependsOn 'generateAntoraYml'
 }
 
+// Commented out for now:
+// https://github.com/spring-projects/spring-framework/issues/30481
+// tasks.named("check") {
+//	dependsOn 'antora'
+// }
+
 jar {
 	enabled = false
 }
@@ -60,11 +67,166 @@ repositories {
 
 dependencies {
 	api(project(":spring-context"))
-	api(project(":spring-jms"))
 	api(project(":spring-web"))
-	api("jakarta.jms:jakarta.jms-api")
 	api("jakarta.servlet:jakarta.servlet-api")
 
 	implementation(project(":spring-core-test"))
 	implementation("org.assertj:assertj-core")
 }
+
+/**
+ * Produce Javadoc for all Spring Framework modules in "build/docs/javadoc"
+ */
+task api(type: Javadoc) {
+	group = "Documentation"
+	description = "Generates aggregated Javadoc API documentation."
+	title = "${rootProject.description} ${version} API"
+
+	dependsOn {
+		moduleProjects.collect {
+			it.tasks.getByName("jar")
+		}
+	}
+	doFirst {
+		classpath = files(
+				// ensure the javadoc process can resolve types compiled from .aj sources
+				project(":spring-aspects").sourceSets.main.output
+		)
+		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
+	}
+
+	options {
+		encoding = "UTF-8"
+		memberLevel = JavadocMemberLevel.PROTECTED
+		author = true
+		header = rootProject.description
+		use = true
+		overview = "framework-docs/src/docs/api/overview.html"
+		splitIndex = true
+		links(project.ext.javadocLinks)
+		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
+		addBooleanOption('Werror', true) // fail build on Javadoc warnings
+	}
+	source moduleProjects.collect { project ->
+		project.sourceSets.main.allJava
+	}
+	maxMemory = "1024m"
+	destinationDir = file("$buildDir/docs/javadoc")
+}
+
+/**
+ * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
+ */
+rootProject.tasks.dokkaHtmlMultiModule.configure {
+	dependsOn {
+		tasks.getByName("api")
+	}
+	moduleName.set("spring-framework")
+	outputDirectory.set(project.file("$buildDir/docs/kdoc"))
+}
+
+/**
+ * Zip all Java docs (javadoc & kdoc) into a single archive
+ */
+task docsZip(type: Zip, dependsOn: ['api', rootProject.tasks.dokkaHtmlMultiModule]) {
+	group = "Distribution"
+	description = "Builds -${archiveClassifier} archive containing api and reference " +
+			"for deployment at https://docs.spring.io/spring-framework/docs/."
+
+	archiveBaseName.set("spring-framework")
+	archiveClassifier.set("docs")
+	from("src/dist") {
+		include "changelog.txt"
+	}
+	from (api) {
+		into "javadoc-api"
+	}
+	from (rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
+		into "kdoc-api"
+	}
+}
+
+/**
+ * Zip all Spring Framework schemas into a single archive
+ */
+task schemaZip(type: Zip) {
+	group = "Distribution"
+	archiveBaseName.set("spring-framework")
+	archiveClassifier.set("schema")
+	description = "Builds -${archiveClassifier} archive containing all " +
+			"XSDs for deployment at https://springframework.org/schema."
+	duplicatesStrategy DuplicatesStrategy.EXCLUDE
+	moduleProjects.each { module ->
+		def Properties schemas = new Properties();
+
+		module.sourceSets.main.resources.find {
+			(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
+		}?.withInputStream { schemas.load(it) }
+
+		for (def key : schemas.keySet()) {
+			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
+			assert shortName != key
+			File xsdFile = module.sourceSets.main.resources.find {
+				(it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/','\\\\')))
+			}
+			assert xsdFile != null
+			into (shortName) {
+				from xsdFile.path
+			}
+		}
+	}
+}
+
+/**
+ * Create a distribution zip with everything:
+ * docs, schemas, jars, source jars, javadoc jars
+ */
+task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
+	group = "Distribution"
+	archiveBaseName.set("spring-framework")
+	archiveClassifier.set("dist")
+	description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +
+			"suitable for community download page."
+
+	ext.baseDir = "spring-framework-${project.version}";
+
+	from("src/docs/dist") {
+		include "readme.txt"
+		include "license.txt"
+		include "notice.txt"
+		into "${baseDir}"
+		expand(copyright: new Date().format("yyyy"), version: project.version)
+	}
+
+	from(zipTree(docsZip.archiveFile)) {
+		into "${baseDir}/docs"
+	}
+
+	from(zipTree(schemaZip.archiveFile)) {
+		into "${baseDir}/schema"
+	}
+
+	moduleProjects.each { module ->
+		into ("${baseDir}/libs") {
+			from module.jar
+			if (module.tasks.findByPath("sourcesJar")) {
+				from module.sourcesJar
+			}
+			if (module.tasks.findByPath("javadocJar")) {
+				from module.javadocJar
+			}
+		}
+	}
+}
+
+distZip.mustRunAfter moduleProjects.check
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifact docsZip
+			artifact schemaZip
+			artifact distZip
+		}
+	}
+}

framework-docs/modules/ROOT/nav.adoc

@@ -39,8 +39,8 @@
 ** xref:core/resources.adoc[]
 ** xref:core/validation.adoc[]
 *** xref:core/validation/validator.adoc[]
-*** xref:core/validation/conversion.adoc[]
 *** xref:core/validation/beans-beans.adoc[]
+*** xref:core/validation/conversion.adoc[]
 *** xref:core/validation/convert.adoc[]
 *** xref:core/validation/format.adoc[]
 *** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
@@ -122,7 +122,6 @@
 **** xref:testing/testcontext-framework/ctx-management/groovy.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/initializers.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/inheritance.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/env-profiles.adoc[]
@@ -131,7 +130,6 @@
 **** xref:testing/testcontext-framework/ctx-management/web.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/web-mocks.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/caching.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[]
 **** xref:testing/testcontext-framework/ctx-management/hierarchies.adoc[]
 *** xref:testing/testcontext-framework/fixture-di.adoc[]
 *** xref:testing/testcontext-framework/web-scoped-beans.adoc[]
@@ -167,7 +165,6 @@
 ***** xref:testing/annotations/integration-spring/annotation-contextconfiguration.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-webappconfiguration.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-contexthierarchy.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-activeprofiles.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-testpropertysource.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-dynamicpropertysource.adoc[]
@@ -182,7 +179,6 @@
 ***** xref:testing/annotations/integration-spring/annotation-sqlconfig.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-sqlmergemode.adoc[]
 ***** xref:testing/annotations/integration-spring/annotation-sqlgroup.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[]
 **** xref:testing/annotations/integration-junit4.adoc[]
 **** xref:testing/annotations/integration-junit-jupiter.adoc[]
 **** xref:testing/annotations/integration-meta.adoc[]
@@ -270,7 +266,6 @@
 ***** xref:web/webmvc/mvc-controller/ann-methods/jackson.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-modelattrib-methods.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-initbinder.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-validation.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-exceptionhandler.adoc[]
 **** xref:web/webmvc/mvc-controller/ann-advice.adoc[]
 *** xref:web/webmvc-functional.adoc[]
@@ -365,7 +360,6 @@
 ***** xref:web/webflux/controller/ann-methods/jackson.adoc[]
 **** xref:web/webflux/controller/ann-modelattrib-methods.adoc[]
 **** xref:web/webflux/controller/ann-initbinder.adoc[]
-**** xref:web/webflux/controller/ann-validation.adoc[]
 **** xref:web/webflux/controller/ann-exceptions.adoc[]
 **** xref:web/webflux/controller/ann-advice.adoc[]
 *** xref:web/webflux-functional.adoc[]
@@ -420,7 +414,6 @@
 *** xref:integration/cache/plug.adoc[]
 *** xref:integration/cache/specific-config.adoc[]
 ** xref:integration/observability.adoc[]
-** xref:integration/checkpoint-restore.adoc[]
 ** xref:integration/appendix.adoc[]
 * xref:languages.adoc[]
 ** xref:languages/kotlin.adoc[]
@@ -438,4 +431,4 @@
 ** xref:languages/groovy.adoc[]
 ** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
-* https://github.com/spring-projects/spring-framework/wiki[Wiki]
+* https://github.com/spring-projects/spring-framework/wiki[Wiki]

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

@@ -39,6 +39,11 @@ resolvable otherwise. See
 {api-spring-framework}++/core/env/AbstractEnvironment.html#IGNORE_GETENV_PROPERTY_NAME++[`AbstractEnvironment`]
 for details.
 
+| `spring.index.ignore`
+| Instructs Spring to ignore the components index located in
+`META-INF/spring.components`. See xref:core/beans/classpath-scanning.adoc#beans-scanning-index[Generating an Index of Candidate Components]
+.
+
 | `spring.jdbc.getParameterType.ignore`
 | Instructs Spring to ignore `java.sql.ParameterMetaData.getParameterType` completely.
 See the note in xref:data-access/jdbc/advanced.adoc#jdbc-batch-list[Batch Operations with a List of Objects].
@@ -55,27 +60,19 @@ for details.
 {api-spring-framework}++/objenesis/SpringObjenesis.html#IGNORE_OBJENESIS_PROPERTY_NAME++[`SpringObjenesis`]
 for details.
 
-| `spring.test.aot.processing.failOnError`
-| A boolean flag that controls whether errors encountered during AOT processing in the
-_Spring TestContext Framework_ should result in an exception that fails the overall process.
-See xref:testing/testcontext-framework/aot.adoc[Ahead of Time Support for Tests].
-
 | `spring.test.constructor.autowire.mode`
 | The default _test constructor autowire mode_ to use if `@TestConstructor` is not present
-on a test class. See xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-testconstructor[Changing the default test constructor autowire mode].
+on a test class. See xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-testconstructor[Changing the default test constructor autowire mode]
+.
 
 | `spring.test.context.cache.maxSize`
 | The maximum size of the context cache in the _Spring TestContext Framework_. See
 xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching].
 
-| `spring.test.context.failure.threshold`
-| The failure threshold for errors encountered while attempting to load an `ApplicationContext`
-in the _Spring TestContext Framework_. See
-xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[Context Failure Threshold].
-
 | `spring.test.enclosing.configuration`
 | The default _enclosing configuration inheritance mode_ to use if
 `@NestedTestConfiguration` is not present on a test class. See
-xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[Changing the default enclosing configuration inheritance mode].
+xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[Changing the default enclosing configuration inheritance mode]
+.
 
 |===

framework-docs/modules/ROOT/pages/core/aop-api/targetsource.adoc

@@ -168,7 +168,7 @@ Kotlin::
 ======
 
 NOTE: Pooling stateless service objects is not usually necessary. We do not believe it should
-be the default choice, as most stateless objects are naturally thread safe, and instance
+be the default choice, as most stateless objects are naturally thread-safe, and instance
 pooling is problematic if resources are cached.
 
 Simpler pooling is available by using auto-proxying. You can set the `TargetSource` implementations

framework-docs/modules/ROOT/pages/core/aop/ataspectj/advice.adoc

@@ -728,6 +728,11 @@ of determining parameter names, an exception will be thrown.
 `StandardReflectionParameterNameDiscoverer` :: Uses the standard `java.lang.reflect.Parameter`
   API to determine parameter names. Requires that code be compiled with the `-parameters`
   flag for `javac`. Recommended approach on Java 8+.
+`LocalVariableTableParameterNameDiscoverer` :: Analyzes the local variable table available
+  in the byte code of the advice class to determine parameter names from debug information.
+  Requires that code be compiled with debug symbols (`-g:vars` at a minimum). Deprecated
+  as of Spring Framework 6.0 for removal in Spring Framework 6.1 in favor of compiling
+  code with `-parameters`. Not supported in a GraalVM native image.
 `AspectJAdviceParameterNameDiscoverer` :: Deduces parameter names from the pointcut
   expression, `returning`, and `throwing` clauses. See the
   {api-spring-framework}/aop/aspectj/AspectJAdviceParameterNameDiscoverer.html[javadoc]

framework-docs/modules/ROOT/pages/core/aop/introduction-defn.adoc

@@ -31,7 +31,7 @@ However, it would be even more confusing if Spring used its own terminology.
   the "advised object". Since Spring AOP is implemented by using runtime proxies, this
   object is always a proxied object.
 * AOP proxy: An object created by the AOP framework in order to implement the aspect
-  contracts (advice method executions and so on). In the Spring Framework, an AOP proxy
+  contracts (advise method executions and so on). In the Spring Framework, an AOP proxy
   is a JDK dynamic proxy or a CGLIB proxy.
 * Weaving: linking aspects with other application types or objects to create an
   advised object. This can be done at compile time (using the AspectJ compiler, for

framework-docs/modules/ROOT/pages/core/aot.adoc

@@ -256,13 +256,6 @@ Java::
 
 If you are registering bean definitions programmatically, consider using `RootBeanBefinition` as it allows to specify a `ResolvableType` that handles generics.
 
-[[aot.bestpractices.constructors]]
-=== Avoid Multiple Constructors
-The container is able to choose the most appropriate constructor to use based on several candidates.
-However, this is not a best practice and flagging the preferred constructor with `@Autowired` if necessary is preferred.
-
-In case you are working on a code base that you can't modify, you can set the {api-spring-framework}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.
-
 [[aot.bestpractices.factory-bean]]
 === FactoryBean
 

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

@@ -141,7 +141,7 @@ Kotlin::
 ====
 After you learn about Spring's IoC container, you may want to know more about Spring's
 `Resource` abstraction (as described in
-xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources])
+xref:core/resources.adoc[Resources])
 which provides a convenient mechanism for reading an InputStream from locations defined
 in a URI syntax. In particular, `Resource` paths are used to construct applications contexts,
 as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].

framework-docs/modules/ROOT/pages/core/beans/classpath-scanning.adoc

@@ -27,7 +27,7 @@ use these features.
 == `@Component` and Further Stereotype Annotations
 
 The `@Repository` annotation is a marker for any class that fulfills the role or
-_stereotype_ of a repository (also known as Data Access Object or DAO). Among the uses
+stereotype of a repository (also known as Data Access Object or DAO). Among the uses
 of this marker is the automatic translation of exceptions, as described in
 xref:data-access/orm/general.adoc#orm-exception-translation[Exception Translation].
 
@@ -39,7 +39,7 @@ layers, respectively). Therefore, you can annotate your component classes with
 `@Component`, but, by annotating them with `@Repository`, `@Service`, or `@Controller`
 instead, your classes are more properly suited for processing by tools or associating
 with aspects. For example, these stereotype annotations make ideal targets for
-pointcuts. `@Repository`, `@Service`, and `@Controller` may also
+pointcuts. `@Repository`, `@Service`, and `@Controller` can also
 carry additional semantics in future releases of the Spring Framework. Thus, if you are
 choosing between using `@Component` or `@Service` for your service layer, `@Service` is
 clearly the better choice. Similarly, as stated earlier, `@Repository` is already
@@ -664,36 +664,15 @@ analogous to how the container selects between multiple `@Autowired` constructor
 == Naming Autodetected Components
 
 When a component is autodetected as part of the scanning process, its bean name is
-generated by the `BeanNameGenerator` strategy known to that scanner.
+generated by the `BeanNameGenerator` strategy known to that scanner. By default, any
+Spring stereotype annotation (`@Component`, `@Repository`, `@Service`, and
+`@Controller`) that contains a name `value` thereby provides that name to the
+corresponding bean definition.
 
-By default, the `AnnotationBeanNameGenerator` is used. For Spring
-xref:core/beans/classpath-scanning.adoc#beans-stereotype-annotations[stereotype annotations],
-if you supply a name via the annotation's `value` attribute that name will be used as
-the name in the corresponding bean definition. This convention also applies when the
-following JSR-250 and JSR-330 annotations are used instead of Spring stereotype
-annotations: `@jakarta.annotation.ManagedBean`, `@javax.annotation.ManagedBean`,
-`@jakarta.inject.Named`, and `@javax.inject.Named`.
-
-As of Spring Framework 6.1, the name of the annotation attribute that is used to specify
-the bean name is no longer required to be `value`. Custom stereotype annotations can
-declare an attribute with a different name (such as `name`) and annotate that attribute
-with `@AliasFor(annotation = Component.class, attribute = "value")`. See the source code
-declaration of `ControllerAdvice#name()` for a concrete example.
-
-[WARNING]
-====
-As of Spring Framework 6.1, support for convention-based stereotype names is deprecated
-and will be removed in a future version of the framework. Consequently, custom stereotype
-annotations must use `@AliasFor` to declare an explicit alias for the `value` attribute
-in `@Component`. See the source code declaration of `Repository#value()` and
-`ControllerAdvice#name()` for concrete examples.
-====
-
-If an explicit bean name cannot be derived from such an annotation or for any other
-detected component (such as those discovered by custom filters), the default bean name
-generator returns the uncapitalized non-qualified class name. For example, if the
-following component classes were detected, the names would be `myMovieLister` and
-`movieFinderImpl`.
+If such an annotation contains no name `value` or for any other detected component
+(such as those discovered by custom filters), the default bean name generator returns
+the uncapitalized non-qualified class name. For example, if the following component
+classes were detected, the names would be `myMovieLister` and `movieFinderImpl`:
 
 [tabs]
 ======
@@ -1010,4 +989,68 @@ metadata is provided per-instance rather than per-class.
 
 
 
+[[beans-scanning-index]]
+== Generating an Index of Candidate Components
+
+While classpath scanning is very fast, it is possible to improve the startup performance
+of large applications by creating a static list of candidates at compilation time. In this
+mode, all modules that are targets of component scanning must use this mechanism.
+
+NOTE: Your existing `@ComponentScan` or `<context:component-scan/>` directives must remain
+unchanged to request the context to scan candidates in certain packages. When the
+`ApplicationContext` detects such an index, it automatically uses it rather than scanning
+the classpath.
+
+To generate the index, add an additional dependency to each module that contains
+components that are targets for component scan directives. The following example shows
+how to do so with Maven:
+
+[source,xml,indent=0,subs="verbatim,quotes,attributes"]
+----
+	<dependencies>
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-context-indexer</artifactId>
+			<version>{spring-version}</version>
+			<optional>true</optional>
+		</dependency>
+	</dependencies>
+----
+
+With Gradle 4.5 and earlier, the dependency should be declared in the `compileOnly`
+configuration, as shown in the following example:
+
+[source,groovy,indent=0,subs="verbatim,quotes,attributes"]
+----
+	dependencies {
+		compileOnly "org.springframework:spring-context-indexer:{spring-version}"
+	}
+----
+
+With Gradle 4.6 and later, the dependency should be declared in the `annotationProcessor`
+configuration, as shown in the following example:
+
+[source,groovy,indent=0,subs="verbatim,quotes,attributes"]
+----
+	dependencies {
+		annotationProcessor "org.springframework:spring-context-indexer:{spring-version}"
+	}
+----
+
+The `spring-context-indexer` artifact generates a `META-INF/spring.components` file that
+is included in the jar file.
+
+NOTE: When working with this mode in your IDE, the `spring-context-indexer` must be
+registered as an annotation processor to make sure the index is up-to-date when
+candidate components are updated.
+
+TIP: The index is enabled automatically when a `META-INF/spring.components` file is found
+on the classpath. If an index is partially available for some libraries (or use cases)
+but could not be built for the whole application, you can fall back to a regular classpath
+arrangement (as though no index were present at all) by setting `spring.index.ignore` to
+`true`, either as a JVM system property or via the
+xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
+
+
+
 

framework-docs/modules/ROOT/pages/core/beans/context-introduction.adoc

@@ -478,21 +478,20 @@ Kotlin::
 ----
 ======
 
-Notice that `ApplicationListener` is generically parameterized with the type of your custom event (`BlockedListEvent` in the preceding example).
-This means that the `onApplicationEvent()` method can remain type-safe, avoiding any need for downcasting.
-You can register as many event listeners as you wish, but note that, by default, event listeners receive events synchronously.
-This means that the `publishEvent()` method blocks until all listeners have finished processing the event.
-One advantage of this synchronous and single-threaded approach is that, when a listener receives an event,
-it operates inside the transaction context of the publisher if a transaction context is available.
-If another strategy for event publication becomes necessary, e.g. asynchronous event processing by default,
-see the javadoc for Spring's {api-spring-framework}/context/event/ApplicationEventMulticaster.html[`ApplicationEventMulticaster`] interface
-and {api-spring-framework}/context/event/SimpleApplicationEventMulticaster.html[`SimpleApplicationEventMulticaster`] implementation
-for configuration options which can be applied to a custom "applicationEventMulticaster" bean definition.
-In these cases, ThreadLocals and logging context are not propagated for the event processing.
-See xref:integration/observability.adoc#observability.application-events[the `@EventListener` Observability section]
-for more information on Observability concerns.
-
-
+Notice that `ApplicationListener` is generically parameterized with the type of your
+custom event (`BlockedListEvent` in the preceding example). This means that the
+`onApplicationEvent()` method can remain type-safe, avoiding any need for downcasting.
+You can register as many event listeners as you wish, but note that, by default, event
+listeners receive events synchronously. This means that the `publishEvent()` method
+blocks until all listeners have finished processing the event. One advantage of this
+synchronous and single-threaded approach is that, when a listener receives an event,
+it operates inside the transaction context of the publisher if a transaction context
+is available. If another strategy for event publication becomes necessary, e.g.
+asynchronous event processing by default, see the javadoc for Spring's
+{api-spring-framework}/context/event/ApplicationEventMulticaster.html[`ApplicationEventMulticaster`] interface
+and {api-spring-framework}/context/event/SimpleApplicationEventMulticaster.html[`SimpleApplicationEventMulticaster`]
+implementation for configuration options which can be applied to a custom
+"applicationEventMulticaster" bean definition.
 
 The following example shows the bean definitions used to register and configure each of
 the classes above:
@@ -748,9 +747,6 @@ Be aware of the following limitations when using asynchronous events:
   value. If you need to publish another event as the result of the processing, inject an
   {api-spring-framework}/context/ApplicationEventPublisher.html[`ApplicationEventPublisher`]
   to publish the event manually.
-* ThreadLocals and logging context are not propagated by default for the event processing.
-  See xref:integration/observability.adoc#observability.application-events[the `@EventListener` Observability section]
-  for more information on Observability concerns.
 
 
 [[context-functionality-events-order]]

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

@@ -772,9 +772,11 @@ resolved to the corresponding value. If not, then `default/path` is used
 as a default. If no default is specified and a property cannot be resolved, an
 `IllegalArgumentException` is thrown.
 
-NOTE: `@PropertySource` can be used as a repeatable annotation. `@PropertySource`
-may also be used as a meta-annotation to create custom composed annotations with
-attribute overrides.
+NOTE: The `@PropertySource` annotation is repeatable, according to Java 8 conventions.
+However, all such `@PropertySource` annotations need to be declared at the same
+level, either directly on the configuration class or as meta-annotations within the
+same custom annotation. Mixing direct annotations and meta-annotations is not
+recommended, since direct annotations effectively override meta-annotations.
 
 
 

framework-docs/modules/ROOT/pages/core/beans/factory-scopes.adoc

@@ -324,7 +324,6 @@ Kotlin::
 
 
 
-
 [[beans-factory-scopes-application]]
 === Application Scope
 
@@ -374,7 +373,6 @@ Kotlin::
 
 
 
-
 [[beans-factory-scopes-websocket]]
 === WebSocket Scope
 
@@ -384,7 +382,6 @@ xref:web/websocket/stomp/scope.adoc[WebSocket scope] for more details.
 
 
 
-
 [[beans-factory-scopes-other-injection]]
 === Scoped Beans as Dependencies
 

framework-docs/modules/ROOT/pages/core/beans/java/basic-concepts.adoc

@@ -59,7 +59,7 @@ The preceding `AppConfig` class is equivalent to the following Spring `<beans/>`
 ****
 When `@Bean` methods are declared within classes that are not annotated with
 `@Configuration`, they are referred to as being processed in a "`lite`" mode. Bean methods
-declared on a bean that is not annotated with `@Configuration` are considered to be "`lite`",
+declared in a `@Component` or even in a plain old class are considered to be "`lite`",
 with a different primary purpose of the containing class and a `@Bean` method
 being a sort of bonus there. For example, service components may expose management views
 to the container through an additional `@Bean` method on each applicable component class.

framework-docs/modules/ROOT/pages/core/expressions.adoc

@@ -46,9 +46,7 @@ The expression language supports the following functionality:
 * Inline maps
 * Ternary operator
 * Variables
-* User-defined functions added to the context
-  * reflective invocation of `Method`
-  * various cases of `MethodHandle`
+* User-defined functions
 * Collection projection
 * Collection selection
 * Templated expressions

framework-docs/modules/ROOT/pages/core/expressions/language-ref.adoc

@@ -15,7 +15,7 @@ topics:
 * xref:core/expressions/language-ref/types.adoc[Types]
 * xref:core/expressions/language-ref/constructors.adoc[Constructors]
 * xref:core/expressions/language-ref/variables.adoc[Variables]
-* xref:core/expressions/language-ref/functions.adoc[User-Defined Functions]
+* xref:core/expressions/language-ref/functions.adoc[Functions]
 * xref:core/expressions/language-ref/bean-references.adoc[Bean References]
 * xref:core/expressions/language-ref/operator-ternary.adoc[Ternary Operator (If-Then-Else)]
 * xref:core/expressions/language-ref/operator-elvis.adoc[The Elvis Operator]

framework-docs/modules/ROOT/pages/core/expressions/language-ref/collection-projection.adoc

@@ -4,7 +4,7 @@
 Projection lets a collection drive the evaluation of a sub-expression, and the result is
 a new collection. The syntax for projection is `.![projectionExpression]`. For example,
 suppose we have a list of inventors but want the list of cities where they were born.
-Effectively, we want to evaluate 'placeOfBirth.city' for every entry in the inventor
+Effectively, we want to evaluate `placeOfBirth.city` for every entry in the inventor
 list. The following example uses projection to do so:
 
 [tabs]
@@ -13,16 +13,18 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	// returns ['Smiljan', 'Idvor' ]
-	List placesOfBirth = (List)parser.parseExpression("members.![placeOfBirth.city]");
+	// evaluates to ["SmilJan", "Idvor"]
+	List placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
+			.getValue(societyContext, List.class);
 ----
 
 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	// returns ['Smiljan', 'Idvor' ]
-	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]") as List<*>
+	// evaluates to ["SmilJan", "Idvor"]
+	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
+	 		.getValue(societyContext) as List<*>
 ----
 ======
 

framework-docs/modules/ROOT/pages/core/expressions/language-ref/collection-selection.adoc

@@ -28,13 +28,14 @@ Kotlin::
 ======
 
 Selection is supported for arrays and anything that implements `java.lang.Iterable` or
-`java.util.Map`. For a list or array, the selection criteria is evaluated against each
-individual element. Against a map, the selection criteria is evaluated against each map
-entry (objects of the Java type `Map.Entry`). Each map entry has its `key` and `value`
-accessible as properties for use in the selection.
+`java.util.Map`. For an array or `Iterable`, the selection expression is evaluated
+against each individual element. Against a map, the selection expression is evaluated
+against each map entry (objects of the Java type `Map.Entry`). Each map entry has its
+`key` and `value` accessible as properties for use in the selection.
 
-The following expression returns a new map that consists of those elements of the
-original map where the entry's value is less than 27:
+Given a `Map` stored in a variable named `#map`, the following expression returns a new
+map that consists of those elements of the original map where the entry's value is less
+than 27:
 
 [tabs]
 ======
@@ -42,21 +43,21 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	Map newMap = parser.parseExpression("map.?[value<27]").getValue();
+	Map newMap = parser.parseExpression("#map.?[value < 27]").getValue(Map.class);
 ----
 
 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	val newMap = parser.parseExpression("map.?[value<27]").getValue()
+	val newMap = parser.parseExpression("#map.?[value < 27]").getValue() as Map
 ----
 ======
 
 In addition to returning all the selected elements, you can retrieve only the first or
-the last element. To obtain the first element matching the selection, the syntax is
-`.^[selectionExpression]`. To obtain the last matching selection, the syntax is
-`.$[selectionExpression]`.
+the last element. To obtain the first element matching the selection expression, the
+syntax is `.^[selectionExpression]`. To obtain the last element matching the selection
+expression, the syntax is `.$[selectionExpression]`.
 
 
 

framework-docs/modules/ROOT/pages/core/expressions/language-ref/functions.adoc

@@ -3,8 +3,7 @@
 
 You can extend SpEL by registering user-defined functions that can be called within the
 expression string. The function is registered through the `EvaluationContext`. The
-following example shows how to register a user-defined function to be invoked via reflection
-(i.e. a `Method`):
+following example shows how to register a user-defined function:
 
 [tabs]
 ======
@@ -95,97 +94,5 @@ Kotlin::
 ----
 ======
 
-The use of `MethodHandle` is also supported. This enables potentially more efficient use
-cases if the `MethodHandle` target and parameters have been fully bound prior to
-registration, but partially bound handles are also supported.
-
-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:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	ExpressionParser parser = new SpelExpressionParser();
-	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
-
-	MethodHandle mh = MethodHandles.lookup().findVirtual(String.class, "formatted",
-			MethodType.methodType(String.class, Object[].class));
-	context.setVariable("message", mh);
-
-	String message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
-			.getValue(context, String.class);
-	//returns "Simple message: <Hello World>"
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val parser = SpelExpressionParser()
-	val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
-
-	val mh = MethodHandles.lookup().findVirtual(String::class.java, "formatted",
-			MethodType.methodType(String::class.java, Array<Any>::class.java))
-	context.setVariable("message", mh)
-
-	val message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
-			.getValue(context, String::class.java)
-----
-======
-
-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]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	ExpressionParser parser = new SpelExpressionParser();
-	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
-
-	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))
-			.bindTo(template)
-			.bindTo(varargs); //here we have to provide arguments in a single array binding
-	context.setVariable("message", mh);
-
-	String message = parser.parseExpression("#message()")
-			.getValue(context, String.class);
-	//returns "This is a prerecorded message with 3 words: <Oh Hello World!>"
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val parser = SpelExpressionParser()
-	val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
-
-	val template = "This is a %s message with %s words: <%s>"
-	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))
-			.bindTo(template)
-			.bindTo(varargs) //here we have to provide arguments in a single array binding
-	context.setVariable("message", mh)
-
-	val message = parser.parseExpression("#message()")
-			.getValue(context, String::class.java)
-----
-======
-
 
 

framework-docs/modules/ROOT/pages/core/expressions/language-ref/operator-elvis.adoc

@@ -38,10 +38,6 @@ Kotlin::
 ----
 ======
 
-NOTE: The SpEL Elvis operator also checks for _empty_ Strings in addition to `null` objects.
-The original snippet is thus only close to emulating the semantics of the operator (it would need an
-additional `!name.isEmpty()` check).
-
 The following listing shows a more complex example:
 
 [tabs]
@@ -57,7 +53,7 @@ Java::
 	String name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String.class);
 	System.out.println(name);  // Nikola Tesla
 
-	tesla.setName("");
+	tesla.setName(null);
 	name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String.class);
 	System.out.println(name);  // Elvis Presley
 ----
@@ -73,7 +69,7 @@ Kotlin::
 	var name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String::class.java)
 	println(name)  // Nikola Tesla
 
-	tesla.setName("")
+	tesla.setName(null)
 	name = parser.parseExpression("name?:'Elvis Presley'").getValue(context, tesla, String::class.java)
 	println(name)  // Elvis Presley
 ----

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

@@ -1,50 +1,5 @@
-[[beans-binding]]
-= Data Binding
-
-Data binding is useful for binding user input to a target object where user input is a map
-with property paths as keys, following xref:beans-beans-conventions[JavaBeans conventions].
-`DataBinder` is the main class that supports this, and it provides two ways to bind user
-input:
-
-- xref:beans-constructor-binding[Constructor binding] - bind user input to a public data
-constructor, looking up constructor argument values in the user input.
-- xref:beans-beans[Property binding] - bind user input to setters, matching keys from the
-user input to properties of the target object structure.
-
-You can apply both constructor and property binding or only one.
-
-
-[[beans-constructor-binding]]
-== Constructor Binding
-
-To use constructor binding:
-
-1. Create a `DataBinder` with `null` as the target object.
-2. Set `targetType` to the target class.
-3. Call `construct`.
-
-The target class should have a single public constructor or a single non-public constructor
-with arguments. If there are multiple constructors, then a default constructor if present
-is used.
-
-By default, constructor parameter names are used to look up argument values, but you can
-configure a `NameResolver`. Spring MVC and WebFlux both rely to allow customizing the name
-of the value to bind through an `@BindParam` annotation on constructor parameters.
-
-xref:beans-beans-conventions[Type conversion] is applied as needed to convert user input.
-If the constructor parameter is an object, it is constructed recursively in the same
-manner, but through a nested property path. That means constructor binding creates both
-the target object and any objects it contains.
-
-Binding and conversion errors are reflected in the `BindingResult` of the `DataBinder`.
-If the target is created successfully, then `target` is set to the created instance
-after the call to `construct`.
-
-
-
-
 [[beans-beans]]
-== Property Binding with `BeanWrapper`
+= Bean Manipulation and the `BeanWrapper`
 
 The `org.springframework.beans` package adheres to the JavaBeans standard.
 A JavaBean is a class with a default no-argument constructor and that follows
@@ -71,7 +26,7 @@ perform actions on that bean, such as setting and retrieving properties.
 
 
 [[beans-beans-conventions]]
-=== Setting and Getting Basic and Nested Properties
+== Setting and Getting Basic and Nested Properties
 
 Setting and getting properties is done through the `setPropertyValue` and
 `getPropertyValue` overloaded method variants of `BeanWrapper`. See their Javadoc for
@@ -237,7 +192,7 @@ Kotlin::
 
 
 [[beans-beans-conversion]]
-== ``PropertyEditor``'s
+== Built-in `PropertyEditor` Implementations
 
 Spring uses the concept of a `PropertyEditor` to effect the conversion between an
 `Object` and a `String`. It can be handy
@@ -423,7 +378,7 @@ Kotlin::
 
 
 [[beans-beans-conversion-customeditor-registration]]
-=== Custom ``PropertyEditor``'s
+=== Registering Additional Custom `PropertyEditor` Implementations
 
 When setting bean properties as string values, a Spring IoC container ultimately uses
 standard JavaBeans `PropertyEditor` implementations to convert these strings to the complex type of the
@@ -566,7 +521,7 @@ Finally, the following example shows how to use `CustomEditorConfigurer` to regi
 ----
 
 [[beans-beans-conversion-customeditor-registration-per]]
-=== `PropertyEditorRegistrar`
+==== Using `PropertyEditorRegistrar`
 
 Another mechanism for registering property editors with the Spring container is to
 create and use a `PropertyEditorRegistrar`. This interface is particularly useful when

framework-docs/modules/ROOT/pages/core/validation/beanvalidation.adoc

@@ -123,12 +123,15 @@ Validator, is expected to be present in the classpath and is automatically detec
 
 
 [[validation-beanvalidation-spring-inject]]
-=== Inject Jakarta Validator
+=== Injecting a Validator
 
 `LocalValidatorFactoryBean` implements both `jakarta.validation.ValidatorFactory` and
-`jakarta.validation.Validator`, so you can inject a reference to the latter to
-apply validation logic if you prefer to work with the Bean Validation API directly,
-as the following example shows:
+`jakarta.validation.Validator`, as well as Spring's `org.springframework.validation.Validator`.
+You can inject a reference to either of these interfaces into beans that need to invoke
+validation logic.
+
+You can inject a reference to `jakarta.validation.Validator` if you prefer to work with the Bean
+Validation API directly, as the following example shows:
 
 [tabs]
 ======
@@ -157,15 +160,8 @@ Kotlin::
 ----
 ======
 
-
-[[validation-beanvalidation-spring-inject-adapter]]
-=== Inject Spring Validator
-
-In addition to implementing `jakarta.validation.Validator`, `LocalValidatorFactoryBean`
-also adapts to `org.springframework.validation.Validator`, so you can inject a reference
-to the latter if your bean requires the Spring Validation API.
-
-For example:
+You can inject a reference to `org.springframework.validation.Validator` if your bean
+requires the Spring Validation API, as the following example shows:
 
 [tabs]
 ======
@@ -194,15 +190,9 @@ Kotlin::
 ----
 ======
 
-When used as `org.springframework.validation.Validator`, `LocalValidatorFactoryBean`
-invokes the underlying `jakarta.validation.Validator`, and then adapts
-``ContraintViolation``s to ``FieldError``s, and registers them with the `Errors` object
-passed into the `validate` method.
-
-
 
 [[validation-beanvalidation-spring-constraints]]
-=== Configure Custom Constraints
+=== Configuring Custom Constraints
 
 Each bean validation constraint consists of two parts:
 
@@ -282,10 +272,11 @@ As the preceding example shows, a `ConstraintValidator` implementation can have
 
 
 [[validation-beanvalidation-spring-method]]
-== Spring-driven Method Validation
+=== Spring-driven Method Validation
 
-You can integrate the method validation feature of Bean Validation into a
-Spring context through a `MethodValidationPostProcessor` bean definition:
+You can integrate the method validation feature supported by Bean Validation 1.1 (and, as
+a custom extension, also by Hibernate Validator 4.3) into a Spring context through a
+`MethodValidationPostProcessor` bean definition:
 
 [tabs]
 ======
@@ -314,11 +305,11 @@ XML::
 ----
 ======
 
-To be eligible for Spring-driven method validation, target classes need to be annotated
+To be eligible for Spring-driven method validation, all target classes need to be annotated
 with Spring's `@Validated` annotation, which can optionally also declare the validation
 groups to use. See
 {api-spring-framework}/validation/beanvalidation/MethodValidationPostProcessor.html[`MethodValidationPostProcessor`]
-for setup details with the Hibernate Validator and Bean Validation providers.
+for setup details with the Hibernate Validator and Bean Validation 1.1 providers.
 
 [TIP]
 ====
@@ -329,142 +320,8 @@ xref:core/aop/proxying.adoc#aop-understanding-aop-proxies[Understanding AOP Prox
 to always use methods and accessors on proxied classes; direct field access will not work.
 ====
 
-Spring MVC and WebFlux have built-in support for the same underlying method validation but without
-the need for AOP. Therefore, do check the rest of this section, and also see the Spring MVC
-xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation] and
-xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses] sections, and the WebFlux
-xref:web/webflux/controller/ann-validation.adoc[Validation] and
-xref:web/webflux/ann-rest-exceptions.adoc[Error Responses] sections.
 
 
-[[validation-beanvalidation-spring-method-exceptions]]
-=== Method Validation Exceptions
-
-By default, `jakarta.validation.ConstraintViolationException` is raised with the set of
-``ConstraintViolation``s returned by `jakarata.validation.Validator`. As an alternative,
-you can have `MethodValidationException` raised instead with ``ConstraintViolation``s
-adapted to `MessageSourceResolvable` errors. To enable set the following flag:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
-
-	@Configuration
-	public class AppConfig {
-
-		@Bean
-		public MethodValidationPostProcessor validationPostProcessor() {
-			MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
-			processor.setAdaptConstraintViolations(true);
-			return processor;
-		}
-	}
-
-----
-
-XML::
-+
-[source,xml,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	<bean class="org.springframework.validation.beanvalidation.MethodValidationPostProcessor">
-		<property name="adaptConstraintViolations" value="true"/>
-	</bean>
-----
-======
-
-`MethodValidationException` contains a list of ``ParameterValidationResult``s which
-group errors by method parameter, and each exposes a `MethodParameter`, the argument
-value, and a list of `MessageSourceResolvable` errors adapted from
-``ConstraintViolation``s. For `@Valid` method parameters with cascaded violations on
-fields and properties, the `ParameterValidationResult` is `ParameterErrors` which
-implements `org.springframework.validation.Errors` and exposes validation errors as
-``FieldError``s.
-
-
-[[validation-beanvalidation-spring-method-i18n]]
-=== Customizing Validation Errors
-
-The adapted `MessageSourceResolvable` errors can be turned into error messages to
-display to users through the configured `MessageSource` with locale and language specific
-resource bundles. This section provides an example for illustration.
-
-Given the following class declarations:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	record Person(@Size(min = 1, max = 10) String name) {
-	}
-
-	@Validated
-	public class MyService {
-
-		void addStudent(@Valid Person person, @Max(2) int degrees) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@JvmRecord
-	internal data class Person(@Size(min = 1, max = 10) val name: String)
-
-	@Validated
-	class MyService {
-
-		fun addStudent(person: @Valid Person?, degrees: @Max(2) Int) {
-			// ...
-		}
-	}
-----
-======
-
-A `ConstraintViolation` on `Person.name()` is adapted to a `FieldErrro` with the following:
-
-- Error codes `"Size.student.name"`, `"Size.name"`, `"Size.java.lang.String"`, and `"Size"`
-- Message arguments `"name"`, `10`, and `1` (the field name and the constraint attributes)
-- Default message "size must be between 1 and 10"
-
-To customize the default message, you can add properties to
-xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-resource bundles using any of the above errors codes and message arguments. Note also that the
-message argument `"name"` is itself a `MessagreSourceResolvable` with error codes
-`"student.name"` and `"name"` and can customized too. For example:
-
-Properties::
-+
-[source,properties,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-Size.student.name=Please, provide a {0} that is between {2} and {1} characters long
-student.name=username
-----
-
-A `ConstraintViolation` on the `degrees` method parameter is adapted to a
-`MessageSourceResolvable` with the following:
-
-- Error codes `"Max.myService#addStudent.degrees"`, `"Max.degrees"`, `"Max.int"`, `"Max"`
-- Message arguments "degrees2 and 2 (the field name and the constraint attribute)
-- Default message "must be less than or equal to 2"
-
-To customize the above default message, you can add a property such as:
-
-Properties::
-+
-[source,properties,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-Max.degrees=You cannot provide more than {1} {0}
-----
-
 
 [[validation-beanvalidation-spring-other]]
 === Additional Configuration Options

framework-docs/modules/ROOT/pages/core/validation/validator.adoc

@@ -195,12 +195,6 @@ of Spring Web MVC, you can use the `<spring:bind/>` tag to inspect the error mes
 you can also inspect the `Errors` object yourself. More information about the
 methods it offers can be found in the {api-spring-framework}/validation/Errors.html[javadoc].
 
-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()`
-or the new `failOnError` method for turning the error summary message into an exception
-(e.g. `validator.validateObject(myObject).failOnError(IllegalArgumentException::new)`).
 
 
 

framework-docs/modules/ROOT/pages/data-access/jdbc/choose-style.adoc

@@ -2,26 +2,30 @@
 = Choosing an Approach for JDBC Database Access
 
 You can choose among several approaches to form the basis for your JDBC database access.
-In addition to three flavors of `JdbcTemplate`, a `SimpleJdbcInsert` and `SimpleJdbcCall`
-approach optimizes database metadata, and the RDBMS Object style results in a more
-object-oriented approach. Once you start using one of these approaches, you can still mix
-and match to include a feature from a different approach.
+In addition to three flavors of `JdbcTemplate`, a new `SimpleJdbcInsert` and
+`SimpleJdbcCall` approach optimizes database metadata, and the RDBMS Object style takes a
+more object-oriented approach similar to that of JDO Query design. Once you start using
+one of these approaches, you can still mix and match to include a feature from a
+different approach. All approaches require a JDBC 2.0-compliant driver, and some
+advanced features require a JDBC 3.0 driver.
 
 * `JdbcTemplate` is the classic and most popular Spring JDBC approach. This
-  "`lowest-level`" approach and all others use a `JdbcTemplate` under the covers.
+  "`lowest-level`" approach and all others use a JdbcTemplate under the covers.
 * `NamedParameterJdbcTemplate` wraps a `JdbcTemplate` to provide named parameters
   instead of the traditional JDBC `?` placeholders. This approach provides better
   documentation and ease of use when you have multiple parameters for an SQL statement.
 * `SimpleJdbcInsert` and `SimpleJdbcCall` optimize database metadata to limit the amount
-  of necessary configuration. This approach simplifies coding so that you only need to
-  provide the name of the table or procedure and a map of parameters matching the column
-  names. This works only if the database provides adequate metadata. If the database does
-  not provide this metadata, you have to provide explicit configuration of the parameters.
+  of necessary configuration. This approach simplifies coding so that you need to
+  provide only the name of the table or procedure and provide a map of parameters matching
+  the column names. This works only if the database provides adequate metadata. If the
+  database does not provide this metadata, you have to provide explicit
+  configuration of the parameters.
 * RDBMS objects — including `MappingSqlQuery`, `SqlUpdate`, and `StoredProcedure` —
   require you to create reusable and thread-safe objects during initialization of your
-  data-access layer. This approach allows you to define your query string, declare
-  parameters, and compile the query. Once you do that, `execute(...)`, `update(...)`, and
-  `findObject(...)` methods can be called multiple times with various parameter values.
+  data-access layer. This approach is modeled after JDO Query, wherein you define your
+  query string, declare parameters, and compile the query. Once you do that,
+  `execute(...)`, `update(...)`, and `findObject(...)` methods can be called multiple
+  times with various parameter values.
 
 
 

framework-docs/modules/ROOT/pages/data-access/jdbc/core.adoc

@@ -6,7 +6,6 @@ including error handling. It includes the following topics:
 
 * xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate[Using `JdbcTemplate`]
 * xref:data-access/jdbc/core.adoc#jdbc-NamedParameterJdbcTemplate[Using `NamedParameterJdbcTemplate`]
-* xref:data-access/jdbc/core.adoc#jdbc-JdbcClient[Unified JDBC Query/Update Operations: `JdbcClient`]
 * xref:data-access/jdbc/core.adoc#jdbc-SQLExceptionTranslator[Using `SQLExceptionTranslator`]
 * xref:data-access/jdbc/core.adoc#jdbc-statements-executing[Running Statements]
 * xref:data-access/jdbc/core.adoc#jdbc-statements-querying[Running Queries]
@@ -702,120 +701,6 @@ See also xref:data-access/jdbc/core.adoc#jdbc-JdbcTemplate-idioms[`JdbcTemplate`
 for guidelines on using the `NamedParameterJdbcTemplate` class in the context of an application.
 
 
-[[jdbc-JdbcClient]]
-== Unified JDBC Query/Update Operations: `JdbcClient`
-
-As of 6.1, the named parameter statements of `NamedParameterJdbcTemplate` and the positional
-parameter statements of a regular `JdbcTemplate` are available through a unified client API
-with a fluent interaction model.
-
-For example, with positional parameters:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	private JdbcClient jdbcClient = JdbcClient.create(dataSource);
-
-	public int countOfActorsByFirstName(String firstName) {
-		return this.jdbcClient.sql("select count(*) from t_actor where first_name = ?")
-				.param(firstName);
-				.query(Integer.class).single();
-	}
-----
-
-For example, with named parameters:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	private JdbcClient jdbcClient = JdbcClient.create(dataSource);
-
-	public int countOfActorsByFirstName(String firstName) {
-		return this.jdbcClient.sql("select count(*) from t_actor where first_name = :firstName")
-				.param("firstName", firstName);
-				.query(Integer.class).single();
-	}
-----
-
-`RowMapper` capabilities are available as well, with flexible result resolution:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	List<Actor> actors = this.jdbcClient.sql("select first_name, last_name from t_actor")
-			.query((rs, rowNum) -> new Actor(rs.getString("first_name"), rs.getString("last_name")))
-			.list();
-----
-
-Instead of a custom `RowMapper`, you may also specify a class to map to.
-For example, assuming that `Actor` has `firstName` and `lastName` properties
-as a record class, a custom constructor, bean properties, or plain fields:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	List<Actor> actors = this.jdbcClient.sql("select first_name, last_name from t_actor")
-			.query(Actor.class)
-			.list();
-----
-
-With a required single object result:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	Actor actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
-			.param(1212L);
-			.query(Actor.class)
-			.single();
-----
-
-With a `java.util.Optional` result:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	Optional<Actor> actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
-			.param(1212L);
-			.query(Actor.class)
-			.optional();
-----
-
-And for an update statement:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (?, ?)")
-			.param("Leonor").param("Watling");
-			.update();
-----
-
-Or an update statement with named parameters:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.param("firstName", "Leonor").param("lastName", "Watling");
-			.update();
-----
-
-Instead of individual named parameters, you may also specify a parameter source object –
-for example, a record class, a class with bean properties, or a plain field holder which
-provides `firstName` and `lastName` properties, such as the `Actor` class from above:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.paramSource(new Actor("Leonor", "Watling");
-			.update();
-----
-
-The automatic `Actor` class mapping for parameters as well as the query results above is
-provided through implicit `SimplePropertySqlParameterSource` and `SimplePropertyRowMapper`
-strategies which are also available for direct use. They can serve as a common replacement
-for `BeanPropertySqlParameterSource` and `BeanPropertyRowMapper`/`DataClassRowMapper`,
-also with `JdbcTemplate` and `NamedParameterJdbcTemplate` themselves.
-
-NOTE: `JdbcClient` is a flexible but simplified facade for JDBC query/update statements.
-Advanced capabilities such as batch inserts and stored procedure calls typically require
-extra customization: consider Spring's `SimpleJdbcInsert` and `SimpleJdbcCall` classes or
-plain direct `JdbcTemplate` usage for any such capabilities not available in `JdbcClient`.
-
-
 [[jdbc-SQLExceptionTranslator]]
 == Using `SQLExceptionTranslator`
 
@@ -824,7 +709,7 @@ between ``SQLException``s and Spring's own `org.springframework.dao.DataAccessEx
 which is agnostic in regard to data access strategy. Implementations can be generic (for
 example, using SQLState codes for JDBC) or proprietary (for example, using Oracle error
 codes) for greater precision. This exception translation mechanism is used behind the
-common `JdbcTemplate` and `JdbcTransactionManager` entry points which do not
+the common `JdbcTemplate` and `JdbcTransactionManager` entry points which do not
 propagate `SQLException` but rather `DataAccessException`.
 
 NOTE: As of 6.0, the default exception translator is `SQLExceptionSubclassTranslator`,

framework-docs/modules/ROOT/pages/data-access/jdbc/packages.adoc

@@ -20,10 +20,9 @@ xref:data-access/jdbc/connections.adoc[Controlling Database Connections] and xre
 
 * `object`: The `org.springframework.jdbc.object` package contains classes that represent
 RDBMS queries, updates, and stored procedures as thread-safe, reusable objects. See
-xref:data-access/jdbc/object.adoc[Modeling JDBC Operations as Java Objects]. This style
-results in a more object-oriented approach, although objects returned by queries are
-naturally disconnected from the database. This higher-level of JDBC abstraction depends
-on the lower-level abstraction in the `org.springframework.jdbc.core` package.
+xref:data-access/jdbc/object.adoc[Modeling JDBC Operations as Java Objects]. This approach is modeled by JDO, although objects returned by queries
+are naturally disconnected from the database. This higher-level of JDBC abstraction
+depends on the lower-level abstraction in the `org.springframework.jdbc.core` package.
 
 * `support`: The `org.springframework.jdbc.support` package provides `SQLException`
 translation functionality and some utility classes. Exceptions thrown during JDBC processing

framework-docs/modules/ROOT/pages/data-access/orm/jpa.adoc

@@ -268,8 +268,8 @@ The actual JPA provider bootstrapping is handed off to the specified executor an
 running in parallel, to the application bootstrap thread. The exposed `EntityManagerFactory`
 proxy can be injected into other application components and is even able to respond to
 `EntityManagerFactoryInfo` configuration inspection. However, once the actual JPA provider
-is being accessed by other components (for example, calling `createEntityManager`), those calls
-block until the background bootstrapping has completed. In particular, when you use
+is being accessed by other components (for example, calling `createEntityManager`), those
+calls block until the background bootstrapping has completed. In particular, when you use
 Spring Data JPA, make sure to set up deferred bootstrapping for its repositories as well.
 
 
@@ -284,9 +284,9 @@ to a newly created `EntityManager` per operation, in effect making its usage thr
 
 It is possible to write code against the plain JPA without any Spring dependencies, by
 using an injected `EntityManagerFactory` or `EntityManager`. Spring can understand the
-`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method level
-if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example shows a plain
-JPA DAO implementation that uses the `@PersistenceUnit` annotation:
+`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method
+level if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example
+shows a plain JPA DAO implementation that uses the `@PersistenceUnit` annotation:
 
 [tabs]
 ======

framework-docs/modules/ROOT/pages/data-access/r2dbc.adoc

@@ -254,25 +254,6 @@ Kotlin::
 ----
 ======
 
-Alternatively, there is a shortcut for mapping to a single value:
-
-[source,java]
-----
-	Flux<String> names = client.sql("SELECT name FROM person")
-			.mapValue(String.class)
-			.all();
-----
-
-Or you may map to a result object with bean properties or record components:
-
-[source,java]
-----
-	// assuming a name property on Person
-	Flux<Person> persons = client.sql("SELECT name FROM person")
-			.mapProperties(Person.class)
-			.all();
-----
-
 [[r2dbc-DatabaseClient-mapping-null]]
 .What about `null`?
 ****
@@ -343,27 +324,6 @@ The following example shows parameter binding for a query:
 			.bind("age", 34);
 ----
 
-Alternatively, you may pass in a map of names and values:
-
-[source,java]
-----
-	Map<String, Object> params = new LinkedHashMap<>();
-	params.put("id", "joe");
-	params.put("name", "Joe");
-	params.put("age", 34);
-	db.sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
-			.bindValues(params);
-----
-
-Or you may pass in a parameter object with bean properties or record components:
-
-[source,java]
-----
-	// assuming id, name, age properties on Person
-	db.sql("INSERT INTO person (id, name, age) VALUES(:id, :name, :age)")
-			.bindProperties(new Person("joe", "Joe", 34);
-----
-
 .R2DBC Native Bind Markers
 ****
 R2DBC uses database-native bind markers that depend on the actual database vendor.

framework-docs/modules/ROOT/pages/data-access/transaction/declarative/rolling-back.adoc

@@ -23,7 +23,7 @@ As of Spring Framework 5.2, the default configuration also provides support for
 Vavr's `Try` method to trigger transaction rollbacks when it returns a 'Failure'.
 This allows you to handle functional-style errors using Try and have the transaction
 automatically rolled back in case of a failure. For more information on Vavr's Try,
-refer to the [official Vavr documentation](https://www.vavr.io/vavr-docs/#_try).
+refer to the https://docs.vavr.io/#_try[official Vavr documentation].
 
 Here's an example of how to use Vavr's Try with a transactional method:
 [tabs]

framework-docs/modules/ROOT/pages/data-access/transaction/event.adoc

@@ -57,14 +57,10 @@ attribute of the annotation to `true`.
 
 [NOTE]
 ====
-As of 6.1, `@TransactionalEventListener` can work with thread-bound transactions managed by
-`PlatformTransactionManager` as well as reactive transactions managed by `ReactiveTransactionManager`.
-For the former, listeners are guaranteed to see the current thread-bound transaction.
-Since the latter uses the Reactor context instead of thread-local variables, the transaction
-context needs to be included in the published event instance as the event source.
-See the
-{api-spring-framework}/transaction/reactive/TransactionalEventPublisher.html[`TransactionalEventPublisher`]
-javadoc for details.
+`@TransactionalEventListener` only works with thread-bound transactions managed by
+`PlatformTransactionManager`. A reactive transaction managed by `ReactiveTransactionManager`
+uses the Reactor context instead of thread-local attributes, so from the perspective of
+an event listener, there is no compatible active transaction that it can participate in.
 ====
 
 

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

@@ -16,7 +16,7 @@ STOMP Messaging.
 xref:web-reactive.adoc[Web Reactive] :: Spring WebFlux, WebClient,
 WebSocket, RSocket.
 xref:integration.adoc[Integration] :: REST Clients, JMS, JCA, JMX,
-Email, Tasks, Scheduling, Caching, Observability, JVM Checkpoint Restore.
+Email, Tasks, Scheduling, Caching, Observability.
 xref:languages.adoc[Languages] :: Kotlin, Groovy, Dynamic Languages.
 xref:testing/appendix.adoc[Appendix] :: Spring properties.
 https://github.com/spring-projects/spring-framework/wiki[Wiki] :: What's New,

framework-docs/modules/ROOT/pages/integration/cache/annotations.adoc

@@ -208,76 +208,6 @@ NOTE: This is an optional feature, and your favorite cache library may not suppo
 All `CacheManager` implementations provided by the core framework support it. See the
 documentation of your cache provider for more details.
 
-[[cache-annotations-cacheable-reactive]]
-=== Caching with CompletableFuture and Reactive Return Types
-
-As of 6.1, cache annotations take `CompletableFuture` and reactive return types
-into account, automatically adapting the cache interaction accordingly.
-
-For a method returning a `CompletableFuture`, the object produced by that future
-will be cached whenever it is complete, and the cache lookup for a cache hit will
-be retrieved via a `CompletableFuture`:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable("books")
-	public CompletableFuture<Book> findBook(ISBN isbn) {...}
-----
-
-For a method returning a Reactor `Mono`, the object emitted by that Reactive Streams
-publisher will be cached whenever it is available, and the cache lookup for a cache
-hit will be retrieved as a `Mono` (backed by a `CompletableFuture`):
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable("books")
-	public Mono<Book> findBook(ISBN isbn) {...}
-----
-
-For a method returning a Reactor `Flux`, the objects emitted by that Reactive Streams
-publisher will be collected into a `List` and cached whenever that list is complete,
-and the cache lookup for a cache hit will be retrieved as a `Flux` (backed by a
-`CompletableFuture` for the cached `List` value):
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable("books")
-	public Flux<Book> findBooks(String author) {...}
-----
-
-Such `CompletableFuture` and reactive adaptation also works for synchronized caching,
-computing the value only once in case of a concurrent cache miss:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Cacheable(cacheNames="foos", sync=true) <1>
-	public CompletableFuture<Foo> executeExpensiveOperation(String id) {...}
-----
-<1> Using the `sync` attribute.
-
-NOTE: In order for such an arrangement to work at runtime, the configured cache
-needs to be capable of `CompletableFuture`-based retrieval. The Spring-provided
-`ConcurrentMapCacheManager` automatically adapts to that retrieval style, and
-`CaffeineCacheManager` natively supports it when its asynchronous cache mode is
-enabled: set `setAsyncCacheMode(true)` on your `CaffeineCacheManager` instance.
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Bean
-	CacheManager cacheManager() {
-		CaffeineCacheManager cacheManager = new CaffeineCacheManager();
-		cacheManager.setCacheSpecification(...);
-		cacheManager.setAsyncCacheMode(true);
-		return cacheManager;
-	}
-----
-
-Last but not least, be aware that annotation-driven caching is not appropriate
-for sophisticated reactive interactions involving composition and back pressure.
-If you choose to declare `@Cacheable` on specific reactive methods, consider the
-impact of the rather coarse-granular cache interaction which simply stores the
-emitted object for a `Mono` or even a pre-collected list of objects for a `Flux`.
-
 [[cache-annotations-cacheable-condition]]
 === Conditional Caching
 
@@ -407,9 +337,6 @@ other), such declarations should be avoided. Note also that such conditions shou
 on the result object (that is, the `#result` variable), as these are validated up-front to
 confirm the exclusion.
 
-As of 6.1, `@CachePut` takes `CompletableFuture` and reactive return types into account,
-performing the put operation whenever the produced object is available.
-
 
 [[cache-annotations-evict]]
 == The `@CacheEvict` Annotation
@@ -452,9 +379,6 @@ trigger, the return values are ignored (as they do not interact with the cache).
 not the case with `@Cacheable` which adds data to the cache or updates data in the cache
 and, thus, requires a result.
 
-As of 6.1, `@CacheEvict` takes `CompletableFuture` and reactive return types into account,
-performing an after-invocation evict operation whenever processing has completed.
-
 
 [[cache-annotations-caching]]
 == The `@Caching` Annotation

framework-docs/modules/ROOT/pages/integration/checkpoint-restore.adoc

@@ -1,31 +0,0 @@
-[[checkpoint-restore]]
-= JVM Checkpoint Restore
-
-The Spring Framework integrates with checkpoint/restore as implemented by https://github.com/CRaC/docs[Project CRaC] in order to allow implementing systems capable to reduce the startup and warmup times of Spring-based Java applications with the JVM.
-
-Using this feature requires:
-
-* A checkpoint/restore enabled JVM (Linux only for now).
-* The presence in the classpath of the https://github.com/CRaC/org.crac[`org.crac:crac`] library (version `1.4.0` and above are supported).
-* Specifying the required `java` command line parameters like `-XX:CRaCCheckpointTo=PATH` or `-XX:CRaCRestoreFrom=PATH`.
-
-WARNING: The files generated in the path specified by `-XX:CRaCCheckpointTo=PATH` when a checkpoint is requested contain a representation of the memory of the running JVM, which may contain secrets and other sensitive data. Using this feature should be done with the assumption that any value "seen" by the JVM, such as configuration properties coming from the environment, will be stored in those CRaC files. As a consequence, the security implications of where and how those files are generated, stored and accessed should be carefully assessed.
-
-Conceptually, checkpoint and restore match with xref:core/beans/factory-nature.adoc#beans-factory-lifecycle-processor[Spring `Lifecycle` contract] for individual beans.
-
-== On demand checkpoint/restore of a running application
-
-A checkpoint can be created on demand, for example using a command like `jcmd application.jar JDK.checkpoint`. Before the creation of the checkpoint, Spring Framework
-stops all the running beans, giving them a chance to close resources if needed by implementing `Lifecycle.stop`. After restore, the same beans are restarted, with `Lifecycle.start` allowing to reopen resources when relevant. For libraries not depending on Spring, checkpoint/restore custom integration can be provided by implementing `org.crac.Resource` and registering the related instance.
-
-WARNING: Leveraging checkpoint/restore of a running application typically requires additional lifecycle management to gracefully stop and start using resources like files or sockets and stop active threads.
-
-NOTE: If the checkpoint is created on a warmed-up JVM, the restored JVM will be equally warmed-up, allowing potentially peak performance immediately. This method typically requires access to remote services, and thus requires some level of platform integration.
-
-== Automatic checkpoint/restore at startup
-
-When the `-Dspring.context.checkpoint=onRefresh` Java system property is set, a checkpoint is created automatically during the startup at `LifecycleProcessor.onRefresh` level. At this phase, all non-lazy initialized singletons are instantiated, `InitializingBean.afterPropertiesSet` callbacks have been invoked, but not `Lifecycle.start` ones and `ContextRefreshedEvent` has not yet been published.
-
-WARNING: As mentioned above, and especially in use cases where the CRaC files are shipped as part of a deployable artifact (a container image for example), operate with the assumption that any sensitive data "seen" by the JVM ends up in the CRaC files, and assess carefully the related security implications.
-
-NOTE: Here checkpoint/restore is a way to "fast-forward" the startup of the application to a phase where the application context is about to start, but does not allow to have a fully warmed-up JVM.

framework-docs/modules/ROOT/pages/integration/email.adoc

@@ -85,7 +85,7 @@ email when someone places an order:
 
 			// Call the collaborators to persist the order...
 
-			// Create a thread safe "copy" of the template message and customize it
+			// Create a thread-safe "copy" of the template message and customize it
 			SimpleMailMessage msg = new SimpleMailMessage(this.templateMessage);
 			msg.setTo(order.getCustomer().getEmailAddress());
 			msg.setText(

framework-docs/modules/ROOT/pages/integration/observability.adoc

@@ -21,20 +21,11 @@ As outlined xref:integration/observability.adoc[at the beginning of this section
 |===
 |Observation name |Description
 
-|xref:integration/observability.adoc#observability.http-client[`"http.client.requests"`]
+|xref:integration/observability.adoc#http-client[`"http.client.requests"`]
 |Time spent for HTTP client exchanges
 
-|xref:integration/observability.adoc#observability.http-server[`"http.server.requests"`]
+|xref:integration/observability.adoc#http-server[`"http.server.requests"`]
 |Processing time for HTTP server exchanges at the Framework level
-
-|xref:integration/observability.adoc#observability.jms.publish[`"jms.message.publish"`]
-|Time spent sending a JMS message to a destination by a message producer.
-
-|xref:integration/observability.adoc#observability.jms.process[`"jms.message.process"`]
-|Processing time for a JMS message that was previously received by a message consumer.
-
-|xref:integration/observability.adoc#observability.tasks-scheduled[`"tasks.scheduled.execution"`]
-|Processing time for an execution of a `@Scheduled` task
 |===
 
 NOTE: Observations are using Micrometer's official naming convention, but Metrics names will be automatically converted
@@ -88,99 +79,6 @@ include-code::./ServerRequestObservationFilter[]
 
 You can configure `ObservationFilter` instances on the `ObservationRegistry`.
 
-[[observability.tasks-scheduled]]
-== @Scheduled tasks instrumentation
-
-An Observation is created for xref:integration/scheduling.adoc#scheduling-enable-annotation-support[each execution of an `@Scheduled` task].
-Applications need to configure the `ObservationRegistry` on the `ScheduledTaskRegistrar` to enable the recording of observations.
-This can be done by declaring a `SchedulingConfigurer` bean that sets the observation registry:
-
-include-code::./ObservationSchedulingConfigurer[]
-
-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).
-
-By default, the following `KeyValues` are created:
-
-.Low cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`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.
-|`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.
-|`outcome` _(required)_|Outcome of the method execution. Can be `"SUCCESS"`, `"ERROR"` or `"UNKNOWN"` (if for example the operation was cancelled during execution).
-|===
-
-
-[[observability.jms]]
-== JMS messaging instrumentation
-
-Spring Framework uses the Jakarta JMS instrumentation provided by Micrometer if the `io.micrometer:micrometer-jakarta9` dependency is on the classpath.
-The `io.micrometer.jakarta9.instrument.jms.JmsInstrumentation` instruments `jakarta.jms.Session` and records the relevant observations.
-
-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 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`:
-
-.Low cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`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 JMS operation being performed (values: `"publish"` or `"process"`).
-|===
-
-.High cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`messaging.message.conversation_id` |The correlation ID of the JMS message.
-|`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.
-|===
-
-[[observability.jms.publish]]
-=== JMS message Publication instrumentation
-
-`"jms.message.publish"` observations are recorded when a JMS message is sent to the broker.
-They measure the time spent sending the message and propagate the tracing information with outgoing JMS message headers.
-
-You will need to configure the `ObservationRegistry` on the `JmsTemplate` to enable observations:
-
-include-code::./JmsTemplatePublish[]
-
-It uses the `io.micrometer.jakarta9.instrument.jms.DefaultJmsPublishObservationConvention` by default, backed by the `io.micrometer.jakarta9.instrument.jms.JmsPublishObservationContext`.
-
-[[observability.jms.process]]
-=== JMS message Processing instrumentation
-
-`"jms.message.process"` observations are recorded when a JMS message is processed by the application.
-They measure the time spent processing the message and propagate the tracing context with incoming JMS message headers.
-
-Most applications will use the xref:integration/jms/annotated.adoc#jms-annotated[`@JmsListener` annotated methods] mechanism to process incoming messages.
-You will need to ensure that the `ObservationRegistry` is configured on the dedicated `JmsListenerContainerFactory`:
-
-include-code::./JmsConfiguration[]
-
-A xref:integration/jms/annotated.adoc#jms-annotated-support[default container factory is required to enable the annotation support],
-but note that `@JmsListener` annotations can refer to specific container factory beans for specific purposes.
-In all cases, Observations are only recorded if the observation registry is configured on the container factory.
-
-Similar observations are recorded with `JmsTemplate` when messages are processed by a `MessageListener`.
-Such listeners are set on a `MessageConsumer` within a session callback (see `JmsTemplate.execute(SessionCallback<T>)`).
-
-This observation uses the `io.micrometer.jakarta9.instrument.jms.DefaultJmsProcessObservationConvention` by default, backed by the `io.micrometer.jakarta9.instrument.jms.JmsProcessObservationContext`.
 
 [[observability.http-server]]
 == HTTP Server instrumentation
@@ -201,7 +99,7 @@ include-code::./UserController[]
 
 NOTE: Because the instrumentation is done at the Servlet Filter level, the observation scope only covers the filters ordered after this one as well as the handling of the request.
 Typically, Servlet container error handling is performed at a lower level and won't have any active observation or span.
-For this use case, a container-specific implementation is required, such as a `org.apache.catalina.Valve` for Tomcat; this is outside the scope of this project.
+For this use case, a container-specific implementation is required, such as a `org.apache.catalina.Valve` for Tomcat; this is outside of the scope of this project.
 
 By default, the following `KeyValues` are created:
 
@@ -209,8 +107,7 @@ By default, the following `KeyValues` are created:
 [cols="a,a"]
 |===
 |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.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `KeyValue#NONE_VALUE`} if no exception happened.
 |`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.
@@ -228,15 +125,11 @@ By default, the following `KeyValues` are created:
 [[observability.http-server.reactive]]
 === Reactive applications
 
-Applications need to configure the `WebHttpHandlerBuilder` with a `MeterRegistry` to enable server instrumentation.
-This can be done on the `WebHttpHandlerBuilder`, as follows:
+Applications need to configure the `org.springframework.web.filter.reactive.ServerHttpObservationFilter` reactive `WebFilter` in their application.
+It uses the `org.springframework.http.server.reactive.observation.DefaultServerRequestObservationConvention` by default, backed by the `ServerRequestObservationContext`.
 
-include-code::./HttpHandlerConfiguration[]
-
-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 <<web.adoc#webflux-ann-rest-exceptions,`ProblemDetail` support>> will not be recorded with the observation.
+This will only record an observation as an error if the `Exception` has not been handled by the web framework and has bubbled up to the `WebFilter`.
+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.
 You can, at any point during request processing, set the error field on the `ObservationContext` yourself:
 
 include-code::./UserController[]
@@ -247,8 +140,7 @@ By default, the following `KeyValues` are created:
 [cols="a,a"]
 |===
 |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.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `"none"` if no exception happened.
 |`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.
@@ -287,8 +179,7 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 |`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.
-|`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.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `"none"` if no exception happened.
 |===
 
 .High cardinality Keys
@@ -299,33 +190,6 @@ Instrumentation uses the `org.springframework.http.client.observation.ClientRequ
 |===
 
 
-[[observability.http-client.restclient]]
-=== RestClient
-
-Applications must configure an `ObservationRegistry` on the `RestClient.Builder` to enable the instrumentation; without that, observations are "no-ops".
-
-Instrumentation uses the `org.springframework.http.client.observation.ClientRequestObservationConvention` by default, backed by the `ClientRequestObservationContext`.
-
-.Low cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`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.
-|`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.
-|===
-
-.High cardinality Keys
-[cols="a,a"]
-|===
-|Name | Description
-|`http.url` _(required)_|HTTP request URI.
-|===
-
 
 [[observability.http-client.webclient]]
 === WebClient
@@ -344,8 +208,7 @@ Instrumentation uses the `org.springframework.web.reactive.function.client.Clien
 |`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.
-|`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.
+|`exception` _(required)_|Name of the exception thrown during the exchange, or `"none"` if no exception happened.
 |===
 
 .High cardinality Keys
@@ -356,28 +219,3 @@ Instrumentation uses the `org.springframework.web.reactive.function.client.Clien
 |===
 
 
-[[observability.application-events]]
-== Application Events and `@EventListener`
-
-Spring Framework does not contribute Observations for xref:core/beans/context-introduction.adoc#context-functionality-events-annotation[`@EventListener` calls],
-as they don't have the right semantics for such instrumentation.
-By default, event publication and processing are done synchronously and on the same thread.
-This means that during the execution of that task, the ThreadLocals and logging context will be the same as the event publisher.
-
-If the application globally configures a custom `ApplicationEventMulticaster` with a strategy that schedules event processing on different threads, this is no longer true.
-All `@EventListener` methods will be processed on a different thread, outside the main event publication thread.
-In these cases, the https://micrometer.io/docs/contextPropagation[Micrometer Context Propagation library] can help propagate such values and better correlate the processing of the events.
-The application can configure the chosen `TaskExecutor` to use a `ContextPropagatingTaskDecorator` that decorates tasks and propagates context.
-For this to work, the `io.micrometer:context-propagation` library must be present on the classpath:
-
-include-code::./ApplicationEventsConfiguration[]
-
-Similarly, if that asynchronous choice is made locally for each `@EventListener` annotated method, by adding `@Async` to it,
-you can choose a `TaskExecutor` that propagates context by referring to it by its qualifier.
-Given the following `TaskExecutor` bean definition, configured with the dedicated task decorator:
-
-include-code::./EventAsyncExecutionConfiguration[]
-
-Annotating event listeners with `@Async` and the relevant qualifier will achieve similar context propagation results:
-
-include-code::./EmailNotificationListener[]

framework-docs/modules/ROOT/pages/integration/scheduling.adoc

@@ -66,11 +66,6 @@ The variants that Spring provides are as follows:
   compatible runtime environment (such as a Jakarta EE application server),
   replacing a CommonJ WorkManager for that purpose.
 
-As of 6.1, `ThreadPoolTaskExecutor` provides a pause/resume capability and graceful
-shutdown through Spring's lifecycle management. There is also a new "virtualThreads"
-option on `SimpleAsyncTaskExecutor` which is aligned with JDK 21's Virtual Threads,
-as well as a graceful shutdown capability for `SimpleAsyncTaskExecutor` as well.
-
 
 [[scheduling-task-executor-usage]]
 === Using a `TaskExecutor`
@@ -249,11 +244,6 @@ to provide common bean-style configuration along the lines of `ThreadPoolTaskExe
 These variants work perfectly fine for locally embedded thread pool setups in lenient
 application server environments, as well -- in particular on Tomcat and Jetty.
 
-As of 6.1, `ThreadPoolTaskScheduler` provides a pause/resume capability and graceful
-shutdown through Spring's lifecycle management. There is also a new option called
-`SimpleAsyncTaskScheduler` which is aligned with JDK 21's Virtual Threads, using a
-single scheduler thread but firing up a new thread for every scheduled task execution.
-
 
 
 [[scheduling-annotation-support]]
@@ -363,17 +353,6 @@ the amount of time to wait before the first execution of the method, as the foll
 	}
 ----
 
-For one-time tasks, you can just specify an initial delay by indicating the amount
-of time to wait before the intended execution of the method:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(initialDelay = 1000)
-	public void doSomething() {
-		// something that should run only once
-	}
-----
-
 If simple periodic scheduling is not expressive enough, you can provide a
 xref:integration/scheduling.adoc#scheduling-cron-expression[cron expression].
 The following example runs only on weekdays:
@@ -413,120 +392,6 @@ container and once through the `@Configurable` aspect), with the consequence of
 `@Scheduled` method being invoked twice.
 ====
 
-[[scheduling-annotation-support-scheduled-reactive]]
-=== The `@Scheduled` annotation on Reactive methods or Kotlin suspending functions
-
-As of Spring Framework 6.1, `@Scheduled` methods are also supported on several types
-of reactive methods:
-
- - methods with a `Publisher` return type (or any concrete implementation of `Publisher`)
-like in the following example:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	public Publisher<Void> reactiveSomething() {
-		// return an instance of Publisher
-	}
-----
-
- - methods with a return type that can be adapted to `Publisher` via the shared instance
-of the `ReactiveAdapterRegistry`, provided the type supports _deferred subscription_ like
-in the following example:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	public Single<String> rxjavaNonPublisher() {
-		return Single.just("example");
-	}
-----
-
-[NOTE]
-====
-The `CompletableFuture` class is an example of a type that can typically be adapted
-to `Publisher` but doesn't support deferred subscription. Its `ReactiveAdapter` in the
-registry denotes that by having the `getDescriptor().isDeferred()` method return `false`.
-====
-
- - Kotlin suspending functions, like in the following example:
-
-[source,kotlin,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	suspend fun something() {
-		// do something asynchronous
-	}
-----
-
- - methods that return a Kotlin `Flow` or `Deferred` instance, like in the following example:
-
-[source,kotlin,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(fixedDelay = 500)
-	fun something(): Flow<Void> {
-		flow {
-			// do something asynchronous
-		}
-	}
-----
-
-All these types of methods must be declared without any arguments. In the case of Kotlin
-suspending functions, the `kotlinx.coroutines.reactor` bridge must also be present to allow
-the framework to invoke a suspending function as a `Publisher`.
-
-The Spring Framework will obtain a `Publisher` for the annotated method once and will
-schedule a `Runnable` in which it subscribes to said `Publisher`. These inner regular
-subscriptions occur according to the corresponding `cron`/fixedDelay`/`fixedRate` configuration.
-
-If the `Publisher` emits `onNext` signal(s), these are ignored and discarded (the same way
-return values from synchronous `@Scheduled` methods are ignored).
-
-In the following example, the `Flux` emits `onNext("Hello"), onNext("World")` every 5
-seconds, but these values are unused:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(initialDelay = 5000, fixedRate = 5000)
-	public Flux<String> reactiveSomething() {
-		return Flux.just("Hello", "World");
-	}
-----
-
-If the `Publisher` emits an `onError` signal, it is logged at `WARN` level and recovered.
-Because of the asynchronous and lazy nature of `Publisher` instances, exceptions are
-not thrown from the `Runnable` task: this means that the `ErrorHandler` contract is not
-involved for reactive methods.
-
-As a result, further scheduled subscription occurs despite the error.
-
-In the following example, the `Mono` subscription fails twice in the first five seconds.
-Then subscriptions start succeeding, printing a message to the standard output every five
-seconds:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	@Scheduled(initialDelay = 0, fixedRate = 5000)
-	public Mono<Void> reactiveSomething() {
-		AtomicInteger countdown = new AtomicInteger(2);
-
-		return Mono.defer(() -> {
-			if (countDown.get() == 0 || countDown.decrementAndGet() == 0) {
-				return Mono.fromRunnable(() -> System.out.println("Message"));
-			}
-			return Mono.error(new IllegalStateException("Cannot deliver message"));
-		})
-	}
-----
-
-[NOTE]
-====
-When destroying the annotated bean or closing the application context, Spring Framework cancels
-scheduled tasks, which includes the next scheduled subscription to the `Publisher` as well
-as any past subscription that is still currently active (e.g. for long-running publishers
-or even infinite publishers).
-====
-
 
 [[scheduling-annotation-support-async]]
 === The `@Async` annotation

framework-docs/modules/ROOT/pages/languages/kotlin/spring-projects-in.adoc

@@ -248,7 +248,7 @@ For example, declaring `List<Foo>` in Kotlin is conceptually equivalent to `java
 `kotlin.collections.List` is declared as
 https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/[`interface List<out E> : kotlin.collections.Collection<E>`].
 
-This needs to be taken into account by using the `out` Kotlin keyword on generic types when using Java classes,
+This needs to be taken in account by using the `out` Kotlin keyword on generic types when using Java classes,
 for example when writing a `org.springframework.core.convert.converter.Converter` from a Kotlin type to a Java type.
 
 [source,kotlin,indent=0]
@@ -287,14 +287,11 @@ https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-featu
 === Constructor injection
 
 As described in the xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[dedicated section],
-JUnit Jupiter (JUnit 5) allows constructor injection of beans which is pretty useful with Kotlin
+JUnit 5 allows constructor injection of beans which is pretty useful with Kotlin
 in order to use `val` instead of `lateinit var`. You can use
 {api-spring-framework}/test/context/TestConstructor.html[`@TestConstructor(autowireMode = AutowireMode.ALL)`]
 to enable autowiring for all parameters.
 
-NOTE: You can also change the default behavior to `ALL` in a `junit-platform.properties`
-file with a `spring.test.constructor.autowire.mode = all` property.
-
 [source,kotlin,indent=0]
 ----
 @SpringJUnitConfig(TestConfig::class)
@@ -311,11 +308,11 @@ class OrderServiceIntegrationTests(val orderService: OrderService,
 === `PER_CLASS` Lifecycle
 
 Kotlin lets you specify meaningful test function names between backticks (```).
-With JUnit Jupiter (JUnit 5), Kotlin test classes can use the `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`
+As of JUnit 5, Kotlin test classes can use the `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`
 annotation to enable single instantiation of test classes, which allows the use of `@BeforeAll`
 and `@AfterAll` annotations on non-static methods, which is a good fit for Kotlin.
 
-NOTE: You can also change the default behavior to `PER_CLASS` in a `junit-platform.properties`
+You can also change the default behavior to `PER_CLASS` thanks to a `junit-platform.properties`
 file with a `junit.jupiter.testinstance.lifecycle.default = per_class` property.
 
 The following example demonstrates `@BeforeAll` and `@AfterAll` annotations on non-static methods:

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

@@ -137,12 +137,10 @@ demonstrate its API and protocol features.
 
 The `spring-messaging` module contains the following:
 
-* xref:rsocket.adoc#rsocket-requester[RSocketRequester] -- fluent API to make requests
-through an `io.rsocket.RSocket` with data and metadata encoding/decoding.
-* xref:rsocket.adoc#rsocket-annot-responders[Annotated Responders] -- `@MessageMapping`
-  and `@RSocketExchange` annotated handler methods for responding.
-* xref:rsocket.adoc#rsocket-interface[RSocket Interface] -- RSocket service declaration
-as Java interface with `@RSocketExchange` methods, for use as requester or responder.
+* xref:rsocket.adoc#rsocket-requester[RSocketRequester] -- fluent API to make requests through an `io.rsocket.RSocket`
+  with data and metadata encoding/decoding.
+* xref:rsocket.adoc#rsocket-annot-responders[Annotated Responders] -- `@MessageMapping` annotated handler methods for
+  responding.
 
 The `spring-web` module contains `Encoder` and `Decoder` implementations such as Jackson
 CBOR/JSON, and Protobuf that RSocket applications will likely need. It also contains the
@@ -865,69 +863,6 @@ interaction type(s):
 
 
 
-[[rsocket-annot-rsocketexchange]]
-=== @RSocketExchange
-
-As an alternative to  `@MessageMapping`, you can also handle requests with
-`@RSocketExchange` methods. Such methods are declared on an
-xref:rsocket-interface[RSocket Interface] and can be used as a requester via
-`RSocketServiceProxyFactory` or implemented by a responder.
-
-For example, to handle requests as a responder:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public interface RadarsService {
-
-		@RSocketExchange("locate.radars.within")
-		Flux<AirportLocation> radars(MapRequest request);
-	}
-
-	@Controller
-	public class RadarsController implements RadarsService {
-
-		public Flux<AirportLocation> radars(MapRequest request) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	interface RadarsService {
-
-		@RSocketExchange("locate.radars.within")
-		fun radars(request: MapRequest): Flow<AirportLocation>
-	}
-
-	@Controller
-	class RadarsController : RadarsService {
-
-		override fun radars(request: MapRequest): Flow<AirportLocation> {
-			// ...
-		}
-	}
-----
-======
-
-There some differences between `@RSocketExhange` and `@MessageMapping` since the
-former needs to remain suitable for requester and responder use. For example, while
-`@MessageMapping` can be declared to handle any number of routes and each route can
-be a pattern, `@RSocketExchange` must be declared with a single, concrete route. There are
-also small differences in the supported method parameters related to metadata, see
-xref:rsocket-annot-messagemapping[@MessageMapping] and
-xref:rsocket-interface[RSocket Interface] for a list of supported parameters.
-
-`@RSocketExchange` can be used at the type level to specify a common prefix for all routes
-for a given RSocket service interface.
-
-
 [[rsocket-annot-connectmapping]]
 === @ConnectMapping
 
@@ -1062,13 +997,12 @@ Kotlin::
 [[rsocket-interface]]
 == RSocket Interface
 
-The Spring Framework lets you define an RSocket service as a Java interface with
-`@RSocketExchange` methods. You can pass such an interface to `RSocketServiceProxyFactory`
-to create a proxy which performs requests through an
-xref:rsocket.adoc#rsocket-requester[RSocketRequester]. You can also implement the
-interface as a responder that handles requests.
+The Spring Framework lets you define an RSocket service as a Java interface with annotated
+methods for RSocket exchanges. You can then generate a proxy that implements this interface
+and performs the exchanges. This helps to simplify RSocket remote access by wrapping the
+use of the underlying xref:rsocket.adoc#rsocket-requester[RSocketRequester].
 
-Start by creating the interface with `@RSocketExchange` methods:
+One, declare an interface with `@RSocketExchange` methods:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -1082,7 +1016,7 @@ Start by creating the interface with `@RSocketExchange` methods:
 	}
 ----
 
-Now you can create a proxy that performs requests when methods are called:
+Two, create a proxy that will perform the declared RSocket exchanges:
 
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -1092,10 +1026,6 @@ Now you can create a proxy that performs requests when methods are called:
 	RadarService service = factory.createClient(RadarService.class);
 ----
 
-You can also implement the interface to handle requests as a responder.
-See xref:rsocket.adoc#rsocket-annot-rsocketexchange[Annotated Responders].
-
-
 
 [[rsocket-interface-method-parameters]]
 === Method Parameters
@@ -1136,10 +1066,3 @@ method parameters:
 Annotated, RSocket exchange methods support return values that are concrete value(s), or
 any producer of value(s) that can be adapted to a Reactive Streams `Publisher` via
 `ReactiveAdapterRegistry`.
-
-By default, the behavior of RSocket service methods with synchronous (blocking) method
-signature depends on response timeout settings of the underlying RSocket `ClientTransport`
-as well as RSocket keep-alive settings. `RSocketServiceProxyFactory.Builder` does expose a
-`blockTimeout` option that also lets you configure the maximum time to block for a response,
-but we recommend configuring timeout values at the RSocket level for more control.
-

framework-docs/modules/ROOT/pages/testing/annotations/integration-junit-jupiter.adoc

@@ -11,7 +11,6 @@ xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupite
 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[`@NestedTestConfiguration`]
 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-junit-jupiter-enabledif[`@EnabledIf`]
 * xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-junit-jupiter-disabledif[`@DisabledIf`]
-* xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[`@DisabledInAotMode`]
 
 [[integration-testing-annotations-junit-jupiter-springjunitconfig]]
 == `@SpringJUnitConfig`
@@ -171,9 +170,8 @@ of a test class constructor are autowired from components in the test's
 
 If `@TestConstructor` is not present or meta-present on a test class, the default _test
 constructor autowire mode_ will be used. See the tip below for details on how to change
-the default mode. Note, however, that a local declaration of `@Autowired`,
-`@jakarta.inject.Inject`, or `@javax.inject.Inject` on a constructor takes precedence
-over both `@TestConstructor` and the default mode.
+the default mode. Note, however, that a local declaration of `@Autowired` on a
+constructor takes precedence over both `@TestConstructor` and the default mode.
 
 .Changing the default test constructor autowire mode
 [TIP]
@@ -224,7 +222,6 @@ following annotations.
 * xref:testing/annotations/integration-spring/annotation-contextconfiguration.adoc[`@ContextConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-webappconfiguration.adoc[`@WebAppConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-contexthierarchy.adoc[`@ContextHierarchy`]
-* xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[`@ContextCustomizerFactories`]
 * xref:testing/annotations/integration-spring/annotation-activeprofiles.adoc[`@ActiveProfiles`]
 * xref:testing/annotations/integration-spring/annotation-testpropertysource.adoc[`@TestPropertySource`]
 * xref:testing/annotations/integration-spring/annotation-dynamicpropertysource.adoc[`@DynamicPropertySource`]

framework-docs/modules/ROOT/pages/testing/annotations/integration-meta.adoc

@@ -11,7 +11,6 @@ xref:testing/testcontext-framework.adoc[TestContext framework].
 * `@BootstrapWith`
 * `@ContextConfiguration`
 * `@ContextHierarchy`
-* `@ContextCustomizerFactories`
 * `@ActiveProfiles`
 * `@TestPropertySource`
 * `@DirtiesContext`

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

@@ -12,7 +12,6 @@ Spring's testing annotations include the following:
 * xref:testing/annotations/integration-spring/annotation-contextconfiguration.adoc[`@ContextConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-webappconfiguration.adoc[`@WebAppConfiguration`]
 * xref:testing/annotations/integration-spring/annotation-contexthierarchy.adoc[`@ContextHierarchy`]
-* xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[`@ContextCustomizerFactories`]
 * xref:testing/annotations/integration-spring/annotation-activeprofiles.adoc[`@ActiveProfiles`]
 * xref:testing/annotations/integration-spring/annotation-testpropertysource.adoc[`@TestPropertySource`]
 * xref:testing/annotations/integration-spring/annotation-dynamicpropertysource.adoc[`@DynamicPropertySource`]
@@ -27,5 +26,4 @@ Spring's testing annotations include the following:
 * xref:testing/annotations/integration-spring/annotation-sqlconfig.adoc[`@SqlConfig`]
 * xref:testing/annotations/integration-spring/annotation-sqlmergemode.adoc[`@SqlMergeMode`]
 * xref:testing/annotations/integration-spring/annotation-sqlgroup.adoc[`@SqlGroup`]
-* xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[`@DisabledInAotMode`]
 

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

@@ -1,45 +0,0 @@
-[[spring-testing-annotation-contextcustomizerfactories]]
-= `@ContextCustomizerFactories`
-
-`@ContextCustomizerFactories` is used to register `ContextCustomizerFactory`
-implementations for a particular test class, its subclasses, and its nested classes. If
-you wish to register a factory globally, you should register it via the automatic
-discovery mechanism described in
-xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[`ContextCustomizerFactory` Configuration].
-
-The following example shows how to register two `ContextCustomizerFactory` implementations:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@ContextConfiguration
-	@ContextCustomizerFactories({CustomContextCustomizerFactory.class, AnotherContextCustomizerFactory.class}) // <1>
-	class CustomContextCustomizerFactoryTests {
-		// class body...
-	}
-----
-<1> Register two `ContextCustomizerFactory` implementations.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@ContextConfiguration
-	@ContextCustomizerFactories([CustomContextCustomizerFactory::class, AnotherContextCustomizerFactory::class]) // <1>
-	class CustomContextCustomizerFactoryTests {
-		// class body...
-	}
-----
-<1> Register two `ContextCustomizerFactory` implementations.
-======
-
-
-By default, `@ContextCustomizerFactories` provides support for inheriting factories from
-superclasses or enclosing classes. See
-xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-nested-test-configuration[`@Nested` test class configuration] and the
-{api-spring-framework}/test/context/ContextCustomizerFactories.html[`@ContextCustomizerFactories`
-javadoc] for an example and further details.
-

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

@@ -1,20 +0,0 @@
-[[spring-testing-annotation-disabledinaotmode]]
-= `@DisabledInAotMode`
-
-`@DisabledInAotMode` signals that an annotated test class is disabled in Spring AOT
-(ahead-of-time) mode, which means that the `ApplicationContext` for the test class will
-not be processed for AOT optimizations at build time.
-
-If a test class is annotated with `@DisabledInAotMode`, all other test classes which
-specify configuration to load the same `ApplicationContext` must also be annotated with
-`@DisabledInAotMode`. Failure to annotate all such test classes will result in an
-exception, either at build time or run time.
-
-When used with JUnit Jupiter based tests, `@DisabledInAotMode` also signals that the
-annotated test class or test method is disabled when running the test suite in Spring AOT
-mode. When applied at the class level, all test methods within that class will be
-disabled. In this sense, `@DisabledInAotMode` has semantics similar to those of JUnit
-Jupiter's `@DisabledInNativeImage` annotation.
-
-For details on AOT support specific to integration tests, see
-xref:testing/testcontext-framework/aot.adoc[Ahead of Time Support for Tests].

framework-docs/modules/ROOT/pages/testing/spring-mvc-test-framework/server-setup-options.adoc

@@ -152,7 +152,7 @@ Kotlin::
 		@Autowired
 		lateinit var accountService: AccountService
 
-		lateinit mockMvc: MockMvc
+		lateinit var mockMvc: MockMvc
 
 		@BeforeEach
 		fun setup(wac: WebApplicationContext) {

framework-docs/modules/ROOT/pages/testing/testcontext-framework/aot.adoc

@@ -19,31 +19,7 @@ following features.
   use an AOT-optimized `ApplicationContext` that participates transparently with the
   xref:testing/testcontext-framework/ctx-management/caching.adoc[context cache].
 
-All tests are enabled in AOT mode by default. However, you can selectively disable an
-entire test class or individual test method in AOT mode by annotating it with
-xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[`@DisabledInAotMode`].
-When using JUnit Jupiter, you may selectively enable or disable tests in a GraalVM native
-image via Jupiter's `@EnabledInNativeImage` and `@DisabledInNativeImage` annotations.
-Note that `@DisabledInAotMode` also disables the annotated test class or test method when
-running within a GraalVM native image, analogous to JUnit Jupiter's
-`@DisabledInNativeImage` annotation.
-
-[TIP]
-====
-By default, if an error is encountered during build-time AOT processing, an exception
-will be thrown, and the overall process will fail immediately.
-
-If you would prefer that build-time AOT processing continue after errors are encountered,
-you can disable the `failOnError` mode which results in errors being logged at `WARN`
-level or with greater detail at `DEBUG` level.
-
-The `failOnError` mode can be disabled from the command line or a build script by setting
-a JVM system property named `spring.test.aot.processing.failOnError` to `false`. As an
-alternative, you can set the same property via the
-xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
-====
-
-[NOTE]
+[WARNING]
 ====
 The `@ContextHierarchy` annotation is currently not supported in AOT mode.
 ====

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management.adoc

@@ -112,7 +112,6 @@ advanced use cases.
 * xref:testing/testcontext-framework/ctx-management/groovy.adoc[Context Configuration with Groovy Scripts]
 * xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[Context Configuration with Component Classes]
 * xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[Mixing XML, Groovy Scripts, and Component Classes]
-* xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[Context Configuration with Context Customizers]
 * xref:testing/testcontext-framework/ctx-management/initializers.adoc[Context Configuration with Context Initializers]
 * xref:testing/testcontext-framework/ctx-management/inheritance.adoc[Context Configuration Inheritance]
 * xref:testing/testcontext-framework/ctx-management/env-profiles.adoc[Context Configuration with Environment Profiles]
@@ -120,6 +119,5 @@ advanced use cases.
 * xref:testing/testcontext-framework/ctx-management/dynamic-property-sources.adoc[Context Configuration with Dynamic Property Sources]
 * xref:testing/testcontext-framework/ctx-management/web.adoc[Loading a `WebApplicationContext`]
 * xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching]
-* xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[Context Failure Threshold]
 * xref:testing/testcontext-framework/ctx-management/hierarchies.adoc[Context Hierarchies]
 

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/caching.adoc

@@ -20,7 +20,7 @@ framework uses the following configuration parameters to build the context cache
 * `contextLoader` (from `@ContextConfiguration`)
 * `parent` (from `@ContextHierarchy`)
 * `activeProfiles` (from `@ActiveProfiles`)
-* `propertySourceDescriptors` (from `@TestPropertySource`)
+* `propertySourceLocations` (from `@TestPropertySource`)
 * `propertySourceProperties` (from `@TestPropertySource`)
 * `resourceBasePath` (from `@WebAppConfiguration`)
 

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/context-customizers.adoc

@@ -1,69 +0,0 @@
-[[testcontext-context-customizers]]
-= Configuration Configuration with Context Customizers
-
-A `ContextCustomizer` is responsible for customizing the supplied
-`ConfigurableApplicationContext` after bean definitions have been loaded into the context
-but before the context has been refreshed.
-
-A `ContextCustomizerFactory` is responsible for creating a `ContextCustomizer`, based on
-some custom logic which determines if the `ContextCustomizer` is necessary for a given
-test class -- for example, based on the presence of a certain annotation. Factories are
-invoked after `ContextLoaders` have processed context configuration attributes for a test
-class but before the `MergedContextConfiguration` is created.
-
-For example, Spring Framework provides the following `ContextCustomizerFactory`
-implementation which is registered by default:
-
-`MockServerContainerContextCustomizerFactory`:: Creates a
-  `MockServerContainerContextCustomizer` if WebSocket support is present in the classpath
-  and the test class or one of its enclosing classes is annotated or meta-annotated with
-  `@WebAppConfiguration`. `MockServerContainerContextCustomizer` instantiates a new
-  `MockServerContainer` and stores it in the `ServletContext` under the attribute named
-  `jakarta.websocket.server.ServerContainer`.
-
-
-[[testcontext-context-customizers-registration]]
-== Registering `ContextCustomizerFactory` Implementations
-
-You can register `ContextCustomizerFactory` implementations explicitly for a test class, its
-subclasses, and its nested classes by using the `@ContextCustomizerFactories` annotation. See
-xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[annotation support]
-and the javadoc for
-{api-spring-framework}/test/context/ContextCustomizerFactories.html[`@ContextCustomizerFactories`]
-for details and examples.
-
-
-[[testcontext-context-customizers-automatic-discovery]]
-== Automatic Discovery of Default `ContextCustomizerFactory` Implementations
-
-Registering `ContextCustomizerFactory` implementations by using `@ContextCustomizerFactories` is
-suitable for custom factories that are used in limited testing scenarios. However, it can
-become cumbersome if a custom factory needs to be used across an entire test suite. This
-issue is addressed through support for automatic discovery of default
-`ContextCustomizerFactory` implementations through the `SpringFactoriesLoader` mechanism.
-
-Specifically, the modules that make up the testing support in Spring Framework and Spring
-Boot declare all core default `ContextCustomizerFactory` implementations under the
-`org.springframework.test.context.ContextCustomizerFactory` key in their
-`META-INF/spring.factories` properties files. Third-party frameworks and developers can
-contribute their own `ContextCustomizerFactory` implementations to the list of default
-factories in the same manner through their own `META-INF/spring.factories` properties
-files.
-
-
-[[testcontext-context-customizers-merging]]
-== Merging `ContextCustomizerFactory` Implementations
-
-If a custom `ContextCustomizerFactory` is registered via `@ContextCustomizerFactories`, it
-will be _merged_ with the default factories that have been registered using the aforementioned
-xref:testing/testcontext-framework/ctx-management/context-customizers.adoc#testcontext-context-customizers-automatic-discovery[automatic discovery mechanism].
-
-The merging algorithm ensures that duplicates are removed from the list and that locally
-declared factories are appended to the list of default factories when merged.
-
-[TIP]
-====
-To replace the default factories for a test class, its subclasses, and its nested
-classes, you can set the `mergeMode` attribute of `@ContextCustomizerFactories` to
-`MergeMode.REPLACE_DEFAULTS`.
-====

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/failure-threshold.adoc

@@ -1,23 +0,0 @@
-[[testcontext-ctx-management-failure-threshold]]
-= Context Failure Threshold
-
-As of Spring Framework 6.1, a context _failure threshold_ policy is in place which helps
-avoid repeated attempts to load a failing `ApplicationContext`. By default, the failure
-threshold is set to `1` which means that only one attempt will be made to load an
-`ApplicationContext` for a given context cache key (see
-xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching]). Any
-subsequent attempt to load the `ApplicationContext` for the same context cache key will
-result in an immediate `IllegalStateException` with an error message which explains that
-the attempt was preemptively skipped. This behavior allows individual test classes and
-test suites to fail faster by avoiding repeated attempts to load an `ApplicationContext`
-that will never successfully load -- for example, due to a configuration error or a missing
-external resource that prevents the context from loading in the current environment.
-
-You can configure the context failure threshold from the command line or a build script
-by setting a JVM system property named `spring.test.context.failure.threshold` with a
-positive integer value. As an alternative, you can set the same property via the
-xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism.
-
-NOTE: If you wish to effectively disable the context failure threshold, you can set the
-property to a very large value. For example, from the command line you could set the
-system property via `-Dspring.test.context.failure.threshold=1000000`.

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/property-sources.adoc

@@ -16,7 +16,7 @@ SPI, but `@TestPropertySource` is not supported with implementations of the olde
 `ContextLoader` SPI.
 
 Implementations of `SmartContextLoader` gain access to merged test property source values
-through the `getPropertySourceDescriptors()` and `getPropertySourceProperties()` methods in
+through the `getPropertySourceLocations()` and `getPropertySourceProperties()` methods in
 `MergedContextConfiguration`.
 ====
 
@@ -26,23 +26,17 @@ through the `getPropertySourceDescriptors()` and `getPropertySourceProperties()`
 You can configure test properties files by using the `locations` or `value` attribute of
 `@TestPropertySource`.
 
-By default, both traditional and XML-based `java.util.Properties` file formats are
-supported -- for example, `"classpath:/com/example/test.properties"` or
-`"file:///path/to/file.xml"`. As of Spring Framework 6.1, you can configure a custom
-`PropertySourceFactory` via the `factory` attribute in `@TestPropertySource` in order to
-support a different file format such as JSON, YAML, etc.
+Both traditional and XML-based properties file formats are supported -- for example,
+`"classpath:/com/example/test.properties"` or `"file:///path/to/file.xml"`.
 
 Each path is interpreted as a Spring `Resource`. A plain path (for example,
 `"test.properties"`) is treated as a classpath resource that is relative to the package
 in which the test class is defined. A path starting with a slash is treated as an
 absolute classpath resource (for example: `"/org/example/test.xml"`). A path that
 references a URL (for example, a path prefixed with `classpath:`, `file:`, or `http:`) is
-loaded by using the specified resource protocol.
-
-Property placeholders in paths (such as `${...}`) will be resolved against the `Environment`.
-
-As of Spring Framework 6.1, resource location patterns are also supported — for
-example, `"classpath*:/config/*.properties"`.
+loaded by using the specified resource protocol. Resource location wildcards (such as
+`{asterisk}{asterisk}/{asterisk}.properties`) are not permitted: Each location must
+evaluate to exactly one `.properties` or `.xml` resource.
 
 The following example uses a test properties file:
 
@@ -86,20 +80,6 @@ a Java properties file:
 * `key:value`
 * `key value`
 
-[TIP]
-====
-Although properties can be defined using any of the above syntax variants and any number
-of spaces between the key and the value, it is recommended that you use one syntax
-variant and consistent spacing within your test suite — for example, consider always
-using `key = value` instead of `key= value`, `key=value`, etc. Similarly, if you define
-inlined properties using text blocks you should consistently use text blocks for inlined
-properties throughout your test suite.
-
-The reason is that the exact strings you provide will be used to determine the key for
-the context cache. Consequently, to benefit from the context cache you must ensure that
-you define inlined properties consistently.
-====
-
 The following example sets two inlined properties:
 
 [tabs]
@@ -109,61 +89,24 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	@ContextConfiguration
-	@TestPropertySource(properties = {"timezone = GMT", "port = 4242"}) // <1>
+	@TestPropertySource(properties = {"timezone = GMT", "port: 4242"}) // <1>
 	class MyIntegrationTests {
 		// class body...
 	}
 ----
-<1> Setting two properties via an array of strings.
+<1> Setting two properties by using two variations of the key-value syntax.
 
 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	@ContextConfiguration
-	@TestPropertySource(properties = ["timezone = GMT", "port = 4242"]) // <1>
+	@TestPropertySource(properties = ["timezone = GMT", "port: 4242"]) // <1>
 	class MyIntegrationTests {
 		// class body...
 	}
 ----
-<1> Setting two properties via an array of strings.
-======
-
-As of Spring Framework 6.1, you can use _text blocks_ to define multiple inlined
-properties in a single `String`. The following example sets two inlined properties using
-a text block:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@ContextConfiguration
-	@TestPropertySource(properties = """
-		timezone = GMT
-		port = 4242
-		""") // <1>
-	class MyIntegrationTests {
-		// class body...
-	}
-----
-<1> Setting two properties via a text block.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@ContextConfiguration
-	@TestPropertySource(properties = ["""
-		timezone = GMT
-		port = 4242
-		"""]) // <1>
-	class MyIntegrationTests {
-		// class body...
-	}
-----
-<1> Setting two properties via a text block.
+<1> Setting two properties by using two variations of the key-value syntax.
 ======
 
 [NOTE]
@@ -223,7 +166,7 @@ Java::
 	@ContextConfiguration
 	@TestPropertySource(
 		locations = "/test.properties",
-		properties = {"timezone = GMT", "port = 4242"}
+		properties = {"timezone = GMT", "port: 4242"}
 	)
 	class MyIntegrationTests {
 		// class body...
@@ -236,7 +179,7 @@ Kotlin::
 ----
 	@ContextConfiguration
 	@TestPropertySource("/test.properties",
-			properties = ["timezone = GMT", "port = 4242"]
+			properties = ["timezone = GMT", "port: 4242"]
 	)
 	class MyIntegrationTests {
 		// class body...

framework-docs/modules/ROOT/pages/testing/testcontext-framework/executing-sql.adoc

@@ -95,22 +95,13 @@ In addition to the aforementioned mechanisms for running SQL scripts programmati
 you can declaratively configure SQL scripts in the Spring TestContext Framework.
 Specifically, you can declare the `@Sql` annotation on a test class or test method to
 configure individual SQL statements or the resource paths to SQL scripts that should be
-run against a given database before or after an integration test class or test method.
-Support for `@Sql` is provided by the `SqlScriptsTestExecutionListener`, which is enabled
-by default.
+run against a given database before or after an integration test method. Support for
+`@Sql` is provided by the `SqlScriptsTestExecutionListener`, which is enabled by default.
 
-[NOTE]
-====
-Method-level `@Sql` declarations override class-level declarations by default, but this
-behavior may be configured per test class or per test method via `@SqlMergeMode`. See
-xref:testing/testcontext-framework/executing-sql.adoc#testcontext-executing-sql-declaratively-script-merging[Merging and Overriding Configuration with `@SqlMergeMode`]
-for further details.
-
-However, this does not apply to class-level declarations configured for the
-`BEFORE_TEST_CLASS` or `AFTER_TEST_CLASS` execution phases. Such declarations cannot be
-overridden, and the corresponding scripts and statements will be executed once per class
-in addition to any method-level scripts and statements.
-====
+NOTE: Method-level `@Sql` declarations override class-level declarations by default. As
+of Spring Framework 5.2, however, this behavior may be configured per test class or per
+test method via `@SqlMergeMode`. See
+xref:testing/testcontext-framework/executing-sql.adoc#testcontext-executing-sql-declaratively-script-merging[Merging and Overriding Configuration with `@SqlMergeMode`] for further details.
 
 [[testcontext-executing-sql-declaratively-script-resources]]
 === Path Resource Semantics
@@ -183,25 +174,17 @@ script, depending on where `@Sql` is declared. If a default cannot be detected,
   defined in the class `com.example.MyTest`, the corresponding default script is
   `classpath:com/example/MyTest.testMethod.sql`.
 
-[[testcontext-executing-sql-declaratively-logging]]
-=== Logging SQL Scripts and Statements
-
-If you want to see which SQL scripts are being executed, set the
-`org.springframework.test.context.jdbc` logging category to `DEBUG`.
-
-If you want to see which SQL statements are being executed, set the
-`org.springframework.jdbc.datasource.init` logging category to `DEBUG`.
-
 [[testcontext-executing-sql-declaratively-multiple-annotations]]
 === Declaring Multiple `@Sql` Sets
 
 If you need to configure multiple sets of SQL scripts for a given test class or test
 method but with different syntax configuration, different error handling rules, or
-different execution phases per set, you can declare multiple instances of `@Sql`. You can
-either use `@Sql` as a repeatable annotation, or you can use the `@SqlGroup` annotation
-as an explicit container for declaring multiple instances of `@Sql`.
+different execution phases per set, you can declare multiple instances of `@Sql`. With
+Java 8, you can use `@Sql` as a repeatable annotation. Otherwise, you can use the
+`@SqlGroup` annotation as an explicit container for declaring multiple instances of
+`@Sql`.
 
-The following example shows how to use `@Sql` as a repeatable annotation:
+The following example shows how to use `@Sql` as a repeatable annotation with Java 8:
 
 [tabs]
 ======
@@ -221,12 +204,7 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	@Test
-	@Sql("/test-schema.sql", config = SqlConfig(commentPrefix = "`"))
-	@Sql("/test-user-data.sql")
-	fun userTest() {
-		// run code that uses the test schema and test data
-	}
+	// Repeatable annotations with non-SOURCE retention are not yet supported by Kotlin
 ----
 ======
 
@@ -234,8 +212,9 @@ In the scenario presented in the preceding example, the `test-schema.sql` script
 different syntax for single-line comments.
 
 The following example is identical to the preceding example, except that the `@Sql`
-declarations are grouped together within `@SqlGroup`. The use of `@SqlGroup` is optional,
-but you may need to use `@SqlGroup` for compatibility with other JVM languages.
+declarations are grouped together within `@SqlGroup`. With Java 8 and above, the use of
+`@SqlGroup` is optional, but you may need to use `@SqlGroup` for compatibility with
+other JVM languages such as Kotlin.
 
 [tabs]
 ======
@@ -260,8 +239,7 @@ Kotlin::
 	@Test
 	@SqlGroup(
 		Sql("/test-schema.sql", config = SqlConfig(commentPrefix = "`")),
-		Sql("/test-user-data.sql")
-	)
+		Sql("/test-user-data.sql"))
 	fun userTest() {
 		// Run code that uses the test schema and test data
 	}
@@ -271,10 +249,10 @@ Kotlin::
 [[testcontext-executing-sql-declaratively-script-execution-phases]]
 === Script Execution Phases
 
-By default, SQL scripts are run before the corresponding test method. However, if you
-need to run a particular set of scripts after the test method (for example, to clean up
-database state), you can set the `executionPhase` attribute in `@Sql` to
-`AFTER_TEST_METHOD`, as the following example shows:
+By default, SQL scripts are run before the corresponding test method. However, if
+you need to run a particular set of scripts after the test method (for example, to clean
+up database state), you can use the `executionPhase` attribute in `@Sql`, as the
+following example shows:
 
 [tabs]
 ======
@@ -303,11 +281,12 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	@Test
-	@Sql("create-test-data.sql",
-		config = SqlConfig(transactionMode = ISOLATED))
-	@Sql("delete-test-data.sql",
-		config = SqlConfig(transactionMode = ISOLATED),
-		executionPhase = AFTER_TEST_METHOD)
+	@SqlGroup(
+		Sql("create-test-data.sql",
+			config = SqlConfig(transactionMode = ISOLATED)),
+		Sql("delete-test-data.sql",
+			config = SqlConfig(transactionMode = ISOLATED),
+			executionPhase = AFTER_TEST_METHOD))
 	fun userTest() {
 		// run code that needs the test data to be committed
 		// to the database outside of the test's transaction
@@ -315,60 +294,9 @@ Kotlin::
 ----
 ======
 
-NOTE: `ISOLATED` and `AFTER_TEST_METHOD` are statically imported from
+Note that `ISOLATED` and `AFTER_TEST_METHOD` are statically imported from
 `Sql.TransactionMode` and `Sql.ExecutionPhase`, respectively.
 
-As of Spring Framework 6.1, it is possible to run a particular set of scripts before or
-after the test class by setting the `executionPhase` attribute in a class-level `@Sql`
-declaration to `BEFORE_TEST_CLASS` or `AFTER_TEST_CLASS`, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@SpringJUnitConfig
-	@Sql(scripts = "/test-schema.sql", executionPhase = BEFORE_TEST_CLASS)
-	class DatabaseTests {
-
-		@Test
-		void emptySchemaTest() {
-			// run code that uses the test schema without any test data
-		}
-
-		@Test
-		@Sql("/test-user-data.sql")
-		void userTest() {
-			// run code that uses the test schema and test data
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@SpringJUnitConfig
-	@Sql("/test-schema.sql", executionPhase = BEFORE_TEST_CLASS)
-	class DatabaseTests {
-
-		@Test
-		fun emptySchemaTest() {
-			// run code that uses the test schema without any test data
-		}
-
-		@Test
-		@Sql("/test-user-data.sql")
-		fun userTest() {
-			// run code that uses the test schema and test data
-		}
-	}
-----
-======
-
-NOTE: `BEFORE_TEST_CLASS` is statically imported from `Sql.ExecutionPhase`.
-
 [[testcontext-executing-sql-declaratively-script-configuration]]
 === Script Configuration with `@SqlConfig`
 
@@ -396,7 +324,7 @@ individual attributes in {api-spring-framework}/test/context/jdbc/Sql.html[`@Sql
 {api-spring-framework}/test/context/jdbc/SqlConfig.html[`@SqlConfig`] for details.
 
 [[testcontext-executing-sql-declaratively-tx]]
-==== Transaction management for `@Sql`
+*Transaction management for `@Sql`*
 
 By default, the `SqlScriptsTestExecutionListener` infers the desired transaction
 semantics for scripts configured by using `@Sql`. Specifically, SQL scripts are run

framework-docs/modules/ROOT/pages/testing/testcontext-framework/support-classes.adoc

@@ -177,7 +177,7 @@ following features above and beyond the feature set that Spring supports for JUn
 TestNG:
 
 * Dependency injection for test constructors, test methods, and test lifecycle callback
-  methods. See xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[Dependency Injection with the `SpringExtension`] for further details.
+  methods. See xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-di[Dependency Injection with `SpringExtension`] for further details.
 * Powerful support for link:https://junit.org/junit5/docs/current/user-guide/#extensions-conditions[conditional
   test execution] based on SpEL expressions, environment variables, system properties,
   and so on. See the documentation for `@EnabledIf` and `@DisabledIf` in
@@ -310,19 +310,17 @@ See the documentation for `@SpringJUnitConfig` and `@SpringJUnitWebConfig` in
 xref:testing/annotations/integration-junit-jupiter.adoc[Spring JUnit Jupiter Testing Annotations] for further details.
 
 [[testcontext-junit-jupiter-di]]
-=== Dependency Injection with the `SpringExtension`
+=== Dependency Injection with `SpringExtension`
 
-The `SpringExtension` implements the
+`SpringExtension` implements the
 link:https://junit.org/junit5/docs/current/user-guide/#extensions-parameter-resolution[`ParameterResolver`]
 extension API from JUnit Jupiter, which lets Spring provide dependency injection for test
 constructors, test methods, and test lifecycle callback methods.
 
-Specifically, the `SpringExtension` can inject dependencies from the test's
+Specifically, `SpringExtension` can inject dependencies from the test's
 `ApplicationContext` into test constructors and methods that are annotated with
-Spring's `@BeforeTransaction` and `@AfterTransaction` or JUnit's `@BeforeAll`,
-`@AfterAll`, `@BeforeEach`, `@AfterEach`, `@Test`, `@RepeatedTest`, `@ParameterizedTest`,
-and others.
-
+`@BeforeAll`, `@AfterAll`, `@BeforeEach`, `@AfterEach`, `@Test`, `@RepeatedTest`,
+`@ParameterizedTest`, and others.
 
 [[testcontext-junit-jupiter-di-constructor]]
 ==== Constructor Injection
@@ -536,7 +534,7 @@ The _Spring TestContext Framework_ has supported the use of test-related annotat
 Framework 5.3 class-level test configuration annotations were not _inherited_ from
 enclosing classes like they are from superclasses.
 
-Spring Framework 5.3 introduced first-class support for inheriting test class
+Spring Framework 5.3 introduces first-class support for inheriting test class
 configuration from enclosing classes, and such configuration will be inherited by
 default. To change from the default `INHERIT` mode to `OVERRIDE` mode, you may annotate
 an individual `@Nested` test class with

framework-docs/modules/ROOT/pages/testing/testcontext-framework/tx.adoc

@@ -295,56 +295,14 @@ behavior after your test runs (if the test was configured to commit the transact
 `TransactionalTestExecutionListener` supports the `@BeforeTransaction` and
 `@AfterTransaction` annotations for exactly such scenarios. You can annotate any `void`
 method in a test class or any `void` default method in a test interface with one of these
-annotations, and the `TransactionalTestExecutionListener` ensures that your
-before-transaction method or after-transaction method runs at the appropriate time.
+annotations, and the `TransactionalTestExecutionListener` ensures that your before
+transaction method or after transaction method runs at the appropriate time.
 
-[NOTE]
-====
-Generally speaking, `@BeforeTransaction` and `@AfterTransaction` methods must not accept
-any arguments.
-
-However, as of Spring Framework 6.1, for tests using the 
-xref:testing/testcontext-framework/support-classes.adoc#testcontext-junit-jupiter-extension[`SpringExtension`]
-with JUnit Jupiter, `@BeforeTransaction` and `@AfterTransaction` methods may optionally
-accept arguments which will be resolved by any registered JUnit `ParameterResolver`
-extension such as the `SpringExtension`. This means that JUnit-specific arguments like
-`TestInfo` or beans from the test's `ApplicationContext` may be provided to
-`@BeforeTransaction` and `@AfterTransaction` methods, as demonstrated in the following
-example.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-@BeforeTransaction
-void verifyInitialDatabaseState(@Autowired DataSource dataSource) {
-	// Use the DataSource to verify the initial state before a transaction is started
-}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-@BeforeTransaction
-fun verifyInitialDatabaseState(@Autowired dataSource: DataSource) {
-	// Use the DataSource to verify the initial state before a transaction is started
-}
-----
-======
-====
-
-[TIP]
-====
-Any before methods (such as methods annotated with JUnit Jupiter's `@BeforeEach`) and any
-after methods (such as methods annotated with JUnit Jupiter's `@AfterEach`) are run
-within the test-managed transaction for a transactional test method.
-
-Similarly, methods annotated with `@BeforeTransaction` or `@AfterTransaction` are only
-run for transactional test methods.
-====
+TIP: Any before methods (such as methods annotated with JUnit Jupiter's `@BeforeEach`)
+and any after methods (such as methods annotated with JUnit Jupiter's `@AfterEach`) are
+run within a transaction. In addition, methods annotated with `@BeforeTransaction` or
+`@AfterTransaction` are not run for test methods that are not configured to run within a
+transaction.
 
 [[testcontext-tx-mgr-config]]
 == Configuring a Transaction Manager

framework-docs/modules/ROOT/pages/web/webflux-webclient/client-filter.adoc

@@ -148,75 +148,5 @@ Kotlin::
 ----
 ======
 
-The example below demonstrates how to use the `ExchangeFilterFunction` interface to create
-a custom filter class that helps with computing a `Content-Length` header for `PUT` and `POST`
-`multipart/form-data` requests using buffering.
 
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-public class MultipartExchangeFilterFunction implements ExchangeFilterFunction {
 
-    @Override
-    public Mono<ClientResponse> filter(ClientRequest request, ExchangeFunction next) {
-        if (MediaType.MULTIPART_FORM_DATA.includes(request.headers().getContentType())
-                && (request.method() == HttpMethod.PUT || request.method() == HttpMethod.POST)) {
-            return next.exchange(ClientRequest.from(request).body((outputMessage, context) ->
-                request.body().insert(new BufferingDecorator(outputMessage), context)).build()
-            );
-        } else {
-            return next.exchange(request);
-        }
-    }
-
-    private static final class BufferingDecorator extends ClientHttpRequestDecorator {
-
-        private BufferingDecorator(ClientHttpRequest delegate) {
-            super(delegate);
-        }
-
-        @Override
-        public Mono<Void> writeWith(Publisher<? extends DataBuffer> body) {
-            return DataBufferUtils.join(body).flatMap(buffer -> {
-                getHeaders().setContentLength(buffer.readableByteCount());
-                return super.writeWith(Mono.just(buffer));
-            });
-        }
-    }
-}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-class MultipartExchangeFilterFunction : ExchangeFilterFunction {
-
-    override fun filter(request: ClientRequest, next: ExchangeFunction): Mono<ClientResponse> {
-        return if (MediaType.MULTIPART_FORM_DATA.includes(request.headers().getContentType())
-            && (request.method() == HttpMethod.PUT || request.method() == HttpMethod.POST)) {
-            next.exchange(ClientRequest.from(request)
-                .body { message, context -> request.body().insert(BufferingDecorator(message), context) }
-                .build())
-        }
-        else {
-            next.exchange(request)
-        }
-
-    }
-
-    private class BufferingDecorator(delegate: ClientHttpRequest) : ClientHttpRequestDecorator(delegate) {
-        override fun writeWith(body: Publisher<out DataBuffer>): Mono<Void> {
-            return DataBufferUtils.join(body)
-                .flatMap {
-                    headers.contentLength = it.readableByteCount().toLong()
-                    super.writeWith(Mono.just(it))
-                }
-        }
-    }
-}
-----
-======

framework-docs/modules/ROOT/pages/web/webflux/ann-rest-exceptions.adoc

@@ -67,44 +67,52 @@ from an existing `ProblemDetail`. This could be done centrally, e.g. from an
 
 
 [[webflux-ann-rest-exceptions-i18n]]
-== Customization and i18n
+== Internationalization
 [.small]#xref:web/webmvc/mvc-ann-rest-exceptions.adoc#mvc-ann-rest-exceptions-i18n[See equivalent in the Servlet stack]#
 
-It is a common requirement to customize and internationalize error response details.
-It is also good practice to customize the problem details for Spring WebFlux exceptions
-to avoid revealing implementation details. This section describes the support for that.
+It is a common requirement to internationalize error response details, and good practice
+to customize the problem details for Spring WebFlux exceptions. This is supported as follows:
 
-An `ErrorResponse` exposes message codes for "type", "title", and "detail", as well as
-message code arguments for the "detail" field. `ResponseEntityExceptionHandler` resolves
-these through a xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-and updates the corresponding `ProblemDetail` fields accordingly.
+- Each `ErrorResponse` exposes a message code and arguments to resolve the "detail" field
+through a xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource].
+The actual message code value is parameterized with placeholders, e.g.
+`+"HTTP method {0} not supported"+` to be expanded from the arguments.
+- Each `ErrorResponse` also exposes a message code to resolve the "title" field.
+- `ResponseEntityExceptionHandler` uses the message code and arguments to resolve the
+"detail" and the "title" fields.
 
-The default strategy for message codes follows the pattern:
-
-`problemDetail.[type|title|detail].[fully qualified exception class name]`
-
-An `ErrorResponse` may expose more than one message code, typically adding a suffix
-to the default message code. The table below lists message codes, and arguments for
-Spring WebFlux exceptions:
+By default, the message code for the "detail" field is "problemDetail." + the fully
+qualified exception class name. Some exceptions may expose additional message codes in
+which case a suffix is added to the default message code. The table below lists message
+arguments and codes for Spring WebFlux exceptions:
 
 [[webflux-ann-rest-exceptions-codes]]
 [cols="1,1,2", options="header"]
 |===
 | Exception | Message Code | Message Code Arguments
 
-| `HandlerMethodValidationException`
+| `UnsupportedMediaTypeStatusException`
 | (default)
-| `+{0}+` list all validation errors.
-Message codes and arguments for each error are also resolved via `MessageSource`.
+| `+{0}+` the media type that is not supported, `+{1}+` list of supported media types
 
-| `MethodNotAllowedException`
-| (default)
-| `+{0}+` the current HTTP method, `+{1}+` the list of supported HTTP methods
+| `UnsupportedMediaTypeStatusException`
+| (default) + ".parseError"
+|
 
 | `MissingRequestValueException`
 | (default)
 | `+{0}+` a label for the value (e.g. "request header", "cookie value", ...), `+{1}+` the value name
 
+| `UnsatisfiedRequestParameterException`
+| (default)
+| `+{0}+` the list of parameter conditions
+
+| `WebExchangeBindException`
+| (default)
+| `+{0}+` the list of global errors, `+{1}+` the list of field errors.
+Message codes and arguments for each error within the `BindingResult` are also resolved
+via `MessageSource`.
+
 | `NotAcceptableStatusException`
 | (default)
 | `+{0}+` list of supported media types
@@ -117,32 +125,14 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 | (default)
 | `+{0}+` the failure reason provided to the class constructor
 
-| `UnsupportedMediaTypeStatusException`
+| `MethodNotAllowedException`
 | (default)
-| `+{0}+` the media type that is not supported, `+{1}+` list of supported media types
-
-| `UnsupportedMediaTypeStatusException`
-| (default) + ".parseError"
-|
-
-| `UnsatisfiedRequestParameterException`
-| (default)
-| `+{0}+` the list of parameter conditions
-
-| `WebExchangeBindException`
-| (default)
-| `+{0}+` the list of global errors, `+{1}+` the list of field errors.
-Message codes and arguments for each error are also resolved via `MessageSource`.
+| `+{0}+` the current HTTP method, `+{1}+` the list of supported HTTP methods
 
 |===
 
-NOTE: Unlike other exceptions, the message arguments for
-`WebExchangeBindException` and `HandlerMethodValidationException` are based on a list of
-`MessageSourceResolvable` errors that can also be customized through a
-xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
-resource bundle. See
-xref:core/validation/beanvalidation.adoc#validation-beanvalidation-spring-method-i18n[Customizing Validation Errors]
-for more details.
+By default, the message code for the "title" field is "problemDetail.title." + the fully
+qualified exception class name.
 
 
 

framework-docs/modules/ROOT/pages/web/webflux/config.adoc

@@ -700,8 +700,9 @@ Java::
 
 		@Override
 		public void configurePathMatch(PathMatchConfigurer configurer) {
-			configurer.addPathPrefix(
-					"/api", HandlerTypePredicate.forAnnotation(RestController.class));
+			configurer
+				.setUseCaseSensitiveMatch(true)
+				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController.class));
 		}
 	}
 ----
@@ -716,8 +717,9 @@ Kotlin::
 
 		@Override
 		fun configurePathMatch(configurer: PathMatchConfigurer) {
-			configurer.addPathPrefix(
-					"/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
+			configurer
+				.setUseCaseSensitiveMatch(true)
+				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
 		}
 	}
 ----
@@ -738,59 +740,6 @@ reliance on it.
 
 
 
-
-[[webflux-config-blocking-execution]]
-== Blocking Execution
-
-The WebFlux Java config allows you to customize blocking execution in WebFlux.
-
-You can have blocking controller methods called on a separate thread by providing
-an `AsyncTaskExecutor` such as the
-{api-spring-framework}/core/task/VirtualThreadTaskExecutor.html[`VirtualThreadTaskExecutor`]
-as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@Configuration
-	@EnableWebFlux
-	public class WebConfig implements WebFluxConfigurer {
-
-		@Override
-		public void configureBlockingExecution(BlockingExecutionConfigurer configurer) {
-			AsyncTaskExecutor executor = ...
-			configurer.setExecutor(executor);
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@Configuration
-	@EnableWebFlux
-	class WebConfig : WebFluxConfigurer {
-
-		@Override
-		fun configureBlockingExecution(configurer: BlockingExecutionConfigurer) {
-			val executor = ...
-			configurer.setExecutor(executor)
-		}
-	}
-----
-======
-
-By default, controller methods whose return type is not recognized by the configured
-`ReactiveAdapterRegistry` are considered blocking, but you can set a custom controller
-method predicate via `BlockingExecutionConfigurer`.
-
-
-
-
 [[webflux-config-websocket-service]]
 == WebSocketService
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-initbinder.adoc

@@ -3,21 +3,23 @@
 
 [.small]#xref:web/webmvc/mvc-controller/ann-initbinder.adoc[See equivalent in the Servlet stack]#
 
-`@Controller` or `@ControllerAdvice` classes can have `@InitBinder` methods to
-initialize `WebDataBinder` instances that in turn can:
+`@Controller` or `@ControllerAdvice` classes can have `@InitBinder` methods, to
+initialize instances of `WebDataBinder`. Those, in turn, are used to:
 
-* Bind request parameters to a model object.
-* Convert request values from string to object property types.
-* Format model object properties as strings when rendering HTML forms.
+* Bind request parameters (that is, form data or query) to a model object.
+* Convert `String`-based request values (such as request parameters, path variables,
+headers, cookies, and others) to the target type of controller method arguments.
+* Format model object values as `String` values when rendering HTML forms.
 
-In an `@Controller`, `DataBinder` customizations apply locally within the controller,
-or even to a specific model attribute referenced by name through the annotation.
-In an `@ControllerAdvice` customizations can apply to all or a subset of controllers.
+`@InitBinder` methods can register controller-specific `java.beans.PropertyEditor` or
+Spring `Converter` and `Formatter` components. In addition, you can use the
+xref:web/webflux/config.adoc#webflux-config-conversion[WebFlux Java configuration] to register `Converter` and
+`Formatter` types in a globally shared `FormattingConversionService`.
 
-You can register `PropertyEditor`, `Converter`, and `Formatter` components in the
-`DataBinder` for type conversion. Alternatively, you can use the
-xref:web/webflux/config.adoc#webflux-config-conversion[WebFlux config] to register
-`Converter` and `Formatter` components  in a globally shared `FormattingConversionService`.
+`@InitBinder` methods support many of the same arguments that `@RequestMapping` methods
+do, except for `@ModelAttribute` (command object) arguments. Typically, they are declared
+with a `WebDataBinder` argument, for registrations, and a `void` return value.
+The following example uses the `@InitBinder` annotation:
 
 --
 [tabs]
@@ -110,5 +112,4 @@ Kotlin::
 == Model Design
 [.small]#xref:web/webmvc/mvc-controller/ann-initbinder.adoc#mvc-ann-initbinder-model-design[See equivalent in the Servlet stack]#
 
-include::partial$web/web-data-binding-model-design.adoc[]
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/modelattrib-method-args.adoc

@@ -3,8 +3,11 @@
 
 [.small]#xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[See equivalent in the Servlet stack]#
 
-The `@ModelAttribute` method parameter annotation binds request parameters onto a model
-object. For example:
+You can use the `@ModelAttribute` annotation on a method argument to access an attribute from the
+model or have it instantiated if not present. The model attribute is also overlaid with
+the values of query parameters and form fields whose names match to field names. This is
+referred to as data binding, and it saves you from having to deal with parsing and
+converting individual query parameters and form fields. The following example binds an instance of `Pet`:
 
 [tabs]
 ======
@@ -15,7 +18,7 @@ Java::
 	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
 	public String processSubmit(@ModelAttribute Pet pet) { } // <1>
 ----
-<1> Bind to an instance of `Pet`.
+<1> Bind an instance of `Pet`.
 
 Kotlin::
 +
@@ -24,66 +27,28 @@ Kotlin::
 	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
 	fun processSubmit(@ModelAttribute pet: Pet): String { } // <1>
 ----
-<1> Bind to an instance of `Pet`.
+<1> Bind an instance of `Pet`.
 ======
 
-The `Pet` instance may be:
+The `Pet` instance in the preceding example is resolved as follows:
 
-* Accessed from the model where it could have been added by a
-  xref:web/webflux/controller/ann-modelattrib-methods.adoc[`Model`].
-* Accessed from the HTTP session if the model attribute was listed in
-  the class-level xref:web/webflux/controller/ann-methods/sessionattributes.adoc[`@SessionAttributes`].
-* Instantiated through a default constructor.
-* Instantiated through a "`primary constructor`" with arguments that match to Servlet
-request parameters. Argument names are determined through runtime-retained parameter
-names in the bytecode.
+* From the model if already added through xref:web/webflux/controller/ann-modelattrib-methods.adoc[`Model`].
+* From the HTTP session through xref:web/webflux/controller/ann-methods/sessionattributes.adoc[`@SessionAttributes`].
+* From the invocation of a default constructor.
+* From the invocation of a "`primary constructor`" with arguments that match query
+parameters or form fields. Argument names are determined through JavaBeans
+`@ConstructorProperties` or through runtime-retained parameter names in the bytecode.
 
-By default, both constructor and property
-xref:core/validation/beans-beans.adoc#beans-binding[data binding] are applied. However,
-model object design requires careful consideration, and for security reasons it is
-recommended either to use an object tailored specifically for web binding, or to apply
-constructor binding only. If property binding must still be used, then _allowedFields_
-patterns should be set to limit which properties can be set. For further details on this
-and example configuration, see
-xref:web/webflux/controller/ann-initbinder.adoc#webflux-ann-initbinder-model-design[model design].
+After the model attribute instance is obtained, data binding is applied. The
+`WebExchangeDataBinder` class matches names of query parameters and form fields to field
+names on the target `Object`. Matching fields are populated after type conversion is applied
+where necessary. For more on data binding (and validation), see
+xref:web/webmvc/mvc-config/validation.adoc[Validation]. For more on customizing data binding, see
+xref:web/webflux/controller/ann-initbinder.adoc[`DataBinder`].
 
-When using constructor binding, you can customize request parameter names through an
-`@BindParam` annotation. For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	class Account {
-
-	    private final String firstName;
-
-		public Account(@BindParam("first-name") String firstName) {
-			this.firstName = firstName;
-		}
-	}
-----
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class Account(@BindParam("first-name") val firstName: String)
-----
-======
-
-NOTE: The `@BindParam` may also be placed on the fields that correspond to constructor
-parameters. While `@BindParam` is supported out of the box, you can also use a
-different annotation by setting a `DataBinder.NameResolver` on `DataBinder`
-
-WebFlux, unlike Spring MVC, supports reactive types in the model, e.g. `Mono<Account>`.
-You can declare a `@ModelAttribute` argument with or without a reactive type wrapper, and
-it will be resolved accordingly to the actual value.
-
-If data binding results in errors, by default a `WebExchangeBindException` is raised,
-but you can also add a `BindingResult` argument immediately next to the `@ModelAttribute`
-in order to handle such errors in the controller method. For example:
+Data binding can result in errors. By default, a `WebExchangeBindException` is raised, but,
+to check for such errors in the controller method, you can add a `BindingResult` argument
+immediately next to the `@ModelAttribute`, as the following example shows:
 
 [tabs]
 ======
@@ -116,9 +81,49 @@ Kotlin::
 <1> Adding a `BindingResult`.
 ======
 
-To use a `BindingResult` argument, you must declare the `@ModelAttribute` argument before
-it without a reactive type wrapper. If you want to use the reactive, you can handle errors
-directly through it. For example:
+You can automatically apply validation after data binding by adding the
+`jakarta.validation.Valid` annotation or Spring's `@Validated` annotation (see also
+xref:core/validation/beanvalidation.adoc[Bean Validation] and
+xref:web/webmvc/mvc-config/validation.adoc[Spring validation]). The following example uses the `@Valid` annotation:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
+	public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) { // <1>
+		if (result.hasErrors()) {
+			return "petForm";
+		}
+		// ...
+	}
+----
+<1> Using `@Valid` on a model attribute argument.
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
+	fun processSubmit(@Valid @ModelAttribute("pet") pet: Pet, result: BindingResult): String { // <1>
+		if (result.hasErrors()) {
+			return "petForm"
+		}
+		// ...
+	}
+----
+<1> Using `@Valid` on a model attribute argument.
+======
+
+Spring WebFlux, unlike Spring MVC, supports reactive types in the model -- for example,
+`Mono<Account>` or `io.reactivex.Single<Account>`. You can declare a `@ModelAttribute` argument
+with or without a reactive type wrapper, and it will be resolved accordingly,
+to the actual value if necessary. However, note that, to use a `BindingResult`
+argument, you must declare the `@ModelAttribute` argument before it without a reactive
+type wrapper, as shown earlier. Alternatively, you can handle any errors through the
+reactive type, as the following example shows:
 
 [tabs]
 ======
@@ -155,49 +160,13 @@ Kotlin::
 ----
 ======
 
-You can automatically apply validation after data binding by adding the
-`jakarta.validation.Valid` annotation or Spring's `@Validated` annotation (see
-xref:core/validation/beanvalidation.adoc[Bean Validation] and
-xref:web/webmvc/mvc-config/validation.adoc[Spring validation]). For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
-	public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) { // <1>
-		if (result.hasErrors()) {
-			return "petForm";
-		}
-		// ...
-	}
-----
-<1> Using `@Valid` on a model attribute argument.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
-	fun processSubmit(@Valid @ModelAttribute("pet") pet: Pet, result: BindingResult): String { // <1>
-		if (result.hasErrors()) {
-			return "petForm"
-		}
-		// ...
-	}
-----
-<1> Using `@Valid` on a model attribute argument.
-======
-
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` would be raised instead. See the section on
-controller method xref:web/webmvc/mvc-controller/ann-validation.adoc[Validation].
-
-TIP: Using `@ModelAttribute` is optional. By default, any argument that is not a simple
-value type as determined by
-{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]
-_AND_ that is not resolved by any other argument resolver is treated as an `@ModelAttribute`.
-
+Note that use of `@ModelAttribute` is optional -- for example, to set its attributes.
+By default, any argument that is not a simple value type (as determined by
+{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty])
+and is not resolved by any other argument resolver is treated as if it were annotated
+with `@ModelAttribute`.
 
+WARNING: When compiling to a native image with GraalVM, the implicit `@ModelAttribute`
+support described above does not allow proper ahead-of-time inference of related data
+binding reflection hints. As a consequence, it is recommended to explicitly annotate
+method parameters with `@ModelAttribute` for use in a GraalVM native image.

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/multipart-forms.adoc

@@ -176,10 +176,6 @@ Kotlin::
 ======
 --
 
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` is raised instead. See the section on
-xref:web/webflux/controller/ann-validation.adoc[Validation].
-
 To access all multipart data as a `MultiValueMap`, you can use `@RequestBody`,
 as the following example shows:
 
@@ -310,3 +306,5 @@ file upload.
 
 Received part events can also be relayed to another service by using the `WebClient`.
 See xref:web/webflux-webclient/client-body.adoc#webflux-client-body-multipart[Multipart Data].
+
+

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/requestbody.adoc

@@ -89,33 +89,4 @@ Kotlin::
 ----
 ======
 
-You can also declare an `Errors` parameter for access to validation errors, but in
-that case the request body must not be a `Mono`, and will be resolved first:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@PostMapping("/accounts")
-	public void handle(@Valid @RequestBody Account account, Errors errors) {
-		// use one of the onError* operators...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@PostMapping("/accounts")
-	fun handle(@Valid @RequestBody account: Mono<Account>) {
-		// ...
-	}
-----
-======
-
-If method validation applies because other parameters have `@Constraint` annotations,
-then `HandlerMethodValidationException` is raised instead. For more details, see the
-section on xref:web/webflux/controller/ann-validation.adoc[Validation].
 

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-requestmapping.adoc

@@ -1,15 +1,8 @@
 [[webflux-ann-requestmapping]]
-= Mapping Requests
+= Request Mapping
 
 [.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc[See equivalent in the Servlet stack]#
 
-This section discusses request mapping for annotated controllers.
-
-[[webflux-ann-requestmapping-annotation]]
-== `@RequestMapping`
-
-[.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc#mvc-ann-requestmapping-annotation[See equivalent in the Servlet stack]#
-
 The `@RequestMapping` annotation is used to map requests to controllers methods. It has
 various attributes to match by URL, HTTP method, request parameters, headers, and media
 types. You can use it at the class level to express shared mappings or at the method level
@@ -507,68 +500,3 @@ Kotlin::
 
 
 
-[[webflux-ann-httpexchange-annotation]]
-== `@HttpExchange`
-[.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc#mvc-ann-httpexchange-annotation[See equivalent in the Reactive stack]#
-
-As an alternative to  `@RequestMapping`, you can also handle requests with `@HttpExchange`
-methods. Such methods are declared on an
-xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] and can be used as
-a client via `HttpServiceProxyFactory` or implemented by a server `@Controller`.
-
-For example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	@RestController
-	@HttpExchange("/persons")
-	class PersonController {
-
-		@GetExchange("/{id}")
-		public Person getPerson(@PathVariable Long id) {
-			// ...
-		}
-
-		@PostExchange
-		@ResponseStatus(HttpStatus.CREATED)
-		public void add(@RequestBody Person person) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	@RestController
-	@HttpExchange("/persons")
-	class PersonController {
-
-		@GetExchange("/{id}")
-		fun getPerson(@PathVariable id: Long): Person {
-			// ...
-		}
-
-		@PostExchange
-		@ResponseStatus(HttpStatus.CREATED)
-		fun add(@RequestBody person: Person) {
-			// ...
-		}
-	}
-----
-======
-
-There some differences between `@HttpExchange` and `@RequestMapping` since the
-former needs to remain suitable for client and server use. For example, while
-`@RequestMapping` can be declared to handle any number of paths and each path can
-be a pattern, `@HttpExchange` must be declared with a single, concrete path. There are
-also differences in the supported method parameters. Generally, `@HttpExchange` supports
-a subset of method parameters that `@RequestMapping` does, excluding any parameters that
-are server side only. For details see the list of supported method parameters for
-xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[HTTP interface] and for
-xref:web/webflux/controller/ann-methods/arguments.adoc[@RequestMapping].