Release v6.0.0

Add milestone repo for optional Netty 5 support
Closes gh-29498
2026-06-08 17:33:33 +00:00 · 2022-11-16 10:07:46 +00:00 · 2022-11-16 11:03:14 +01:00 · 2022-11-16 09:58:04 +01:00 · 2022-11-16 08:16:57 +01:00 · 2022-11-15 20:10:03 +01:00
4837 changed files with 150224 additions and 100670 deletions
@@ -0,0 +1,29 @@
+name: Backport Bot
+
+on:
+  issues:
+    types: [labeled]
+  push:
+    branches:
+      - '*.x'
+permissions:
+  contents: read
+jobs:
+  build:
+    permissions:
+      contents: read
+      issues: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          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
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_EVENT: ${{ toJSON(github.event) }}
+        run: java -jar backport-bot-0.0.1-SNAPSHOT.jar --github.accessToken="$GITHUB_TOKEN" --github.event_name "$GITHUB_EVENT_NAME" --github.event "$GITHUB_EVENT"
@@ -1,10 +1,13 @@
 name: "Validate Gradle Wrapper"
 on: [push, pull_request]

+permissions:
+  contents: read
+
 jobs:
  validation:
    name: "Validation"
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
      - uses: gradle/wrapper-validation-action@v1
@@ -1,35 +1,42 @@
+# Miscellaneous
 *.java.hsp
 *.sonarj
 *.sw*
 .DS_Store
-.settings
-.springBeans
-bin
 build.sh
 integration-repo
 ivy-cache
+argfile*
+activemq-data/
+classes/
+
+# Log files
 jxl.log
 jmx.log
 derby.log
-spring-test/test-output/
-.gradle
-argfile*
-pom.xml
-activemq-data/

-classes/
+# Gradle artifacts
+.gradle
+.gradletasknamecache
 /build
 buildSrc/build
 /spring-*/build
-/spring-core/kotlin-coroutines/build
 /framework-bom/build
+/framework-docs/build
 /integration-tests/build
 /src/asciidoc/build
+spring-test/test-output/
+
+# Maven artifacts
+pom.xml
 target/

 # Eclipse artifacts, including WTP generated manifests
+bin
 .classpath
 .project
+.settings
+.springBeans
 spring-*/src/main/java/META-INF/MANIFEST.MF

 # IDEA artifacts and output dirs
@@ -40,7 +47,6 @@ spring-*/src/main/java/META-INF/MANIFEST.MF
 out
 test-output
 atlassian-ide-plugin.xml
-.gradletasknamecache

 # VS Code
-.vscode/
+.vscode/
@@ -1,23 +1,34 @@
-Juergen Hoeller <jhoeller@pivotal.io> jhoeller <jhoeller@vmware.com>
-<jhoeller@pivotal.io> <jhoeller@vmware.com>
-<jhoeller@pivotal.io> <jhoeller@gopivotal.com>
-<rstoyanchev@pivotal.io> <rstoyanchev@vmware.com>
-<rstoyanchev@pivotal.io> <rstoyanchev@gopivotal.com>
-<pwebb@pivotal.io> <pwebb@vmware.com>
-<pwebb@pivotal.io> <pwebb@gopivotal.com>
-<cbeams@pivotal.io> <cbeams@vmware.com>
-<cbeams@pivotal.io> <cbeams@gopivotal.com>
-<cbeams@pivotal.io> <cbeams@gmail.com>
-<apoutsma@pivotal.io> <apoutsma@vmware.com>
-<apoutsma@pivotal.io> <apoutsma@gopivotal.com>
-<apoutsma@pivotal.io> <poutsma@mac.com>
-<ogierke@pivotal.io> <ogierke@vmware.com>
-<ogierke@pivotal.io> <ogierke@gopivotal.com>
-<dsyer@pivotal.io> <dsyer@vmware.com>
-<dsyer@pivotal.io> <dsyer@gopivotal.com>
-<dsyer@pivotal.io> <david_syer@hotmail.com>
-<aclement@pivotal.io> <aclement@vmware.com>
-<aclement@pivotal.io> <aclement@gopivotal.com>
-<aclement@pivotal.io> <andrew.clement@gmail.com>
+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>
 <dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
-Nick Williams <nicholas@nicholaswilliams.net> Nicholas Williams <nicholas@nicholaswilliams.net>
+Nick Williams <nicholas@nicholaswilliams.net>
@@ -0,0 +1,3 @@
+# Enable auto-env through the sdkman_auto_env config
+# Add key=value pairs of SDKs to use below
+java=17.0.5-librca
@@ -6,7 +6,7 @@ First off, thank you for taking the time to contribute! :+1: :tada:

 * [Code of Conduct](#code-of-conduct)
 * [How to Contribute](#how-to-contribute)
-  * [Discuss](#discuss)
+  * [Ask questions](#ask-questions)
  * [Create an Issue](#create-an-issue)
  * [Issue Lifecycle](#issue-lifecycle)
  * [Submit a Pull Request](#submit-a-pull-request)
@@ -22,11 +22,10 @@ Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.

 ### How to Contribute

-#### Discuss
+#### Ask questions

 If you have a question, check Stack Overflow using
-[this list of tags](https://stackoverflow.com/questions/tagged/spring+or+spring-mvc+or+spring-aop+or+spring-jdbc+or+spring-transactions+or+spring-annotations+or+spring-jms+or+spring-el+or+spring-test+or+spring+or+spring-remoting+or+spring-orm+or+spring-jmx+or+spring-cache+or+spring-webflux?tab=Newest).
-Find an existing discussion, or start a new one if necessary.
+[this list of tags](https://stackoverflow.com/questions/tagged/spring+or+spring-mvc+or+spring-aop+or+spring-jdbc+or+spring-transactions+or+spring-annotations+or+spring-jms+or+spring-el+or+spring-test+or+spring+or+spring-remoting+or+spring-orm+or+spring-jmx+or+spring-cache+or+spring-webflux?tab=Newest). Find an existing discussion, or start a new one if necessary.

 If you believe there is an issue, search through
 [existing issues](https://github.com/spring-projects/spring-framework/issues) trying a
@@ -39,14 +38,18 @@ decision.

 Reporting an issue or making a feature request is a great way to contribute. Your feedback
 and the conversations that result from it provide a continuous flow of ideas. However,
-before creating a ticket, please take the time to [discuss and research](#discuss) first.
+before creating a ticket, please take the time to [ask and research](#ask-questions) first.

-If creating an issue after a discussion on Stack Overflow, please provide a description
+If you create an issue after a discussion on Stack Overflow, please provide a description
 in the issue instead of simply referring to Stack Overflow. The issue tracker is an
 important place of record for design discussions and should be self-sufficient.

-Once you're ready, create an issue on
-[GitHub](https://github.com/spring-projects/spring-framework/issues).
+Once you're ready, create an issue on [GitHub](https://github.com/spring-projects/spring-framework/issues).
+
+Many issues are caused by subtle behavior, typos, and unintended configuration.
+Creating a [Minimal Reproducible Example](https://stackoverflow.com/help/minimal-reproducible-example)
+(starting with https://start.spring.io for example) of the problem helps the team
+quickly triage your issue and get to the core of the problem.

 #### Issue Lifecycle

@@ -63,7 +66,7 @@ follow-up reports will need to be created as new issues with a fresh description
 #### Submit a Pull Request

 1. If you have not previously done so, please sign the
-[Contributor License Agreement](https://cla.pivotal.io/sign/spring). You will be reminded
+[Contributor License Agreement](https://cla.spring.io/sign/spring). You will be reminded
 automatically when you submit the PR.

 1. Should you create an issue first? No, just create the pull request and use the
@@ -72,7 +75,7 @@ to start a discussion first or have already created an issue, once a pull reques
 created, we will close the issue as superseded by the pull request, and the discussion
 about the issue will continue under the pull request.

-1. Always check out the `master` branch and submit pull requests against it
+1. Always check out the `main` branch and submit pull requests against it
 (for target version see [settings.gradle](settings.gradle)).
 Backports to prior versions will be considered on a case-by-case basis and reflected as
 the fix version in the issue tracker.
@@ -120,12 +123,13 @@ define the source file coding standards we use along with some IDEA editor setti

 ### Reference Docs

-The reference documentation is in the [src/docs/asciidoc](src/docs/asciidoc) directory, in
+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 asciidoctor` and then browse the result under
-`build/docs/ref-docs/html5/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/).
+
@@ -1,4 +1,4 @@
-# <img src="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-5.3.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.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://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-5.3.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.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)

 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". 

@@ -14,16 +14,16 @@ 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/docs/current/spring-framework-reference/) and [source](src/docs/asciidoc)), 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

-See the [Micro-Benchmarks](https://github.com/spring-projects/spring-framework/wiki/Micro-Benchmarks) Wiki page.
+See the [Micro-Benchmarks](https://github.com/spring-projects/spring-framework/wiki/Micro-Benchmarks) wiki page.

 ## Build from Source

-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source) Wiki page and the [CONTRIBUTING.md](CONTRIBUTING.md) file.
+See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source) wiki page and the [CONTRIBUTING.md](CONTRIBUTING.md) file.

 ## Continuous Integration Builds

@@ -8,4 +8,4 @@ wiki page.

 ## Reporting a Vulnerability

-Please see https://pivotal.io/security.
+Please see https://spring.io/security-policy.
@@ -1,295 +1,39 @@
 plugins {
-	id 'io.spring.dependency-management' version '1.0.9.RELEASE' apply false
-	id 'io.spring.nohttp' version '0.0.5.RELEASE'
-	id 'org.jetbrains.kotlin.jvm' version '1.5.10' apply false
-	id 'org.jetbrains.dokka' version '0.10.1' apply false
-	id 'org.asciidoctor.jvm.convert' version '3.1.0'
-	id 'org.asciidoctor.jvm.pdf' version '3.1.0'
-	id 'de.undercouch.download' version '4.1.1'
-	id "io.freefair.aspectj" version '5.1.1' apply false
-	id "com.github.ben-manes.versions" version '0.28.0'
-	id "com.github.johnrengelman.shadow" version "6.1.0" apply false
-	id "me.champeau.jmh" version "0.6.4" apply false
-	id "org.jetbrains.kotlin.plugin.serialization" version "1.5.10" apply false
-	id "org.unbroken-dome.xjc" version '2.0.0' apply false
+	id 'io.spring.nohttp' version '0.0.10'
+	id 'io.freefair.aspectj' version '6.5.0.3' apply false
+	// kotlinVersion is managed in gradle.properties
+	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
+	id 'org.jetbrains.dokka' version '1.7.20'
+	id 'org.asciidoctor.jvm.convert' version '3.3.2' apply false
+	id 'org.asciidoctor.jvm.pdf' version '3.3.2'  apply false
+	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
+	id 'com.github.ben-manes.versions' version '0.42.0'
+	id 'com.github.johnrengelman.shadow' version '7.1.2' apply false
+	id 'de.undercouch.download' version '5.1.0'
+	id 'me.champeau.jmh' version '0.6.6' apply false
 }

 ext {
 	moduleProjects = subprojects.findAll { it.name.startsWith("spring-") }
-	javaProjects = subprojects - project(":framework-bom")
-	withoutJclOverSlf4j = {
-		exclude group: "org.slf4j", name: "jcl-over-slf4j"
-	}
+	javaProjects = subprojects - project(":framework-bom") - project(":framework-platform")
 }

 configure(allprojects) { project ->
-	apply plugin: "io.spring.dependency-management"
-
-	dependencyManagement {
-		imports {
-			mavenBom "com.fasterxml.jackson:jackson-bom:2.12.3"
-			mavenBom "io.netty:netty-bom:4.1.65.Final"
-			mavenBom "io.projectreactor:reactor-bom:2020.0.7"
-			mavenBom "io.r2dbc:r2dbc-bom:Arabba-SR10"
-			mavenBom "io.rsocket:rsocket-bom:1.1.0"
-			mavenBom "org.eclipse.jetty:jetty-bom:9.4.41.v20210516"
-			mavenBom "org.jetbrains.kotlin:kotlin-bom:1.5.10"
-			mavenBom "org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.5.0"
-			mavenBom "org.jetbrains.kotlinx:kotlinx-serialization-bom:1.2.1"
-			mavenBom "org.junit:junit-bom:5.7.2"
+	repositories {
+		mavenCentral()
+		maven {
+			url "https://repo.spring.io/milestone"
+			content {
+				// Netty 5 optional support
+				includeGroup 'io.projectreactor.netty'
+			}
 		}
-		dependencies {
-			dependencySet(group: 'org.apache.logging.log4j', version: '2.14.1') {
-				entry 'log4j-api'
-				entry 'log4j-core'
-				entry 'log4j-jul'
-				entry 'log4j-slf4j-impl'
-			}
-			dependency "org.slf4j:slf4j-api:1.7.30"
-			dependency("com.google.code.findbugs:findbugs:3.0.1") {
-				exclude group: "dom4j", name: "dom4j"
-			}
-			dependency "com.google.code.findbugs:jsr305:3.0.2"
-
-			dependencySet(group: 'org.aspectj', version: '1.9.6') {
-				entry 'aspectjrt'
-				entry 'aspectjtools'
-				entry 'aspectjweaver'
-			}
-			dependencySet(group: 'org.codehaus.groovy', version: '3.0.8') {
-				entry 'groovy'
-				entry 'groovy-jsr223'
-				entry 'groovy-templates'  // requires findbugs for warning-free compilation
-				entry 'groovy-test'
-				entry 'groovy-xml'
-			}
-
-			dependency "io.reactivex:rxjava:1.3.8"
-			dependency "io.reactivex:rxjava-reactive-streams:1.2.1"
-			dependency "io.reactivex.rxjava2:rxjava:2.2.21"
-			dependency "io.reactivex.rxjava3:rxjava:3.0.13"
-			dependency "io.projectreactor.tools:blockhound:1.0.4.RELEASE"
-
-			dependency "com.caucho:hessian:4.0.63"
-			dependency "com.fasterxml:aalto-xml:1.3.0"
-			dependency("com.fasterxml.woodstox:woodstox-core:6.2.6") {
-				exclude group: "stax", name: "stax-api"
-			}
-			dependency "com.google.code.gson:gson:2.8.7"
-			dependency "com.google.protobuf:protobuf-java-util:3.17.2"
-			dependency "com.googlecode.protobuf-java-format:protobuf-java-format:1.4"
-			dependency("com.thoughtworks.xstream:xstream:1.4.17") {
-				exclude group: "xpp3", name: "xpp3_min"
-				exclude group: "xmlpull", name: "xmlpull"
-			}
-			dependency "org.apache.johnzon:johnzon-jsonb:1.2.10"
-			dependency("org.codehaus.jettison:jettison:1.3.8") {
-				exclude group: "stax", name: "stax-api"
-			}
-			dependencySet(group: 'org.jibx', version: '1.3.3') {
-				entry 'jibx-bind'
-				entry 'jibx-run'
-			}
-			dependency "org.ogce:xpp3:1.1.6"
-			dependency "org.yaml:snakeyaml:1.28"
-
-			dependency "com.h2database:h2:1.4.200"
-			dependency "com.github.ben-manes.caffeine:caffeine:2.9.1"
-			dependency "com.github.librepdf:openpdf:1.3.26"
-			dependency "com.rometools:rome:1.15.0"
-			dependency "commons-io:commons-io:2.5"
-			dependency "io.vavr:vavr:0.10.3"
-			dependency "net.sf.jopt-simple:jopt-simple:5.0.4"
-			dependencySet(group: 'org.apache.activemq', version: '5.16.2') {
-				entry 'activemq-broker'
-				entry('activemq-kahadb-store') {
-					exclude group: "org.springframework", name: "spring-context"
-				}
-				entry 'activemq-stomp'
-			}
-			dependency "org.apache.bcel:bcel:6.0"
-			dependency "org.apache.commons:commons-pool2:2.9.0"
-			dependencySet(group: 'org.apache.derby', version: '10.14.2.0') {
-				entry 'derby'
-				entry 'derbyclient'
-			}
-			dependency "org.apache.poi:poi-ooxml:4.1.2"
-			dependency "org.apache-extras.beanshell:bsh:2.0b6"
-			dependency "org.freemarker:freemarker:2.3.31"
-			dependency "org.hsqldb:hsqldb:2.5.2"
-			dependency "org.quartz-scheduler:quartz:2.3.2"
-			dependency "org.codehaus.fabric3.api:commonj:1.1.0"
-			dependency "net.sf.ehcache:ehcache:2.10.6"
-			dependency "org.ehcache:jcache:1.0.1"
-			dependency "org.ehcache:ehcache:3.4.0"
-			dependency "org.hibernate:hibernate-core:5.4.32.Final"
-			dependency "org.hibernate:hibernate-validator:6.2.0.Final"
-			dependency "org.webjars:webjars-locator-core:0.46"
-			dependency "org.webjars:underscorejs:1.8.3"
-
-			dependencySet(group: 'org.apache.tomcat', version: '9.0.45') {
-				entry 'tomcat-util'
-				entry('tomcat-websocket') {
-					exclude group: "org.apache.tomcat", name: "tomcat-websocket-api"
-					exclude group: "org.apache.tomcat", name: "tomcat-servlet-api"
-				}
-			}
-			dependencySet(group: 'org.apache.tomcat.embed', version: '9.0.45') {
-				entry 'tomcat-embed-core'
-				entry 'tomcat-embed-websocket'
-			}
-			dependencySet(group: 'io.undertow', version: '2.2.8.Final') {
-				entry 'undertow-core'
-				entry('undertow-websockets-jsr') {
-					exclude group: "org.jboss.spec.javax.websocket", name: "jboss-websocket-api_1.1_spec"
-				}
-				entry('undertow-servlet') {
-					exclude group: "org.jboss.spec.javax.servlet", name: "jboss-servlet-api_3.1_spec"
-					exclude group: "org.jboss.spec.javax.annotation", name: "jboss-annotations-api_1.2_spec"
-				}
-			}
-
-			dependencySet(group: 'com.squareup.okhttp3', version: '3.14.9') {
-				entry 'okhttp'
-				entry 'mockwebserver'
-			}
-			dependency("org.apache.httpcomponents:httpclient:4.5.13") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.apache.httpcomponents:httpasyncclient:4.1.4") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency 'org.apache.httpcomponents.client5:httpclient5:5.1'
-			dependency 'org.apache.httpcomponents.core5:httpcore5-reactive:5.1.1'
-			dependency "org.eclipse.jetty:jetty-reactive-httpclient:1.1.8"
-
-			dependency "org.jruby:jruby:9.2.17.0"
-			dependency "org.python:jython-standalone:2.7.1"
-			dependency "org.mozilla:rhino:1.7.11"
-
-			dependency "commons-fileupload:commons-fileupload:1.4"
-			dependency "org.synchronoss.cloud:nio-multipart-parser:1.1.0"
-
-			dependency("org.dom4j:dom4j:2.1.3") {
-				exclude group: "jaxen", name: "jaxen"
-				exclude group: "net.java.dev.msv", name: "xsdlib"
-				exclude group: "pull-parser", name: "pull-parser"
-				exclude group: "xpp3", name: "xpp3"
-			}
-			dependency("jaxen:jaxen:1.2.0") {
-				exclude group: "dom4j", name: "dom4j"
-			}
-
-			dependency("junit:junit:4.13.2") {
-				exclude group: "org.hamcrest", name: "hamcrest-core"
-			}
-			dependency("de.bechte.junit:junit-hierarchicalcontextrunner:4.12.1") {
-				exclude group: "junit", name: "junit"
-			}
-			dependency "org.testng:testng:7.4.0"
-			dependency "org.hamcrest:hamcrest:2.1"
-			dependency "org.awaitility:awaitility:3.1.6"
-			dependency "org.assertj:assertj-core:3.19.0"
-			dependencySet(group: 'org.xmlunit', version: '2.8.2') {
-				entry 'xmlunit-assertj'
-				entry('xmlunit-matchers') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-			}
-			dependencySet(group: 'org.mockito', version: '3.11.0') {
-				entry('mockito-core') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-				entry 'mockito-junit-jupiter'
-			}
-			dependency "io.mockk:mockk:1.10.2"
-
-			dependency("net.sourceforge.htmlunit:htmlunit:2.50.0") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.seleniumhq.selenium:htmlunit-driver:2.50.0") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.seleniumhq.selenium:selenium-java:3.141.59") {
-				exclude group: "commons-logging", name: "commons-logging"
-				exclude group: "io.netty", name: "netty"
-			}
-			dependency "org.skyscreamer:jsonassert:1.5.0"
-			dependency "com.jayway.jsonpath:json-path:2.5.0"
-			dependency "org.bouncycastle:bcpkix-jdk15on:1.66"
-
-			dependencySet(group: 'org.apache.tiles', version: '3.0.8') {
-				entry 'tiles-api'
-				entry('tiles-core', withoutJclOverSlf4j)
-				entry('tiles-servlet', withoutJclOverSlf4j)
-				entry('tiles-jsp', withoutJclOverSlf4j)
-				entry('tiles-el', withoutJclOverSlf4j)
-				entry('tiles-extras') {
-					exclude group: "org.springframework", name: "spring-web"
-					exclude group: "org.slf4j", name: "jcl-over-slf4j"
-				}
-			}
-			dependency("org.apache.taglibs:taglibs-standard-jstlel:1.2.5") {
-				exclude group: "org.apache.taglibs", name: "taglibs-standard-spec"
-			}
-
-			dependency "com.ibm.websphere:uow:6.0.2.17"
-			dependency "com.jamonapi:jamon:2.82"
-			dependency "joda-time:joda-time:2.10.10"
-			dependency "org.eclipse.persistence:org.eclipse.persistence.jpa:2.7.8"
-			dependency "org.javamoney:moneta:1.3"
-
-			dependency "com.sun.activation:javax.activation:1.2.0"
-			dependency "com.sun.mail:javax.mail:1.6.2"
-			dependencySet(group: 'com.sun.xml.bind', version: '2.3.0.1') {
-				entry 'jaxb-core'
-				entry 'jaxb-impl'
-				entry 'jaxb-xjc'
-			}
-
-			dependency "javax.activation:javax.activation-api:1.2.0"
-			dependency "javax.annotation:javax.annotation-api:1.3.2"
-			dependency "javax.cache:cache-api:1.1.0"
-			dependency "javax.ejb:javax.ejb-api:3.2"
-			dependency "javax.el:javax.el-api:3.0.1-b04"
-			dependency "javax.enterprise.concurrent:javax.enterprise.concurrent-api:1.0"
-			dependency "javax.faces:javax.faces-api:2.2"
-			dependency "javax.inject:javax.inject:1"
-			dependency "javax.inject:javax.inject-tck:1"
-			dependency "javax.interceptor:javax.interceptor-api:1.2.2"
-			dependency "javax.jms:javax.jms-api:2.0.1"
-			dependency "javax.json:javax.json-api:1.1.4"
-			dependency "javax.json.bind:javax.json.bind-api:1.0"
-			dependency "javax.mail:javax.mail-api:1.6.2"
-			dependency "javax.money:money-api:1.0.3"
-			dependency "javax.resource:javax.resource-api:1.7.1"
-			dependency "javax.servlet:javax.servlet-api:4.0.1"
-			dependency "javax.servlet.jsp:javax.servlet.jsp-api:2.3.2-b02"
-			dependency "javax.servlet.jsp.jstl:javax.servlet.jsp.jstl-api:1.2.1"
-			dependency "javax.transaction:javax.transaction-api:1.3"
-			dependency "javax.validation:validation-api:2.0.1.Final"
-			dependency "javax.websocket:javax.websocket-api:1.1"
-			dependency "javax.xml.bind:jaxb-api:2.3.1"
-			dependency "javax.xml.ws:jaxws-api:2.3.1"
-
-			dependency "org.eclipse.persistence:javax.persistence:2.2.0"
-
-			// Substitute for "javax.management:jmxremote_optional:1.0.1_04" which
-			// is not available on Maven Central
-			dependency "org.glassfish.external:opendmk_jmxremote_optional_jar:1.0-b01-ea"
-			dependency "org.glassfish:javax.el:3.0.1-b08"
-			dependency "org.glassfish.main:javax.jws:4.0-b33"
-			dependency "org.glassfish.tyrus:tyrus-container-servlet:1.13.1"
+		maven { url "https://repo.spring.io/libs-spring-framework-build" }
+		if (version.contains('-')) {
+			maven { url "https://repo.spring.io/milestone" }
 		}
-		generatedPomCustomization {
-			enabled = false
-		}
-		resolutionStrategy {
-			cacheChangingModulesFor 0, "seconds"
-		}
-		repositories {
-			mavenCentral()
-			maven { url "https://repo.spring.io/libs-spring-framework-build" }
+		if (version.endsWith('-SNAPSHOT')) {
+			maven { url "https://repo.spring.io/snapshot" }
 		}
 	}
 	configurations.all {
@@ -306,25 +50,17 @@ configure([rootProject] + javaProjects) { project ->
 	apply plugin: "java"
 	apply plugin: "java-test-fixtures"
 	apply plugin: "checkstyle"
-	apply plugin: 'org.springframework.build.compile'
+	apply plugin: 'org.springframework.build.conventions'
 	apply from: "${rootDir}/gradle/toolchains.gradle"
 	apply from: "${rootDir}/gradle/ide.gradle"

-	pluginManager.withPlugin("kotlin") {
-		apply plugin: "org.jetbrains.dokka"
-		compileKotlin {
-			kotlinOptions {
-				languageVersion = "1.3"
-				apiVersion = "1.3"
-				freeCompilerArgs = ["-Xjsr305=strict", "-Xsuppress-version-warnings", "-Xopt-in=kotlin.RequiresOptIn"]
-				allWarningsAsErrors = true
-			}
-		}
-		compileTestKotlin {
-			kotlinOptions {
-				freeCompilerArgs = ["-Xjsr305=strict"]
-			}
+	configurations {
+		dependencyManagement {
+			canBeConsumed = false
+			canBeResolved = false
+			visible = false
 		}
+		matching { it.name.endsWith("Classpath") }.all { it.extendsFrom(dependencyManagement) }
 	}

 	test {
@@ -333,52 +69,79 @@ configure([rootProject] + javaProjects) { project ->
 		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 = "8.43"
+		toolVersion = "10.4"
 		configDirectory.set(rootProject.file("src/checkstyle"))
 	}

+	tasks.named("checkstyleMain").configure {
+		maxHeapSize = "1g"
+	}
+
+	tasks.named("checkstyleTest").configure {
+		maxHeapSize = "1g"
+	}
+
 	dependencies {
-		testCompile("org.junit.jupiter:junit-jupiter-api")
-		testCompile("org.junit.jupiter:junit-jupiter-params")
-		testCompile("org.mockito:mockito-core")
-		testCompile("org.mockito:mockito-junit-jupiter")
-		testCompile("io.mockk:mockk")
-		testCompile("org.assertj:assertj-core")
+		dependencyManagement(enforcedPlatform(dependencies.project(path: ":framework-platform")))
+		testImplementation("org.junit.jupiter:junit-jupiter-api")
+		testImplementation("org.junit.jupiter:junit-jupiter-params")
+		testImplementation("org.junit.platform:junit-platform-suite-api")
+		testImplementation("org.mockito:mockito-core")
+		testImplementation("org.mockito:mockito-junit-jupiter")
+		testImplementation("io.mockk:mockk")
+		testImplementation("org.assertj:assertj-core")
 		// Pull in the latest JUnit 5 Launcher API to ensure proper support in IDEs.
-		testRuntime("org.junit.platform:junit-platform-launcher")
-		testRuntime("org.junit.jupiter:junit-jupiter-engine")
-		testRuntime("org.apache.logging.log4j:log4j-core")
-		testRuntime("org.apache.logging.log4j:log4j-slf4j-impl")
-		testRuntime("org.apache.logging.log4j:log4j-jul")
+		testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+		testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+		testRuntimeOnly("org.junit.platform:junit-platform-suite-engine")
+		testRuntimeOnly("org.apache.logging.log4j:log4j-core")
+		testRuntimeOnly("org.apache.logging.log4j:log4j-jul")
+		testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j-impl")
 		// 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.15")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.31")
 	}

 	ext.javadocLinks = [
-			"https://docs.oracle.com/javase/8/docs/api/",
-			"https://docs.oracle.com/javaee/7/api/",
+			"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
-			"https://www.ibm.com/support/knowledgecenter/SS7JFU_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/",
-			"https://glassfish.java.net/nonav/docs/v3/api/",
+			"https://www.ibm.com/docs/api/v1/content/SSEQTP_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/",
 			"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/",
 			"https://docs.jboss.org/jbossas/javadoc/7.1.2.Final/",
-			"https://tiles.apache.org/tiles-request/apidocs/",
-			"https://tiles.apache.org/framework/apidocs/",
 			"https://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
-			"https://www.ehcache.org/apidocs/2.10.4/",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
 			"https://fasterxml.github.io/jackson-core/javadoc/2.10/",
 			"https://fasterxml.github.io/jackson-databind/javadoc/2.10/",
 			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.10/",
-			"https://hc.apache.org/httpcomponents-client-5.1.x/current/httpclient5/apidocs/",
+			"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/",
-			"https://junit.org/junit5/docs/5.7.2/api/"
+			// TODO Uncomment link to JUnit 5 docs once we have sorted out
+			// the following warning in the build.
+			//
+			// warning: The code being documented uses packages in the unnamed module, but the packages defined in https://junit.org/junit5/docs/5.9.1/api/ are in named modules.
+			//
+			// "https://junit.org/junit5/docs/5.9.1/api/",
+			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
+			"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
+			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
+			// The external Javadoc link for JSR 305 must come last to ensure that types from
+			// JSR 250 (such as @PostConstruct) are still supported. This is due to the fact
+			// that JSR 250 and JSR 305 both define types in javax.annotation, which results
+			// in a split package, and the javadoc tool does not support split packages
+			// across multiple external Javadoc sites.
+			"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
 	] as String[]
 }

@@ -389,12 +152,8 @@ configure(moduleProjects) { project ->
 configure(rootProject) {
 	description = "Spring Framework"

-	apply plugin: "groovy"
-	apply plugin: "kotlin"
 	apply plugin: "io.spring.nohttp"
 	apply plugin: 'org.springframework.build.api-diff'
-	apply from: "${rootDir}/gradle/publications.gradle"
-	apply from: "${rootDir}/gradle/docs.gradle"

 	nohttp {
 		source.exclude "**/test-output/**"
@@ -411,13 +170,8 @@ configure(rootProject) {
 		}
 	}

-	publishing {
-		publications {
-			mavenJava(MavenPublication) {
-				artifact docsZip
-				artifact schemaZip
-				artifact distZip
-			}
-		}
+	tasks.named("checkstyleNohttp").configure {
+		maxHeapSize = "1g"
 	}
+
 }
@@ -5,9 +5,12 @@ They are declared in the `build.gradle` file in this folder.

 ## Build Conventions

-### Compiler conventions
+The `org.springframework.build.conventions` plugin applies all conventions to the Framework build:
+
+* Configuring the Java compiler, see `JavaConventions`
+* Configuring the Kotlin compiler, see `KotlinConventions`
+* Configuring testing in the build with `TestConventions` 

-The `org.springframework.build.compile` plugin applies the Java compiler conventions to the build.

 ## Build Plugins

@@ -33,3 +36,40 @@ current working version with. You can generate the reports for all modules or a
 ```      

 The reports are located under `build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/`.
+                                                                                       
+
+### RuntimeHints Java Agent
+
+The `spring-core-test` project module contributes the `RuntimeHintsAgent` Java agent.
+
+The `RuntimeHintsAgentPlugin` Gradle plugin creates a dedicated `"runtimeHintsTest"` test task for each project.
+This task will detect and execute [tests tagged](https://junit.org/junit5/docs/current/user-guide/#running-tests-build-gradle)
+with the `"RuntimeHintsTests"` [JUnit tag](https://junit.org/junit5/docs/current/user-guide/#running-tests-tags).
+In the Spring Framework test suite, those are usually annotated with the `@EnabledIfRuntimeHintsAgent` annotation.
+
+By default, the agent will instrument all classes located in the `"org.springframework"` package, as they are loaded.
+The `RuntimeHintsAgentExtension` allows to customize this using a DSL:
+
+```groovy
+// this applies the `RuntimeHintsAgentPlugin` to the project
+plugins {
+	id 'org.springframework.build.runtimehints-agent'
+}
+
+// You can configure the agent to include and exclude packages from the instrumentation process.
+runtimeHintsAgent {
+	includedPackages = ["org.springframework", "io.spring"]
+	excludedPackages = ["org.example"]
+}
+
+dependencies {
+    // to use the test infrastructure, the project should also depend on the "spring-core-test" module
+	testImplementation(project(":spring-core-test"))
+}
+```
+
+With this configuration, `./gradlew runtimeHintsTest` will run all tests instrumented by this java agent.
+The global `./gradlew check` task depends on `runtimeHintsTest`.            
+
+NOTE: the "spring-core-test" module doesn't shade "spring-core" by design, so the agent should never instrument
+code that doesn't have "spring-core" on its classpath.
@@ -7,9 +7,20 @@ repositories {
 	gradlePluginPortal()
 }

+ext {
+	def propertiesFile = new File(new File("$projectDir").parentFile, "gradle.properties")
+	propertiesFile.withInputStream {
+		def properties = new Properties()
+		properties.load(it)
+		set("kotlinVersion", properties["kotlinVersion"])
+	}
+}
+
 dependencies {
-	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.2.8"
-	implementation "com.google.guava:guava:28.2-jre" // required by japicmp-gradle-plugin
+	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"
 }

 gradlePlugin {
@@ -18,13 +29,17 @@ gradlePlugin {
 			id = "org.springframework.build.api-diff"
 			implementationClass = "org.springframework.build.api.ApiDiffPlugin"
 		}
-		compileConventionsPlugin {
-			id = "org.springframework.build.compile"
-			implementationClass = "org.springframework.build.compile.CompilerConventionsPlugin"
+		conventionsPlugin {
+			id = "org.springframework.build.conventions"
+			implementationClass = "org.springframework.build.ConventionsPlugin"
 		}
 		optionalDependenciesPlugin {
 			id = "org.springframework.build.optional-dependencies"
 			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"
 		}
+		runtimeHintsAgentPlugin {
+			id = "org.springframework.build.runtimehints-agent"
+			implementationClass = "org.springframework.build.hint.RuntimeHintsAgentPlugin"
+		}
 	}
 }
@@ -0,0 +1,45 @@
+/*
+ * 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.
+ * 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 org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaBasePlugin;
+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.
+ *
+ * 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.
+ *
+ * @author Brian Clozel
+ */
+public class ConventionsPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		new JavaConventions().apply(project);
+		new KotlinConventions().apply(project);
+		new TestConventions().apply(project);
+	}
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2021 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.
@@ -14,7 +14,7 @@
 * limitations under the License.
 */

-package org.springframework.build.compile;
+package org.springframework.build;

 import java.util.ArrayList;
 import java.util.Arrays;
@@ -22,9 +22,8 @@ import java.util.List;

 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaLibraryPlugin;
+import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginConvention;
 import org.gradle.api.tasks.compile.JavaCompile;

 /**
@@ -32,8 +31,9 @@ import org.gradle.api.tasks.compile.JavaCompile;
 *
 * @author Brian Clozel
 * @author Sam Brannen
+ * @author Sebastien Deleuze
 */
-public class CompilerConventionsPlugin implements Plugin<Project> {
+public class JavaConventions {

 	private static final List<String> COMPILER_ARGS;

@@ -43,7 +43,8 @@ public class CompilerConventionsPlugin implements Plugin<Project> {
 		List<String> commonCompilerArgs = Arrays.asList(
 				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
 				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
-				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options"
+				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options",
+				"-parameters"
 		);
 		COMPILER_ARGS = new ArrayList<>();
 		COMPILER_ARGS.addAll(commonCompilerArgs);
@@ -54,12 +55,11 @@ public class CompilerConventionsPlugin implements Plugin<Project> {
 		TEST_COMPILER_ARGS = new ArrayList<>();
 		TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
 		TEST_COMPILER_ARGS.addAll(Arrays.asList("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
-				"-Xlint:-deprecation", "-Xlint:-unchecked", "-parameters"));
+				"-Xlint:-deprecation", "-Xlint:-unchecked"));
 	}

-	@Override
 	public void apply(Project project) {
-		project.getPlugins().withType(JavaLibraryPlugin.class, javaPlugin -> applyJavaCompileConventions(project));
+		project.getPlugins().withType(JavaBasePlugin.class, javaPlugin -> applyJavaCompileConventions(project));
 	}

 	/**
@@ -68,7 +68,6 @@ public class CompilerConventionsPlugin implements Plugin<Project> {
 	 * @param project the current project
 	 */
 	private void applyJavaCompileConventions(Project project) {
-		JavaPluginConvention java = project.getConvention().getPlugin(JavaPluginConvention.class);
 		project.getTasks().withType(JavaCompile.class)
 				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
 				.forEach(compileTask -> {
@@ -0,0 +1,47 @@
+/*
+ * 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.
+ * 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.util.ArrayList;
+import java.util.List;
+
+import org.gradle.api.Project;
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions;
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile;
+
+/**
+ * @author Brian Clozel
+ */
+public class KotlinConventions {
+
+	void apply(Project project) {
+		project.getPlugins().withId("org.jetbrains.kotlin.jvm",
+				(plugin) -> project.getTasks().withType(KotlinCompile.class, this::configure));
+	}
+
+	private void configure(KotlinCompile compile) {
+		KotlinJvmOptions kotlinOptions = compile.getKotlinOptions();
+		kotlinOptions.setApiVersion("1.7");
+		kotlinOptions.setLanguageVersion("1.7");
+		kotlinOptions.setJvmTarget("17");
+		kotlinOptions.setAllWarningsAsErrors(true);
+		List<String> freeCompilerArgs = new ArrayList<>(compile.getKotlinOptions().getFreeCompilerArgs());
+		freeCompilerArgs.addAll(List.of("-Xsuppress-version-warnings", "-Xjsr305=strict", "-opt-in=kotlin.RequiresOptIn"));
+		compile.getKotlinOptions().setFreeCompilerArgs(freeCompilerArgs);
+	}
+
+}
@@ -0,0 +1,56 @@
+/*
+ * 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.
+ * 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 org.gradle.api.Project;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.tasks.testing.Test;
+import org.gradle.testretry.TestRetryPlugin;
+import org.gradle.testretry.TestRetryTaskExtension;
+
+/**
+ * Conventions that are applied in the presence of the {@link JavaBasePlugin}. When the
+ * plugin is applied:
+ * <ul>
+ * <li>The {@link TestRetryPlugin Test Retry} plugins is applied so that flaky tests
+ * are retried 3 times when running on the CI.
+ * </ul>
+ *
+ * @author Brian Clozel
+ * @author Andy Wilkinson
+ */
+class TestConventions {
+
+	void apply(Project project) {
+		project.getPlugins().withType(JavaBasePlugin.class, (java) -> configureTestConventions(project));
+	}
+
+	private void configureTestConventions(Project project) {
+		project.getPlugins().apply(TestRetryPlugin.class);
+		project.getTasks().withType(Test.class,
+				(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() {
+		return Boolean.parseBoolean(System.getenv("CI"));
+	}
+
+}
@@ -16,6 +16,7 @@
 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;
@@ -23,6 +24,7 @@ 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;
@@ -32,10 +34,12 @@ 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, diffing the public API one by one
+ * 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.
@@ -46,12 +50,16 @@ import org.gradle.jvm.tasks.Jar;
 */
 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())) {
@@ -63,16 +71,24 @@ public class ApiDiffPlugin implements Plugin<Project> {

 	private void applyApiDiffConventions(Project project) {
 		String baselineVersion = project.property(BASELINE_VERSION_PROPERTY).toString();
-		project.subprojects(subProject -> createApiDiffTask(baselineVersion, subProject));
+		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(project.files(createBaselineConfiguration(baselineVersion, project)));
+			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));
@@ -98,7 +114,16 @@ public class ApiDiffPlugin implements Plugin<Project> {
 		String baseline = String.join(":",
 				project.getGroup().toString(), project.getName(), baselineVersion);
 		Dependency baselineDependency = project.getDependencies().create(baseline + "@jar");
-		return project.getRootProject().getConfigurations().detachedConfiguration(baselineDependency);
+		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) {
@@ -0,0 +1,53 @@
+/*
+ * 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.
+ * 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.model.ObjectFactory;
+import org.gradle.api.provider.SetProperty;
+
+/**
+ * Entry point to the DSL extension for the {@link RuntimeHintsAgentPlugin} Gradle plugin.
+ * @author Brian Clozel
+ */
+public class RuntimeHintsAgentExtension {
+
+	private final SetProperty<String> includedPackages;
+
+	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();
+	}
+}
@@ -0,0 +1,56 @@
+/*
+ * 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.
+ * 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 org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.tasks.bundling.Jar;
+import org.gradle.api.tasks.testing.Test;
+
+/**
+ * {@link Plugin} that configures the {@code RuntimeHints} Java agent to test tasks.
+ *
+ * @author Brian Clozel
+ */
+public class RuntimeHintsAgentPlugin implements Plugin<Project> {
+
+	public static final String RUNTIMEHINTS_TEST_TASK = "runtimeHintsTest";
+	private static final String EXTENSION_NAME = "runtimeHintsAgent";
+
+
+	@Override
+	public void apply(Project project) {
+
+		project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
+			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");
+			});
+			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));
+		});
+	}
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 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.
@@ -20,15 +20,13 @@ import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.SourceSetContainer;
-import org.gradle.plugins.ide.eclipse.EclipsePlugin;
-import org.gradle.plugins.ide.eclipse.model.EclipseModel;

 /**
 * A {@code Plugin} that adds support for Maven-style optional dependencies. Creates a new
 * {@code optional} configuration. The {@code optional} configuration is part of the
- * project's compile and runtime classpath's but does not affect the classpath of
+ * project's compile and runtime classpaths but does not affect the classpath of
 * dependent projects.
 *
 * @author Andy Wilkinson
@@ -43,22 +41,16 @@ public class OptionalDependenciesPlugin implements Plugin<Project> {
 	@Override
 	public void apply(Project project) {
 		Configuration optional = project.getConfigurations().create("optional");
+		optional.setCanBeConsumed(false);
+		optional.setCanBeResolved(false);
 		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> {
-			SourceSetContainer sourceSets = project.getConvention()
-					.getPlugin(JavaPluginConvention.class).getSourceSets();
+			SourceSetContainer sourceSets = project.getExtensions().getByType(JavaPluginExtension.class)
+					.getSourceSets();
 			sourceSets.all((sourceSet) -> {
-				sourceSet.setCompileClasspath(
-						sourceSet.getCompileClasspath().plus(optional));
-				sourceSet.setRuntimeClasspath(
-						sourceSet.getRuntimeClasspath().plus(optional));
+				project.getConfigurations().getByName(sourceSet.getCompileClasspathConfigurationName()).extendsFrom(optional);
+				project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName()).extendsFrom(optional);
 			});
 		});
-		project.getPlugins().withType(EclipsePlugin.class, (eclipePlugin) -> {
-			project.getExtensions().getByType(EclipseModel.class)
-					.classpath((classpath) -> {
-						classpath.getPlusConfigurations().add(optional);
-					});
-		});
 	}

 }
@@ -0,0 +1,175 @@
+package org.springframework.build.shadow;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.component.ModuleComponentSelector;
+import org.gradle.api.artifacts.query.ArtifactResolutionQuery;
+import org.gradle.api.artifacts.result.ArtifactResolutionResult;
+import org.gradle.api.artifacts.result.ComponentArtifactsResult;
+import org.gradle.api.artifacts.result.DependencyResult;
+import org.gradle.api.artifacts.result.ResolutionResult;
+import org.gradle.api.artifacts.result.ResolvedArtifactResult;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.FileCopyDetails;
+import org.gradle.api.file.FileTree;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Nested;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.jvm.JvmLibrary;
+import org.gradle.language.base.artifact.SourcesArtifact;
+
+/**
+ * Gradle task to add source from shadowed jars into our own source jars.
+ *
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ */
+public class ShadowSource extends DefaultTask {
+
+	private final DirectoryProperty outputDirectory = getProject().getObjects().directoryProperty();
+
+	private List<Configuration> configurations = new ArrayList<>();
+
+	private final List<Relocation> relocations = new ArrayList<>();
+
+
+	@Classpath
+	@Optional
+	public List<Configuration> getConfigurations() {
+		return this.configurations;
+	}
+
+	public void setConfigurations(List<Configuration> configurations) {
+		this.configurations = configurations;
+	}
+
+	@Nested
+	public List<Relocation> getRelocations() {
+		return this.relocations;
+	}
+
+	public void relocate(String pattern, String destination) {
+		this.relocations.add(new Relocation(pattern, destination));
+	}
+
+	@OutputDirectory
+	DirectoryProperty getOutputDirectory() {
+		return this.outputDirectory;
+	}
+
+	@TaskAction
+	void syncSourceJarFiles() {
+		sync(getSourceJarFiles());
+	}
+
+	private List<File> getSourceJarFiles() {
+		List<File> sourceJarFiles = new ArrayList<>();
+		for (Configuration configuration : this.configurations) {
+			ResolutionResult resolutionResult = configuration.getIncoming().getResolutionResult();
+			resolutionResult.getRootComponent().get().getDependencies().forEach(dependency -> {
+				Set<ComponentArtifactsResult> artifactsResults = resolveSourceArtifacts(dependency);
+				for (ComponentArtifactsResult artifactResult : artifactsResults) {
+					artifactResult.getArtifacts(SourcesArtifact.class).forEach(sourceArtifact -> {
+						sourceJarFiles.add(((ResolvedArtifactResult) sourceArtifact).getFile());
+					});
+				}
+			});
+		}
+		return Collections.unmodifiableList(sourceJarFiles);
+	}
+
+	private Set<ComponentArtifactsResult> resolveSourceArtifacts(DependencyResult dependency) {
+		ModuleComponentSelector componentSelector = (ModuleComponentSelector) dependency.getRequested();
+		ArtifactResolutionQuery query = getProject().getDependencies().createArtifactResolutionQuery()
+				.forModule(componentSelector.getGroup(), componentSelector.getModule(), componentSelector.getVersion());
+		return executeQuery(query).getResolvedComponents();
+	}
+
+	@SuppressWarnings("unchecked")
+	private ArtifactResolutionResult executeQuery(ArtifactResolutionQuery query) {
+		return query.withArtifacts(JvmLibrary.class, SourcesArtifact.class).execute();
+	}
+
+	private void sync(List<File> sourceJarFiles) {
+		getProject().sync(spec -> {
+			spec.into(this.outputDirectory);
+			spec.eachFile(this::relocateFile);
+			spec.filter(this::transformContent);
+			spec.exclude("META-INF/**");
+			spec.setIncludeEmptyDirs(false);
+			sourceJarFiles.forEach(sourceJar -> spec.from(zipTree(sourceJar)));
+		});
+	}
+
+	private void relocateFile(FileCopyDetails details) {
+		String path = details.getPath();
+		for (Relocation relocation : this.relocations) {
+			path = relocation.relocatePath(path);
+		}
+		details.setPath(path);
+	}
+
+	private String transformContent(String content) {
+		for (Relocation relocation : this.relocations) {
+			content = relocation.transformContent(content);
+		}
+		return content;
+	}
+
+	private FileTree zipTree(File sourceJar) {
+		return getProject().zipTree(sourceJar);
+	}
+
+
+	/**
+	 * A single relocation.
+	 */
+	static class Relocation {
+
+		private final String pattern;
+
+		private final String pathPattern;
+
+		private final String destination;
+
+		private final String pathDestination;
+
+
+		Relocation(String pattern, String destination) {
+			this.pattern = pattern;
+			this.pathPattern = pattern.replace('.', '/');
+			this.destination = destination;
+			this.pathDestination = destination.replace('.', '/');
+		}
+
+
+		@Input
+		public String getPattern() {
+			return this.pattern;
+		}
+
+		@Input
+		public String getDestination() {
+			return this.destination;
+		}
+
+		String relocatePath(String path) {
+			return path.replace(this.pathPattern, this.pathDestination);
+		}
+
+		public String transformContent(String content) {
+			return content.replaceAll("\\b" + this.pattern, this.destination);
+		}
+
+	}
+
+}
@@ -2,7 +2,7 @@

 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-5.3.x[Spring Framework 5.3.x].
+for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].

 === Setting up your development environment

@@ -51,7 +51,7 @@ The pipeline can be deployed using the following command:

 [source]
 ----
-$ fly -t spring set-pipeline -p spring-framework-5.3.x -c ci/pipeline.yml -l ci/parameters.yml
+$ fly -t spring set-pipeline -p spring-framework-6.0.x -c ci/pipeline.yml -l ci/parameters.yml
 ----

 NOTE: This assumes that you have credhub integration configured with the appropriate secrets.
@@ -4,7 +4,7 @@ changelog:
    - title: ":star: New Features"
      labels:
        - "type: enhancement"
-    - title: ":beetle: Bug Fixes"
+    - title: ":lady_beetle: Bug Fixes"
      labels:
        - "type: bug"
        - "type: regression"
@@ -15,3 +15,6 @@ changelog:
      sort: "title"
      labels:
        - "type: dependency-upgrade"
+  contributors:
+    exclude:
+      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll"]
@@ -1,11 +1,12 @@
-FROM ubuntu:focal-20210119
+FROM ubuntu:focal-20220922

 ADD setup.sh /setup.sh
 ADD get-jdk-url.sh /get-jdk-url.sh
-RUN ./setup.sh java8
+RUN ./setup.sh

-ENV JAVA_HOME /opt/openjdk/java8
-ENV JDK11 /opt/openjdk/java11
-ENV JDK15 /opt/openjdk/java15
+ENV JAVA_HOME /opt/openjdk/java17
+ENV JDK17 /opt/openjdk/java17
+ENV JDK18 /opt/openjdk/java18
+ENV JDK19 /opt/openjdk/java19

 ENV PATH $JAVA_HOME/bin:$PATH
@@ -2,16 +2,16 @@
 set -e

 case "$1" in
-	java8)
-		 echo "https://github.com/AdoptOpenJDK/openjdk8-binaries/releases/download/jdk8u282-b08/OpenJDK8U-jdk_x64_linux_hotspot_8u282b08.tar.gz"
+	java17)
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.5+8/bellsoft-jdk17.0.5+8-linux-amd64.tar.gz"
 	;;
-	java11)
-		 echo "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.10%2B9/OpenJDK11U-jdk_x64_linux_hotspot_11.0.10_9.tar.gz"
+	java18)
+		echo "https://github.com/bell-sw/Liberica/releases/download/18.0.2.1%2B1/bellsoft-jdk18.0.2.1+1-linux-amd64.tar.gz"
 	;;
-  java15)
-		 echo "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.2%2B7/OpenJDK15U-jdk_x64_linux_hotspot_15.0.2_7.tar.gz"
-  ;;
-  *)
+	java19)
+		echo "https://github.com/bell-sw/Liberica/releases/download/19.0.1%2B11/bellsoft-jdk19.0.1+11-linux-amd64.tar.gz"
+	;;
+	*)
 		echo $"Unknown java version"
 		exit 1
 esac
@@ -14,15 +14,13 @@ rm -rf /var/lib/apt/lists/*

 curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/concourse-java.sh > /opt/concourse-java.sh

-curl --output /opt/concourse-release-scripts.jar https://repo.spring.io/release/io/spring/concourse/releasescripts/concourse-release-scripts/0.3.2/concourse-release-scripts-0.3.2.jar
-
 ###########################################################
 # JAVA
 ###########################################################

 mkdir -p /opt/openjdk
 pushd /opt/openjdk > /dev/null
-for jdk in java8 java11 java15
+for jdk in java17 java18 java19
 do
  JDK_URL=$( /get-jdk-url.sh $jdk )
  mkdir $jdk
@@ -1,13 +1,14 @@
-email-server: "smtp.svc.pivotal.io"
-email-from: "ci@spring.io"
-email-to: ["spring-framework-dev@pivotal.io"]
 github-repo: "https://github.com/spring-projects/spring-framework.git"
 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: "5.3.x"
+milestone: "6.0.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
+registry-mirror-host: docker.repo.spring.io
+registry-mirror-username: ((artifactory-username))
+registry-mirror-password: ((artifactory-password))
 task-timeout: 1h00m
@@ -2,7 +2,7 @@ anchors:
  git-repo-resource-source: &git-repo-resource-source
    uri: ((github-repo))
    username: ((github-username))
-    password: ((github-password))
+    password: ((github-ci-release-token))
    branch: ((branch))
  gradle-enterprise-task-params: &gradle-enterprise-task-params
    GRADLE_ENTERPRISE_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
@@ -12,7 +12,7 @@ anchors:
    SONATYPE_USERNAME: ((sonatype-username))
    SONATYPE_PASSWORD: ((sonatype-password))
    SONATYPE_URL: ((sonatype-url))
-    SONATYPE_STAGING_PROFILE_ID: ((sonatype-staging-profile-id))
+    SONATYPE_STAGING_PROFILE: ((sonatype-staging-profile))
  artifactory-task-params: &artifactory-task-params
    ARTIFACTORY_SERVER: ((artifactory-server))
    ARTIFACTORY_USERNAME: ((artifactory-username))
@@ -24,6 +24,10 @@ anchors:
    username: ((docker-hub-username))
    password: ((docker-hub-password))
    tag: ((milestone))
+  registry-mirror-vars: &registry-mirror-vars
+    registry-mirror-host: ((registry-mirror-host))
+    registry-mirror-username: ((registry-mirror-username))
+    registry-mirror-password: ((registry-mirror-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!>
@@ -41,11 +45,21 @@ anchors:
    GITHUB_TOKEN: ((github-ci-release-token))

 resource_types:
+- name: registry-image
+  type: registry-image
+  source:
+    repository: concourse/registry-image-resource
+    tag: 1.5.0
 - name: artifactory-resource
  type: registry-image
  source:
    repository: springio/artifactory-resource
-    tag: 0.0.13
+    tag: 0.0.17
+- name: github-release
+  type: registry-image
+  source:
+    repository: concourse/github-release-resource
+    tag: 1.5.5
 - name: github-status-resource
  type: registry-image
  source:
@@ -67,13 +81,6 @@ resources:
  icon: github
  source:
    <<: *git-repo-resource-source
- name: every-morning
-  type: time
-  icon: alarm
-  source:
-    start: 8:00 AM
-    stop: 9:00 AM
-    location: Europe/Vienna
 - name: ci-images-git-repo
  type: git
  icon: github
@@ -82,11 +89,18 @@ resources:
    branch: ((branch))
    paths: ["ci/images/*"]
 - name: ci-image
-  type: docker-image
+  type: registry-image
  icon: docker
  source:
    <<: *docker-resource-source
    repository: ((docker-hub-organization))/spring-framework-ci
+- 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
@@ -111,22 +125,22 @@ resources:
    access_token: ((github-ci-status-token))
    branch: ((branch))
    context: build
- name: repo-status-jdk11-build
+- name: repo-status-jdk18-build
  type: github-status-resource
  icon: eye-check-outline
  source:
    repository: ((github-repo-name))
    access_token: ((github-ci-status-token))
    branch: ((branch))
-    context: jdk11-build
- name: repo-status-jdk15-build
+    context: jdk18-build
+- name: repo-status-jdk19-build
  type: github-status-resource
  icon: eye-check-outline
  source:
    repository: ((github-repo-name))
    access_token: ((github-ci-status-token))
    branch: ((branch))
-    context: jdk15-build
+    context: jdk19-build
 - name: slack-alert
  type: slack-notification
  icon: slack
@@ -152,13 +166,20 @@ resources:
 jobs:
 - name: build-ci-images
  plan:
-  - get: ci-images-git-repo
-    trigger: true
-  - in_parallel:
+    - get: git-repo
+    - get: ci-images-git-repo
+      trigger: true
+    - task: build-ci-image
+      privileged: true
+      file: git-repo/ci/tasks/build-ci-image.yml
+      output_mapping:
+        image: ci-image
+      vars:
+        ci-image-name: ci-image
+        <<: *registry-mirror-vars
    - put: ci-image
      params:
-        build: ci-images-git-repo/ci/images
-        dockerfile: ci-images-git-repo/ci/images/ci-image/Dockerfile
+        image: ci-image/image.tar
 - name: build
  serial: true
  public: true
@@ -197,54 +218,26 @@ jobs:
      threads: 8
      artifact_set:
      - include:
-        - "/**/spring-*.zip"
+        - "/**/framework-docs-*.zip"
        properties:
          "zip.name": "spring-framework"
          "zip.displayname": "Spring Framework"
          "zip.deployed": "false"
      - include:
-        - "/**/spring-*-docs.zip"
+        - "/**/framework-docs-*-docs.zip"
        properties:
          "zip.type": "docs"
      - include:
-        - "/**/spring-*-dist.zip"
+        - "/**/framework-docs-*-dist.zip"
        properties:
          "zip.type": "dist"
      - include:
-        - "/**/spring-*-schema.zip"
+        - "/**/framework-docs-*-schema.zip"
        properties:
          "zip.type": "schema"
    get_params:
      threads: 8
- name: jdk11-build
-  serial: true
-  public: true
-  plan:
-  - get: ci-image
-  - get: git-repo
-  - get: every-morning
-    trigger: true
-  - put: repo-status-jdk11-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: 11
-        <<: *build-project-task-params
-    on_failure:
-      do:
-      - put: repo-status-jdk11-build
-        params: { state: "failure", commit: "git-repo" }
-      - put: slack-alert
-        params:
-          <<: *slack-fail-params
-  - put: repo-status-jdk11-build
-    params: { state: "success", commit: "git-repo" }
- name: jdk15-build
+- name: jdk18-build
  serial: true
  public: true
  plan:
@@ -252,25 +245,53 @@ jobs:
    - get: git-repo
    - get: every-morning
      trigger: true
-    - put: repo-status-jdk15-build
+    - put: repo-status-jdk18-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: 15
-          <<: *build-project-task-params
+        - task: check-project
+          image: ci-image
+          file: git-repo/ci/tasks/check-project.yml
+          privileged: true
+          timeout: ((task-timeout))
+          params:
+            TEST_TOOLCHAIN: 18
+            <<: *build-project-task-params
      on_failure:
        do:
-          - put: repo-status-jdk15-build
+          - put: repo-status-jdk18-build
            params: { state: "failure", commit: "git-repo" }
          - put: slack-alert
            params:
              <<: *slack-fail-params
-    - put: repo-status-jdk15-build
+    - put: repo-status-jdk18-build
+      params: { state: "success", commit: "git-repo" }
+- name: jdk19-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk19-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: 19
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk19-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk19-build
      params: { state: "success", commit: "git-repo" }
 - name: build-pull-requests
  serial: true
@@ -292,7 +313,7 @@ jobs:
        privileged: true
        timeout: ((task-timeout))
        params:
-          <<: *build-project-task-params
+          BRANCH: ((branch))
      on_success:
        put: git-pull-request
        params:
@@ -335,7 +356,6 @@ jobs:
        download_artifacts: false
        save_build_info: true
    - task: promote
-      image: ci-image
      file: git-repo/ci/tasks/promote-version.yml
      params:
        RELEASE_TYPE: M
@@ -380,7 +400,6 @@ jobs:
        download_artifacts: false
        save_build_info: true
    - task: promote
-      image: ci-image
      file: git-repo/ci/tasks/promote-version.yml
      params:
        RELEASE_TYPE: RC
@@ -425,7 +444,6 @@ jobs:
        download_artifacts: true
        save_build_info: true
    - task: promote
-      image: ci-image
      file: git-repo/ci/tasks/promote-version.yml
      params:
        RELEASE_TYPE: RELEASE
@@ -453,7 +471,7 @@ jobs:

 groups:
 - name: "builds"
-  jobs: ["build", "jdk11-build", "jdk15-build"]
+  jobs: ["build", "jdk18-build", "jdk19-build"]
 - name: "releases"
  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
 - name: "ci-images"
@@ -4,6 +4,6 @@ set -e
 source $(dirname $0)/common.sh

 pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK11,JDK15 \
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK18 \
  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check
 popd > /dev/null
@@ -1,16 +1,15 @@
 #!/bin/bash

-source $(dirname $0)/common.sh
 CONFIG_DIR=git-repo/ci/config

 version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
 export BUILD_INFO_LOCATION=$(pwd)/artifactory-repo/build-info.json

-java -jar /opt/concourse-release-scripts.jar \
+java -jar /concourse-release-scripts.jar \
  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
  publishToCentral $RELEASE_TYPE $BUILD_INFO_LOCATION artifactory-repo || { exit 1; }

-java -jar /opt/concourse-release-scripts.jar \
+java -jar /concourse-release-scripts.jar \
  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
  promote $RELEASE_TYPE $BUILD_INFO_LOCATION || { exit 1; }

@@ -29,8 +29,8 @@ fi
 echo "Staging $stageVersion (next version will be $nextVersion)"
 sed -i "s/version=$snapshotVersion/version=$stageVersion/" gradle.properties

-git config user.name "Spring Buildmaster" > /dev/null
-git config user.email "buildmaster@springframework.org" > /dev/null
+git config user.name "Spring Builds" > /dev/null
+git config user.email "spring-builds@users.noreply.github.com" > /dev/null
 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
@@ -1,8 +0,0 @@
-#!/bin/bash
-
-export BUILD_INFO_LOCATION=$(pwd)/artifactory-repo/build-info.json
-version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
-java -jar /opt/concourse-release-scripts.jar syncToCentral "RELEASE" $BUILD_INFO_LOCATION || { exit 1; }
-
-echo "Sync complete"
-echo $version > version/version
@@ -0,0 +1,32 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: concourse/oci-build-task
+    tag: 0.10.0
+    registry_mirror:
+      host: ((registry-mirror-host))
+      username: ((registry-mirror-username))
+      password: ((registry-mirror-password))
+inputs:
+  - name: ci-images-git-repo
+outputs:
+  - name: image
+caches:
+  - path: ci-image-cache
+params:
+  CONTEXT: ci-images-git-repo/ci/images
+  DOCKERFILE: ci-images-git-repo/ci/images/ci-image/Dockerfile
+  DOCKER_HUB_AUTH: ((docker-hub-auth))
+run:
+  path: /bin/sh
+  args:
+    - "-c"
+    - |
+      mkdir -p /root/.docker
+      cat > /root/.docker/config.json <<EOF
+      { "auths": { "https://index.docker.io/v1/": { "auth": "$DOCKER_HUB_AUTH" }}}
+      EOF
+      build
+
@@ -4,7 +4,7 @@ image_resource:
  type: registry-image
  source:
    repository: springio/github-changelog-generator
-    tag: '0.0.6'
+    tag: '0.0.8'
 inputs:
 - name: git-repo
 - name: artifactory-repo
@@ -1,5 +1,10 @@
 ---
 platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/concourse-release-scripts
+    tag: '0.3.4'
 inputs:
 - name: git-repo
 - name: artifactory-repo
@@ -13,6 +18,6 @@ params:
  SONATYPE_USER:
  SONATYPE_PASSWORD:
  SONATYPE_URL:
-  SONATYPE_STAGING_PROFILE_ID:
+  SONATYPE_STAGING_PROFILE:
 run:
  path: git-repo/ci/scripts/promote-version.sh
@@ -1,17 +1,30 @@
+description = "Spring Framework Docs"
+
+apply plugin: 'kotlin'
+apply plugin: 'org.asciidoctor.jvm.convert'
+apply plugin: 'org.asciidoctor.jvm.pdf'
+apply from: "${rootDir}/gradle/publications.gradle"
+
+
 configurations {
-	asciidoctorExt
+	asciidoctorExtensions
+}
+
+jar {
+	enabled = false
+}
+
+javadoc {
+	enabled = false
 }

 dependencies {
-	asciidoctorExt("io.spring.asciidoctor:spring-asciidoctor-extensions-block-switch:0.5.0")
+	asciidoctorExtensions "io.spring.asciidoctor.backends:spring-asciidoctor-backends:0.0.3"
 }

 repositories {
 	maven {
 		url "https://repo.spring.io/release"
-		mavenContent {
-			includeGroup "io.spring.asciidoctor"
-		}
 	}
 }

@@ -42,14 +55,11 @@ task api(type: Javadoc) {
 		author = true
 		header = rootProject.description
 		use = true
-		overview = "src/docs/api/overview.html"
-		stylesheetFile = file("src/docs/api/stylesheet.css")
+		overview = "framework-docs/src/docs/api/overview.html"
 		splitIndex = true
 		links(project.ext.javadocLinks)
-		addStringOption('Xdoclint:none', '-quiet')
-		if(JavaVersion.current().isJava9Compatible()) {
-			addBooleanOption('html5', true)
-		}
+		addBooleanOption('Xdoclint:syntax', true) // only check syntax with doclint
+		addBooleanOption('Werror', true) // fail build on Javadoc warnings
 	}
 	source moduleProjects.collect { project ->
 		project.sourceSets.main.allJava
@@ -61,110 +71,54 @@ task api(type: Javadoc) {
 /**
 * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
 */
-dokka {
+rootProject.tasks.dokkaHtmlMultiModule.configure {
 	dependsOn {
 		tasks.getByName("api")
 	}
-
-	doFirst {
-		configuration {
-			classpath = moduleProjects.collect { project -> project.jar.outputs.files.getFiles() }.flatten()
-			classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-
-			moduleProjects.findAll {
-				it.pluginManager.hasPlugin("kotlin")
-			}.each { project ->
-				def kotlinDirs = project.sourceSets.main.kotlin.srcDirs.collect()
-				kotlinDirs -= project.sourceSets.main.java.srcDirs
-				kotlinDirs.each { dir ->
-					if (dir.exists()) {
-						sourceRoot {
-							path = dir.path
-						}
-					}
-				}
-			}
-		}
-	}
-
-	outputFormat = "html"
-	outputDirectory = "$buildDir/docs/kdoc"
-
-	configuration {
-		moduleName = "spring-framework"
-
-		externalDocumentationLink {
-			url = new URL("https://docs.spring.io/spring-framework/docs/$version/javadoc-api/")
-			packageListUrl = new File(buildDir, "docs/javadoc/package-list").toURI().toURL()
-		}
-		externalDocumentationLink {
-			url = new URL("https://projectreactor.io/docs/core/release/api/")
-		}
-		externalDocumentationLink {
-			url = new URL("https://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/")
-		}
-		externalDocumentationLink {
-			url = new URL("https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/")
-		}
-		externalDocumentationLink {
-			url = new URL("https://r2dbc.io/spec/0.8.3.RELEASE/api/")
-		}
-	}
-}
-
-task downloadResources(type: Download) {
-	def version = "0.2.5"
-	src "https://repo.spring.io/release/io/spring/docresources/" +
-			"spring-doc-resources/$version/spring-doc-resources-${version}.zip"
-	dest project.file("$buildDir/docs/spring-doc-resources.zip")
-	onlyIfModified true
-	useETag "all"
-}
-
-task extractDocResources(type: Copy, dependsOn: downloadResources) {
-	from project.zipTree(downloadResources.dest);
-	into "$buildDir/docs/spring-docs-resources/"
+	moduleName.set("spring-framework")
+	outputDirectory.set(project.file("$buildDir/docs/kdoc"))
 }

 asciidoctorj {
-	version = '2.4.1'
+	def docRoot = 'https://docs.spring.io'
+	def docsSpringFramework = "${docRoot}/spring-framework/docs/${project.version}"
+	version = '2.4.3'
 	fatalWarnings ".*"
 	options doctype: 'book', eruby: 'erubis'
 	attributes([
 			icons: 'font',
 			idprefix: '',
 			idseparator: '-',
-			docinfo: 'shared',
 			revnumber: project.version,
 			sectanchors: '',
 			sectnums: '',
-			'source-highlighter': 'highlight.js',
-			highlightjsdir: 'js/highlight',
-			'highlightjs-theme': 'googlecode',
-			stylesdir: 'css/',
-			stylesheet: 'stylesheet.css',
 			'spring-version': project.version,
-			'spring-framework-main-code': 'https://github.com/spring-projects/spring-framework/tree/main'
+			'spring-framework-main-code': 'https://github.com/spring-projects/spring-framework/tree/main',
+			'doc-root': docRoot,
+			'docs-spring-framework': docsSpringFramework,
+			'api-spring-framework': "${docsSpringFramework}/javadoc-api/org/springframework"
 	])
 }

 /**
- * Generate the Spring Framework Reference documentation from "src/docs/asciidoc"
- * in "build/docs/ref-docs/html5".
+ * Generate the Spring Framework Reference documentation from
+ * "src/docs/asciidoc" in "build/docs/ref-docs/html5".
 */
 asciidoctor {
 	baseDirFollowsSourceDir()
-	configurations 'asciidoctorExt'
+	configurations "asciidoctorExtensions"
 	sources {
 		include '*.adoc'
 	}
 	outputDir "$buildDir/docs/ref-docs/html5"
+	outputOptions {
+		backends "spring-html"
+	}
 	logDocuments = true
 	resources {
 		from(sourceDir) {
-			include 'images/*.png', 'css/**', 'js/**'
+			include 'images/*.png'
 		}
-		from extractDocResources
 	}
 }

@@ -174,21 +128,24 @@ asciidoctor {
 */
 asciidoctorPdf {
 	baseDirFollowsSourceDir()
-	configurations 'asciidoctorExt'
+	configurations 'asciidoctorExtensions'
 	sources {
-		include '*.adoc'
+		include 'spring-framework.adocbook'
 	}
 	outputDir "$buildDir/docs/ref-docs/pdf"
+	forkOptions {
+		jvmArgs += ["--add-opens", "java.base/sun.nio.ch=ALL-UNNAMED", "--add-opens", "java.base/java.io=ALL-UNNAMED"]
+	}
 	logDocuments = true
 }

 /**
 * Zip all docs (API and reference) into a single archive
 */
-task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', 'dokka']) {
+task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', rootProject.tasks.dokkaHtmlMultiModule]) {
 	group = "Distribution"
 	description = "Builds -${archiveClassifier} archive containing api and reference " +
-			"for deployment at https://docs.spring.io/spring-framework/docs."
+			"for deployment at https://docs.spring.io/spring-framework/docs/."

 	archiveBaseName.set("spring-framework")
 	archiveClassifier.set("docs")
@@ -204,7 +161,7 @@ task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', 'dok
 	from ("$asciidoctorPdf.outputDir") {
 		into "reference/pdf"
 	}
-	from (dokka) {
+	from (rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
 		into "kdoc-api"
 	}
 }
@@ -261,11 +218,11 @@ task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 		expand(copyright: new Date().format("yyyy"), version: project.version)
 	}

-	from(zipTree(docsZip.archivePath)) {
+	from(zipTree(docsZip.archiveFile)) {
 		into "${baseDir}/docs"
 	}

-	from(zipTree(schemaZip.archivePath)) {
+	from(zipTree(schemaZip.archiveFile)) {
 		into "${baseDir}/schema"
 	}

@@ -283,3 +240,14 @@ task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 }

 distZip.mustRunAfter moduleProjects.check
+
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifact docsZip
+			artifact schemaZip
+			artifact distZip
+		}
+	}
+}
@@ -1,7 +1,7 @@
 <html>
 <body>
 <p>
-This is the public API documentation for the <a href="https://github.com/SpringSource/spring-framework" target="_top">Spring Framework</a>.
+This is the public API documentation for the <a href="https://github.com/spring-projects/spring-framework" target="_top">Spring Framework</a>.
 </p>
 </body>
 </html>
@@ -1,7 +1,5 @@
 [[appendix]]
 = Appendix
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :toc: left
 :toclevels: 4
 :tabsize: 4
@@ -1,7 +1,5 @@
 [[spring-core]]
 = Core Technologies
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :toc: left
 :toclevels: 4
 :tabsize: 4
@@ -21,6 +19,9 @@ Coverage of Spring's integration with AspectJ (currently the richest -- in terms
 features -- and certainly most mature AOP implementation in the Java enterprise space)
 is also provided.

+AOT processing can be used to optimize your application ahead-of-time. It is typically
+used for native image deployment using GraalVM.
+
 include::core/core-beans.adoc[leveloffset=+1]

 include::core/core-resources.adoc[leveloffset=+1]
@@ -39,4 +40,6 @@ include::core/core-databuffer-codec.adoc[leveloffset=+1]

 include::core/core-spring-jcl.adoc[leveloffset=+1]

+include::core/core-aot.adoc[leveloffset=+1]
+
 include::core/core-appendix.adoc[leveloffset=+1]
@@ -1637,7 +1637,7 @@ The following listing shows an example configuration:

 Note that the target object (`businessObjectTarget` in the preceding example) must be a
 prototype. This lets the `PoolingTargetSource` implementation create new instances
-of the target to grow the pool as necessary. See the {api-spring-framework}aop/target/AbstractPoolingTargetSource.html[javadoc of
+of the target to grow the pool as necessary. See the {api-spring-framework}/aop/target/AbstractPoolingTargetSource.html[javadoc of
 `AbstractPoolingTargetSource`] and the concrete subclass you wish to use for information
 about its properties. `maxSize` is the most basic and is always guaranteed to be present.

@@ -262,8 +262,8 @@ element, as the following example shows:
 ----

 This assumes that you use schema support as described in
-<<core.adoc#xsd-schemas, XML Schema-based configuration>>.
-See <<core.adoc#xsd-schemas-aop, the AOP schema>> for how to
+<<core.adoc#core.appendix.xsd-schemas, XML Schema-based configuration>>.
+See <<core.adoc#core.appendix.xsd-schemas-aop, the AOP schema>> for how to
 import the tags in the `aop` namespace.


@@ -366,7 +366,7 @@ the https://www.eclipse.org/aspectj/doc/released/progguide/index.html[AspectJ
 Programming Guide] (and, for extensions, the
 https://www.eclipse.org/aspectj/doc/released/adk15notebook/index.html[AspectJ 5
 Developer's Notebook]) or one of the books on AspectJ (such as _Eclipse AspectJ_, by Colyer
-et. al., or _AspectJ in Action_, by Ramnivas Laddad).
+et al., or _AspectJ in Action_, by Ramnivas Laddad).


 [[aop-pointcuts-designators]]
@@ -770,7 +770,7 @@ sub-packages:
 	this(com.xyz.service.AccountService)
 ----
 +
-NOTE: 'this' is more commonly used in a binding form. See the section on <<aop-advice>>
+NOTE: `this` is more commonly used in a binding form. See the section on <<aop-advice>>
 for how to make the proxy object available in the advice body.

 * Any join point (method execution only in Spring AOP) where the target object
@@ -781,7 +781,7 @@ implements the `AccountService` interface:
 	target(com.xyz.service.AccountService)
 ----
 +
-NOTE: 'target' is more commonly used in a binding form. See the <<aop-advice>> section
+NOTE: `target` is more commonly used in a binding form. See the <<aop-advice>> section
 for how to make the target object available in the advice body.

 * Any join point (method execution only in Spring AOP) that takes a single parameter
@@ -792,7 +792,7 @@ and where the argument passed at runtime is `Serializable`:
 	args(java.io.Serializable)
 ----
 +
-NOTE: 'args' is more commonly used in a binding form. See the <<aop-advice>> section
+NOTE: `args` is more commonly used in a binding form. See the <<aop-advice>> section
 for how to make the method arguments available in the advice body.
 +
 Note that the pointcut given in this example is different from `execution(*
@@ -808,7 +808,7 @@ parameter of type `Serializable`.
 	@target(org.springframework.transaction.annotation.Transactional)
 ----
 +
-NOTE: You can also use '@target' in a binding form. See the <<aop-advice>> section for
+NOTE: You can also use `@target` in a binding form. See the <<aop-advice>> section for
 how to make the annotation object available in the advice body.

 * Any join point (method execution only in Spring AOP) where the declared type of the
@@ -819,7 +819,7 @@ target object has an `@Transactional` annotation:
 	@within(org.springframework.transaction.annotation.Transactional)
 ----
 +
-NOTE: You can also use '@within' in a binding form. See the <<aop-advice>> section for
+NOTE: You can also use `@within` in a binding form. See the <<aop-advice>> section for
 how to make the annotation object available in the advice body.

 * Any join point (method execution only in Spring AOP) where the executing method has an
@@ -830,7 +830,7 @@ how to make the annotation object available in the advice body.
 	@annotation(org.springframework.transaction.annotation.Transactional)
 ----
 +
-NOTE: You can also use '@annotation' in a binding form. See the <<aop-advice>> section
+NOTE: You can also use `@annotation` in a binding form. See the <<aop-advice>> section
 for how to make the annotation object available in the advice body.

 * Any join point (method execution only in Spring AOP) which takes a single parameter,
@@ -841,7 +841,7 @@ and where the runtime type of the argument passed has the `@Classified` annotati
 	@args(com.xyz.security.Classified)
 ----
 +
-NOTE: You can also use '@args' in a binding form. See the <<aop-advice>> section
+NOTE: You can also use `@args` in a binding form. See the <<aop-advice>> section
 how to make the annotation object(s) available in the advice body.

 * Any join point (method execution only in Spring AOP) on a Spring bean named
@@ -893,7 +893,7 @@ scoping). You can include the contextual designators to match based on
 join point context or bind that context for use in the advice. Supplying only a
 kinded designator or only a contextual designator works but could affect weaving
 performance (time and memory used), due to extra processing and analysis. Scoping
-designators are very fast to match, and using them usage means AspectJ can very quickly
+designators are very fast to match, and using them means AspectJ can very quickly
 dismiss groups of join points that should not be further processed. A good
 pointcut should always include one if possible.

@@ -1213,33 +1213,60 @@ in contrast to `@AfterReturning` which only applies to successful normal returns
 [[aop-ataspectj-around-advice]]
 ==== Around Advice

-The last kind of advice is around advice. Around advice runs "`around`" a matched
+The last kind of advice is _around_ advice. Around advice runs "around" a matched
 method's execution. It has the opportunity to do work both before and after the method
 runs and to determine when, how, and even if the method actually gets to run at all.
 Around advice is often used if you need to share state before and after a method
-execution in a thread-safe manner (starting and stopping a timer, for example).
-Always use the least powerful form of advice that meets your requirements (that is,
-do not use around advice if before advice would do).
+execution in a thread-safe manner – for example, starting and stopping a timer.

-Around advice is declared by using the `@Around` annotation. The first parameter of the
-advice method must be of type `ProceedingJoinPoint`. Within the body of the advice,
-calling `proceed()` on the `ProceedingJoinPoint` causes the underlying method to run.
-The `proceed` method can also pass in an `Object[]`. The values in the array are used
-as the arguments to the method execution when it proceeds.
+[TIP]
+====
+Always use the least powerful form of advice that meets your requirements.

-NOTE: The behavior of `proceed` when called with an `Object[]` is a little different than
-the behavior of `proceed` for around advice compiled by the AspectJ compiler. For around
+For example, do not use _around_ advice if _before_ advice is sufficient for your needs.
+====
+
+Around advice is declared by annotating a method with the `@Around` annotation. The
+method should declare `Object` as its return type, and the first parameter of the method
+must be of type `ProceedingJoinPoint`. Within the body of the advice method, you must
+invoke `proceed()` on the `ProceedingJoinPoint` in order for the underlying method to
+run. Invoking `proceed()` without arguments will result in the caller's original
+arguments being supplied to the underlying method when it is invoked. For advanced use
+cases, there is an overloaded variant of the `proceed()` method which accepts an array of
+arguments (`Object[]`). The values in the array will be used as the arguments to the
+underlying method when it is invoked.
+
+[NOTE]
+====
+The behavior of `proceed` when called with an `Object[]` is a little different than the
+behavior of `proceed` for around advice compiled by the AspectJ compiler. For around
 advice written using the traditional AspectJ language, the number of arguments passed to
 `proceed` must match the number of arguments passed to the around advice (not the number
 of arguments taken by the underlying join point), and the value passed to proceed in a
-given argument position supplants the original value at the join point for the entity
-the value was bound to (do not worry if this does not make sense right now). The approach
-taken by Spring is simpler and a better match to its proxy-based, execution-only
-semantics. You only need to be aware of this difference if you compile @AspectJ
-aspects written for Spring and use `proceed` with arguments with the AspectJ compiler
-and weaver. There is a way to write such aspects that is 100% compatible across both
-Spring AOP and AspectJ, and this is discussed in the
-<<aop-ataspectj-advice-params, following section on advice parameters>>.
+given argument position supplants the original value at the join point for the entity the
+value was bound to (do not worry if this does not make sense right now).
+
+The approach taken by Spring is simpler and a better match to its proxy-based,
+execution-only semantics. You only need to be aware of this difference if you compile
+`@AspectJ` aspects written for Spring and use `proceed` with arguments with the AspectJ
+compiler and weaver. There is a way to write such aspects that is 100% compatible across
+both Spring AOP and AspectJ, and this is discussed in the
+<<aop-ataspectj-advice-proceeding-with-the-call, following section on advice parameters>>.
+====
+
+The value returned by the around advice is the return value seen by the caller of the
+method. For example, a simple caching aspect could return a value from a cache if it has
+one or invoke `proceed()` (and return that value) if it does not. Note that `proceed`
+may be invoked once, many times, or not at all within the body of the around advice. All
+of these are legal.
+
+WARNING: If you declare the return type of your around advice method as `void`, `null`
+will always be returned to the caller, effectively ignoring the result of any invocation
+of `proceed()`. It is therefore recommended that an around advice method declare a return
+type of `Object`. The advice method should typically return the value returned from an
+invocation of `proceed()`, even if the underlying method has a `void` return type.
+However, the advice may optionally return a cached value, a wrapped value, or some other
+value depending on the use case.

 The following example shows how to use around advice:

@@ -1282,12 +1309,6 @@ The following example shows how to use around advice:
 	}
 ----

-The value returned by the around advice is the return value seen by the caller of the
-method. For example, a simple caching aspect could return a value from a cache if it
-has one and invoke `proceed()` if it does not. Note that `proceed` may be invoked once,
-many times, or not at all within the body of the around advice. All of these are legal.
-
-
 [[aop-ataspectj-advice-params]]
 ==== Advice Parameters

@@ -1301,8 +1322,9 @@ write generic advice that can find out about the method the advice is currently
 ===== Access to the Current `JoinPoint`

 Any advice method may declare, as its first parameter, a parameter of type
-`org.aspectj.lang.JoinPoint` (note that around advice is required to declare a first
+`org.aspectj.lang.JoinPoint`. Note that around advice is required to declare a first
 parameter of type `ProceedingJoinPoint`, which is a subclass of `JoinPoint`.
+
 The `JoinPoint` interface provides a number of useful methods:

 * `getArgs()`: Returns the method arguments.
@@ -1319,7 +1341,7 @@ See the https://www.eclipse.org/aspectj/doc/released/runtime-api/org/aspectj/lan
 We have already seen how to bind the returned value or exception value (using after
 returning and after throwing advice). To make argument values available to the advice
 body, you can use the binding form of `args`. If you use a parameter name in place of a
-type name in an args expression, the value of the corresponding argument is passed as
+type name in an `args` expression, the value of the corresponding argument is passed as
 the parameter value when the advice is invoked. An example should make this clearer.
 Suppose you want to advise the execution of DAO operations that take an `Account`
 object as the first parameter, and you need access to the account in the advice body.
@@ -1348,7 +1370,7 @@ parameter, and the argument passed to that parameter is an instance of `Account`
 Second, it makes the actual `Account` object available to the advice through the `account`
 parameter.

-Another way of writing this is to declare a pointcut that "`provides`" the `Account`
+Another way of writing this is to declare a pointcut that "provides" the `Account`
 object value when it matches a join point, and then refer to the named pointcut
 from the advice. This would look as follows:

@@ -1376,13 +1398,12 @@ from the advice. This would look as follows:
 	}
 ----

-See the AspectJ programming guide for more
-details.
+See the AspectJ programming guide for more details.

-The proxy object ( `this`), target object ( `target`), and annotations ( `@within`,
-`@target`, `@annotation`, and `@args`) can all be bound in a similar fashion. The next two
-examples show how to match the execution of methods annotated with an
-`@Auditable` annotation and extract the audit code:
+The proxy object (`this`), target object (`target`), and annotations (`@within`,
+`@target`, `@annotation`, and `@args`) can all be bound in a similar fashion. The next
+two examples show how to match the execution of methods annotated with an `@Auditable`
+annotation and extract the audit code:

 The first of the two examples shows the definition of the `@Auditable` annotation:

@@ -1448,7 +1469,7 @@ you have a generic type like the following:
 ----

 You can restrict interception of method types to certain parameter types by
-typing the advice parameter to the parameter type for which you want to intercept the method:
+tying the advice parameter to the parameter type for which you want to intercept the method:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1575,18 +1596,18 @@ the `argNames` attribute:
 	}
 ----

-* Using the `'argNames'` attribute is a little clumsy, so if the `'argNames'` attribute
+* Using the `argNames` attribute is a little clumsy, so if the `argNames` attribute
  has not been specified,  Spring AOP looks at the debug information for the
  class and tries to determine the parameter names from the local variable table. This
  information is present as long as the classes have been compiled with debug
-  information ( `'-g:vars'` at a minimum). The consequences of compiling with this flag
+  information (`-g:vars` at a minimum). The consequences of compiling with this flag
  on are: (1) your code is slightly easier to understand (reverse engineer), (2)
  the class file sizes are very slightly bigger (typically inconsequential), (3) the
-  optimization to remove unused local variables is not  applied by your compiler. In
+  optimization to remove unused local variables is not applied by your compiler. In
  other words, you should encounter no difficulties by building with this flag on.
 +
-NOTE: If an @AspectJ aspect has been compiled by the AspectJ compiler (ajc) even without the
-debug information, you need not add the `argNames` attribute, as the compiler
+NOTE: If an @AspectJ aspect has been compiled by the AspectJ compiler (`ajc`) even
+without the debug information, you need not add the `argNames` attribute, as the compiler
 retain the needed information.

 * If the code has been compiled without the necessary debug information, Spring AOP
@@ -1970,8 +1991,8 @@ that syntax and refer the reader to the discussion in the previous section
 of advice parameters.

 To use the aop namespace tags described in this section, you need to import the
-`spring-aop` schema, as described in <<core.adoc#xsd-schemas,
-XML Schema-based configuration>>. See <<core.adoc#xsd-schemas-aop, the AOP schema>>
+`spring-aop` schema, as described in <<core.adoc#core.appendix.xsd-schemas,
+XML Schema-based configuration>>. See <<core.adoc#core.appendix.xsd-schemas-aop, the AOP schema>>
 for how to import the tags in the `aop` namespace.

 Within your Spring configurations, all aspect and advisor elements must be placed within
@@ -2315,20 +2336,30 @@ You can declare it by using the `after` element, as the following example shows:
 [[aop-schema-advice-around]]
 ==== Around Advice

-The last kind of advice is around advice. Around advice runs "around" a matched method
-execution. It has the opportunity to do work both before and after the method runs
-and to determine when, how, and even if the method actually gets to run at all.
-Around advice is often used to share state before and after a method execution in a
-thread-safe manner (starting and stopping a timer, for example). Always use the least
-powerful form of advice that meets your requirements. Do not use around advice if
-before advice can do the job.
+The last kind of advice is _around_ advice. Around advice runs "around" a matched
+method's execution. It has the opportunity to do work both before and after the method
+runs and to determine when, how, and even if the method actually gets to run at all.
+Around advice is often used if you need to share state before and after a method
+execution in a thread-safe manner – for example, starting and stopping a timer.
+
+[TIP]
+====
+Always use the least powerful form of advice that meets your requirements.
+
+For example, do not use _around_ advice if _before_ advice is sufficient for your needs.
+====
+
+You can declare around advice by using the `aop:around` element. The advice method should
+declare `Object` as its return type, and the first parameter of the method must be of
+type `ProceedingJoinPoint`. Within the body of the advice method, you must invoke
+`proceed()` on the `ProceedingJoinPoint` in order for the underlying method to run.
+Invoking `proceed()` without arguments will result in the caller's original arguments
+being supplied to the underlying method when it is invoked. For advanced use cases, there
+is an overloaded variant of the `proceed()` method which accepts an array of arguments
+(`Object[]`). The values in the array will be used as the arguments to the underlying
+method when it is invoked. See <<aop-ataspectj-around-advice>> for notes on calling
+`proceed` with an `Object[]`.

-You can declare around advice by using the `aop:around` element. The first parameter of
-the advice method must be of type `ProceedingJoinPoint`. Within the body of the advice,
-calling `proceed()` on the `ProceedingJoinPoint` causes the underlying method to run.
-The `proceed` method may also be called with an `Object[]`. The values in the array
-are used as the arguments to the method execution when it proceeds.
-See <<aop-ataspectj-around-advice>> for notes on calling `proceed` with an `Object[]`.
 The following example shows how to declare around advice in XML:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -2542,7 +2573,7 @@ With such a Boot class, we would get output similar to the following on standard

 [literal,subs="verbatim,quotes"]
 ----
-StopWatch 'Profiling for 'Pengo' and '12'': running time (millis) = 0
+StopWatch 'Profiling for 'Pengo' and '12': running time (millis) = 0
 -----------------------------------------
 ms     %     Task name
 -----------------------------------------
@@ -2830,7 +2861,7 @@ The corresponding Spring configuration is as follows:
 	</bean>
 ----

-Notice that, for the time, being we assume that all business services are idempotent. If
+Notice that, for the time being, we assume that all business services are idempotent. If
 this is not the case, we can refine the aspect so that it retries only genuinely
 idempotent operations, by introducing an `Idempotent` annotation and using the annotation
 to annotate the implementation of service operations, as the following example shows:
@@ -3471,7 +3502,7 @@ use Java-based configuration, you can add `@EnableSpringConfigured` to any
 ----

 If you prefer XML based configuration, the Spring
-<<core.adoc#xsd-schemas-context, `context` namespace>>
+<<core.adoc#core.appendix.xsd-schemas-context, `context` namespace>>
 defines a convenient `context:spring-configured` element, which you can use as follows:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -3540,7 +3571,7 @@ with references to beans defined in the child (servlet-specific) contexts by usi

 When deploying multiple web applications within the same container, ensure that each
 web application loads the types in `spring-aspects.jar` by using its own classloader
-(for example, by placing `spring-aspects.jar` in `'WEB-INF/lib'`). If `spring-aspects.jar`
+(for example, by placing `spring-aspects.jar` in `WEB-INF/lib`). If `spring-aspects.jar`
 is added only to the container-wide classpath (and hence loaded by the shared parent
 classloader), all web applications share the same aspect instance (which is probably
 not what you want).
@@ -3570,7 +3601,7 @@ visibility may be annotated, including private methods. Annotating non-public me
 directly is the only way to get transaction demarcation for the execution of such methods.

 TIP: Since Spring Framework 4.2, `spring-aspects` provides a similar aspect that offers the
-exact same features for the standard `javax.transaction.Transactional` annotation. Check
+exact same features for the standard `jakarta.transaction.Transactional` annotation. Check
 `JtaAnnotationTransactionAspect` for more details.

 For AspectJ programmers who want to use the Spring configuration and transaction
@@ -0,0 +1,292 @@
+[[aot]]
+= Ahead of Time Optimizations
+
+This chapter covers Spring's Ahead of Time (AOT) optimizations.
+
+For AOT support specific to integration tests, see <<testing.adoc#testcontext-aot, Ahead of Time Support for Tests>>.
+
+[[aot-introduction]]
+== Introduction to Ahead of Time Optimizations
+
+Spring's support for AOT optimizations is meant to inspect an `ApplicationContext` at build time and apply decisions and discovery logic that usually happens at runtime.
+Doing so allows building an application startup arrangement that is more straightforward and focused on a fixed set of features based mainly on the classpath and the `Environment`.
+
+Applying such optimizations early implies the following restrictions:
+
+* The classpath is fixed and fully defined at build time.
+* The beans defined in your application cannot change at runtime, meaning:
+** `@Profile`, in particular profile-specific configuration needs to be chosen at build time.
+** Environment properties that impact the presence of a bean (`@Conditional`) are only considered at build time.
+
+When these restrictions are in place, it becomes possible to perform ahead-of-time processing at build time and generate additional assets.
+A Spring AOT processed application typically generates:
+
+* Java source code
+* Bytecode (usually for dynamic proxies)
+* {api-spring-framework}/aot/hint/RuntimeHints.html[`RuntimeHints`] for the use of reflection, resource loading, serialization, and JDK proxies.
+
+NOTE: At the moment, AOT is focused on allowing Spring applications to be deployed as native images using GraalVM.
+We intend to offer more JVM-based use cases in future generations.
+
+[[aot-basics]]
+== AOT engine overview
+
+The entry point of the AOT engine for processing an `ApplicationContext` arrangement is `ApplicationContextAotGenerator`. It takes care of the following steps, based on a `GenericApplicationContext` that represents the application to optimize and a {api-spring-framework}/aot/generate/GenerationContext.html[`GenerationContext`]:
+
+* Refresh an `ApplicationContext` for AOT processing. Contrary to a traditional refresh, this version only creates bean definitions, not bean instances.
+* Invoke the available `BeanFactoryInitializationAotProcessor` implementations and apply their contributions against the `GenerationContext`.
+For instance, a core implementation iterates over all candidate bean definitions and generates the necessary code to restore the state of the `BeanFactory`.
+
+Once this process completes, the `GenerationContext` has been updated with the generated code, resources, and classes that are necessary for the application to run.
+The `RuntimeHints` instance can also be used to generate the relevant GraalVM native image configuration files.
+
+`ApplicationContextAotGenerator#processAheadOfTime` returns the class name of the `ApplicationContextInitializer` entry point that allows the context to be started with AOT optimizations.
+
+Those steps are covered in more details in the sections below.
+
+[[aot-refresh]]
+== Refresh for AOT Processing
+
+Refresh for AOT processing is supported on all `GenericApplicationContext` implementations.
+An application context is created with any number of entry points, usually in the form of `@Configuration`-annotated classes.
+
+Let's look at a basic example:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+@Configuration(proxyBeanMethods=false)
+@ComponentScan
+@Import({DataSourceConfiguration.class, ContainerConfiguration.class})
+public class MyApplication {
+}
+----
+
+Starting this application with the regular runtime involves a number of steps including classpath scanning, configuration class parsing, bean instantiation, and lifecycle callback handling.
+Refresh for AOT processing only applies a subset of what happens with a <<beans-introduction,regular `refresh`>>.
+AOT processing can be triggered as follows:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+GenericApplicationContext applicationContext = new AnnotatedConfigApplicationContext();
+context.register(MyApplication.class);
+context.refreshForAotProcessing();
+----
+
+In this mode, <<beans-factory-extension-factory-postprocessors,`BeanFactoryPostProcessor` implementations>> are invoked as usual.
+This includes configuration class parsing, import selectors, classpath scanning, etc.
+Such steps make sure that the `BeanRegistry` contains the relevant bean definitions for the application.
+If bean definitions are guarded by conditions (such as `@Profile`), these are discarded at this stage.
+
+Because this mode does not actually create bean instances, `BeanPostProcessor` implementations are not invoked, except for specific variants that are relevant for AOT processing.
+These are:
+
+* `MergedBeanDefinitionPostProcessor` implementations post-process bean definitions to extract additional settings, such as `init` and `destroy` methods.
+* `SmartInstantiationAwareBeanPostProcessor` implementations determine a more precise bean type if necessary.
+This makes sure to create any proxy that is required at runtime.
+
+One this part completes, the `BeanFactory` contains the bean definitions that are necessary for the application to run. It does not trigger bean instantiation but allows the AOT engine to inspect the beans that would be created at runtime.
+
+[[aot-bean-factory-initialization-contributions]]
+== Bean Factory Initialization AOT Contributions
+
+Components that want to participate in this step can implement the {api-spring-framework}/beans/factory/aot/BeanFactoryInitializationAotProcessor.html[`BeanFactoryInitializationAotProcessor`] interface.
+Each implementation can return an AOT contribution, based on the state of the bean factory.
+
+An AOT contribution is a component that contributes generated code that reproduces a particular behavior.
+It can also contribute `RuntimeHints` to indicate the need for reflection, resource loading, serialization, or JDK proxies.
+
+A `BeanFactoryInitializationAotProcessor` implementation can be registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.
+
+A `BeanFactoryInitializationAotProcessor` can also be implemented directly by a bean.
+In this mode, the bean provides an AOT contribution equivalent to the feature it provides with a regular runtime.
+Consequently, such a bean is automatically excluded from the AOT-optimized context.
+
+[NOTE]
+====
+If a bean implements the `BeanFactoryInitializationAotProcessor` interface, the bean and **all** of its dependencies will be initialized during AOT processing.
+We generally recommend that this interface is only implemented by infrastructure beans such as `BeanFactoryPostProcessor` which have limited dependencies and are already initialized early in the bean factory lifecycle.
+If such a bean is registered using an `@Bean` factory method, ensure the method is `static` so that its enclosing `@Configuration` class does not have to be initialized.
+====
+
+
+[[aot-bean-registration-contributions]]
+=== Bean Registration AOT Contributions
+
+A core `BeanFactoryInitializationAotProcessor` implementation is responsible for collecting the necessary contributions for each candidate `BeanDefinition`.
+It does so using a dedicated `BeanRegistrationAotProcessor`.
+
+This interface is used as follows:
+
+* Implemented by a `BeanPostProcessor` bean, to replace its runtime behavior.
+For instance <<beans-factory-extension-bpp-examples-aabpp,`AutowiredAnnotationBeanPostProcessor`>> implements this interface to generate code that injects members annotated with `@Autowired`.
+* Implemented by a type registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.
+Typically used when the bean definition needs to be tuned for specific features of the core framework.
+
+[NOTE]
+====
+If a bean implements the `BeanRegistrationAotProcessor` interface, the bean and **all** of its dependencies will be initialized during AOT processing.
+We generally recommend that this interface is only implemented by infrastructure beans such as `BeanFactoryPostProcessor` which have limited dependencies and are already initialized early in the bean factory lifecycle.
+If such a bean is registered using an `@Bean` factory method, ensure the method is `static` so that its enclosing `@Configuration` class does not have to be initialized.
+====
+
+If no `BeanRegistrationAotProcessor` handles a particular registered bean, a default implementation processes it.
+This is the default behavior, since tuning the generated code for a bean definition should be restricted to corner cases.
+
+Taking our previous example, let's assume that `DataSourceConfiguration` is as follows:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	@Configuration(proxyBeanMethods = false)
+	public class DataSourceConfiguration {
+
+		@Bean
+		public SimpleDataSource dataSource() {
+			return new SimpleDataSource();
+		}
+
+	}
+----
+
+Since there isn't any particular condition on this class, `dataSourceConfiguration` and `dataSource` are identified as candidates.
+The AOT engine will convert the configuration class above to code similar to the following:
+
+[source,java,indent=0,role="primary"]
+.Java
+----
+	/**
+	 * Bean definitions for {@link DataSourceConfiguration}
+	 */
+	public class DataSourceConfiguration__BeanDefinitions {
+		/**
+		 * Get the bean definition for 'dataSourceConfiguration'
+		 */
+		public static BeanDefinition getDataSourceConfigurationBeanDefinition() {
+			Class<?> beanType = DataSourceConfiguration.class;
+			RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
+			beanDefinition.setInstanceSupplier(DataSourceConfiguration::new);
+			return beanDefinition;
+		}
+
+		/**
+		 * Get the bean instance supplier for 'dataSource'.
+		 */
+		private static BeanInstanceSupplier<SimpleDataSource> getDataSourceInstanceSupplier() {
+			return BeanInstanceSupplier.<SimpleDataSource>forFactoryMethod(DataSourceConfiguration.class, "dataSource")
+					.withGenerator((registeredBean) -> registeredBean.getBeanFactory().getBean(DataSourceConfiguration.class).dataSource());
+		}
+
+		/**
+		 * Get the bean definition for 'dataSource'
+		 */
+		public static BeanDefinition getDataSourceBeanDefinition() {
+			Class<?> beanType = SimpleDataSource.class;
+			RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
+			beanDefinition.setInstanceSupplier(getDataSourceInstanceSupplier());
+			return beanDefinition;
+		}
+	}
+----
+
+NOTE: The exact code generated may differ depending on the exact nature of your bean definitions.
+
+The generated code above creates bean definitions equivalent to the `@Configuration` class, but in a direct way and without the use of reflection if at all possible.
+There is a bean definition for `dataSourceConfiguration` and one for `dataSourceBean`.
+When a `datasource` instance is required, a `BeanInstanceSupplier` is called.
+This supplier invokes the `dataSource()` method on the `dataSourceConfiguration` bean.
+
+
+[[aot-hints]]
+== Runtime Hints
+
+Running an application as a native image requires additional information compared to a regular JVM runtime.
+For instance, GraalVM needs to know ahead of time if a component uses reflection.
+Similarly, classpath resources are not shipped in a native image unless specified explicitly.
+Consequently, if the application needs to load a resource, it must be referenced from the corresponding GraalVM native image configuration file.
+
+The {api-spring-framework}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxies at runtime.
+The following example makes sure that `config/app.properties` can be loaded from the classpath at runtime within a native image:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	runtimeHints.resources().registerPattern("config/app.properties");
+----
+
+A number of contracts are handled automatically during AOT processing.
+For instance, the return type of a `@Controller` method is inspected, and relevant reflection hints are added if Spring detects that the type should be serialized (typically to JSON).
+
+For cases that the core container cannot infer, you can register such hints programmatically.
+A number of convenient annotations are also provided for common use cases.
+
+
+[[aot-hints-import-runtime-hints]]
+=== `@ImportRuntimeHints`
+
+`RuntimeHintsRegistrar` implementations allow you to get a callback to the `RuntimeHints` instance managed by the AOT engine.
+Implementations of this interface can be registered using `@ImportRuntimeHints` on any Spring bean or `@Bean` factory method.
+`RuntimeHintsRegistrar` implementations are detected and invoked at build time.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	@Component
+	@ImportRuntimeHints(MyComponentRuntimeHints.class)
+	public class MyComponent {
+
+		// ...
+
+		private static class MyComponentRuntimeHints implements RuntimeHintsRegistrar {
+
+			@Override
+			public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
+				// ...
+			}
+		}
+	}
+----
+
+If at all possible, `@ImportRuntimeHints` should be used as close as possible to the component that requires the hints.
+This way, if the component is not contributed to the `BeanFactory`, the hints won't be contributed either.
+
+It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the `RuntimeHintsRegistrar` interface.
+
+
+[[aot-hints-reflective]]
+=== `@Reflective`
+
+{api-spring-framework}/aot/hint/annotation/Reflective.html[`@Reflective`] provides an idiomatic way to flag the need for reflection on an annotated element.
+For instance, `@EventListener` is meta-annotated with `@Reflective` since the underlying implementation invokes the annotated method using reflection.
+
+By default, only Spring beans are considered and an invocation hint is registered for the annotated element.
+This can be tuned by specifying a custom `ReflectiveProcessor` implementation via the
+`@Reflective` annotation.
+
+Library authors can reuse this annotation for their own purposes.
+If components other than Spring beans need to be processed, a `BeanFactoryInitializationAotProcessor` can detect the relevant types and use `ReflectiveRuntimeHintsRegistrar` to process them.
+
+
+[[aot-hints-register-reflection-for-binding]]
+=== `@RegisterReflectionForBinding`
+
+{api-spring-framework}/aot/hint/annotation/RegisterReflectionForBinding.html[`@RegisterReflectionForBinding`] is a specialization of `@Reflective` that registers the need for serializing arbitrary types.
+A typical use case is the use of DTOs that the container cannot infer, such as using a web client within a method body.
+
+`@RegisterReflectionForBinding` can be applied to any Spring bean at the class level, but it can also be applied directly to a method, field, or constructor to better indicate where the hints are actually required.
+The following example registers `Account` for serialization.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	@Component
+	public class OrderService {
+
+		@RegisterReflectionForBinding(Account.class)
+		public void process(Order order) {
+			// ...
+		}
+
+	}
+----
@@ -1,19 +1,17 @@
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
-
+[[core.appendix]]
 = Appendix




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

 This part of the appendix lists XML schemas related to the core container.



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

 As the name implies, the `util` tags deal with common, utility configuration
@@ -38,7 +36,7 @@ correct schema so that the tags in the `util` namespace are available to you):
 ----


-[[xsd-schemas-util-constant]]
+[[core.appendix.xsd-schemas-util-constant]]
 ==== Using `<util:constant/>`

 Consider the following bean definition:
@@ -71,7 +69,7 @@ developer's intent ("`inject this constant value`"), and it reads better:
 	</bean>
 ----

-[[xsd-schemas-util-frfb]]
+[[core.appendix.xsd-schemas-util-frfb]]
 ===== Setting a Bean Property or Constructor Argument from a Field Value

 {api-spring-framework}/beans/factory/config/FieldRetrievingFactoryBean.html[`FieldRetrievingFactoryBean`]
@@ -128,7 +126,7 @@ The following example enumeration shows how easy injecting an enum value is:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	package javax.persistence;
+	package jakarta.persistence;

 	public enum PersistenceContextType {

@@ -139,7 +137,7 @@ The following example enumeration shows how easy injecting an enum value is:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	package javax.persistence
+	package jakarta.persistence

 	enum class PersistenceContextType {

@@ -183,7 +181,7 @@ Now consider the following setter of type `PersistenceContextType` and the corre
 ----


-[[xsd-schemas-util-property-path]]
+[[core.appendix.xsd-schemas-util-property-path]]
 ==== Using `<util:property-path/>`

 Consider the following example:
@@ -230,7 +228,7 @@ The value of the `path` attribute of the `<property-path/>` element follows the
 `beanName.beanProperty`. In this case, it picks up the `age` property of the bean named
 `testBean`. The value of that `age` property is `10`.

-[[xsd-schemas-util-property-path-dependency]]
+[[core.appendix.xsd-schemas-util-property-path-dependency]]
 ===== Using `<util:property-path/>` to Set a Bean Property or Constructor Argument

 `PropertyPathFactoryBean` is a `FactoryBean` that evaluates a property path on a given
@@ -305,7 +303,7 @@ for most use cases, but it can sometimes be useful. See the javadoc for more inf
 this feature.


-[[xsd-schemas-util-properties]]
+[[core.appendix.xsd-schemas-util-properties]]
 ==== Using `<util:properties/>`

 Consider the following example:
@@ -331,7 +329,7 @@ The following example uses a `util:properties` element to make a more concise re
 ----


-[[xsd-schemas-util-list]]
+[[core.appendix.xsd-schemas-util-list]]
 ==== Using `<util:list/>`

 Consider the following example:
@@ -386,7 +384,7 @@ following configuration:
 If no `list-class` attribute is supplied, the container chooses a `List` implementation.


-[[xsd-schemas-util-map]]
+[[core.appendix.xsd-schemas-util-map]]
 ==== Using `<util:map/>`

 Consider the following example:
@@ -441,7 +439,7 @@ following configuration:
 If no `'map-class'` attribute is supplied, the container chooses a `Map` implementation.


-[[xsd-schemas-util-set]]
+[[core.appendix.xsd-schemas-util-set]]
 ==== Using `<util:set/>`

 Consider the following example:
@@ -497,7 +495,7 @@ If no `set-class` attribute is supplied, the container chooses a `Set` implement



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

 The `aop` tags deal with configuring all things AOP in Spring, including Spring's
@@ -527,7 +525,7 @@ are available to you):



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

 The `context` tags deal with `ApplicationContext` configuration that relates to plumbing
@@ -552,7 +550,7 @@ available to you:
 ----


-[[xsd-schemas-context-pphc]]
+[[core.appendix.xsd-schemas-context-pphc]]
 ==== Using `<property-placeholder/>`

 This element activates the replacement of `${...}` placeholders, which are resolved against a
@@ -562,7 +560,7 @@ is a convenience mechanism that sets up a <<core.adoc#beans-factory-placeholderc
 `PropertySourcesPlaceholderConfigurer` setup, you can explicitly define it as a bean yourself.


-[[xsd-schemas-context-ac]]
+[[core.appendix.xsd-schemas-context-ac]]
 ==== Using `<annotation-config/>`

 This element activates the Spring infrastructure to detect annotations in bean classes:
@@ -585,28 +583,28 @@ element for that purpose. Similarly, Spring's
 <<integration.adoc#cache-annotation-enable, enabled>> as well.


-[[xsd-schemas-context-component-scan]]
+[[core.appendix.xsd-schemas-context-component-scan]]
 ==== Using `<component-scan/>`

 This element is detailed in the section on <<core.adoc#beans-annotation-config,
 annotation-based container configuration>>.


-[[xsd-schemas-context-ltw]]
+[[core.appendix.xsd-schemas-context-ltw]]
 ==== Using `<load-time-weaver/>`

 This element is detailed in the section on <<core.adoc#aop-aj-ltw,
 load-time weaving with AspectJ in the Spring Framework>>.


-[[xsd-schemas-context-sc]]
+[[core.appendix.xsd-schemas-context-sc]]
 ==== Using `<spring-configured/>`

 This element is detailed in the section on <<core.adoc#aop-atconfigurable,
 using AspectJ to dependency inject domain objects with Spring>>.


-[[xsd-schemas-context-mbe]]
+[[core.appendix.xsd-schemas-context-mbe]]
 ==== Using `<mbean-export/>`

 This element is detailed in the section on <<integration.adoc#jmx-context-mbeanexport,
@@ -614,7 +612,7 @@ configuring annotation-based MBean export>>.



-[[xsd-schemas-beans]]
+[[core.appendix.xsd-schemas-beans]]
 === The Beans Schema

 Last but not least, we have the elements in the `beans` schema. These elements
@@ -626,7 +624,7 @@ in <<core.adoc#beans-factory-properties-detailed, dependencies and configuration
 Note that you can add zero or more key-value pairs to `<bean/>` XML definitions.
 What, if anything, is done with this extra metadata is totally up to your own custom
 logic (and so is typically only of use if you write your own custom elements as described
-in the appendix entitled <<xml-custom>>).
+in the appendix entitled <<core.appendix.xml-custom>>).

 The following example shows the `<meta/>` element in the context of a surrounding `<bean/>`
 (note that, without any logic to interpret it, the metadata is effectively useless
@@ -655,10 +653,10 @@ the bean definition and sets up some caching infrastructure that uses the suppli



-[[xml-custom]]
+[[core.appendix.xml-custom]]
 == XML Schema Authoring

-[[xsd-custom-introduction]]
+[[core.appendix.xsd-custom-introduction]]
 Since version 2.0, Spring has featured a mechanism for adding schema-based extensions to the
 basic Spring XML format for defining and configuring beans. This section covers
 how to write your own custom XML bean definition parsers and
@@ -667,16 +665,16 @@ integrate such parsers into the Spring IoC container.
 To facilitate authoring configuration files that use a schema-aware XML editor,
 Spring's extensible XML configuration mechanism is based on XML Schema. If you are not
 familiar with Spring's current XML configuration extensions that come with the standard
-Spring distribution, you should first read the previous section on <<xsd-schemas>>.
+Spring distribution, you should first read the previous section on <<core.appendix.xsd-schemas>>.


 To create new XML configuration extensions:

-. <<xsd-custom-schema, Author>> an XML schema to describe your custom element(s).
-. <<xsd-custom-namespacehandler, Code>> a custom `NamespaceHandler` implementation.
-. <<xsd-custom-parser, Code>> one or more `BeanDefinitionParser` implementations
+. <<core.appendix.xsd-custom-schema, Author>> an XML schema to describe your custom element(s).
+. <<core.appendix.xsd-custom-namespacehandler, Code>> a custom `NamespaceHandler` implementation.
+. <<core.appendix.xsd-custom-parser, Code>> one or more `BeanDefinitionParser` implementations
  (this is where the real work is done).
-. <<xsd-custom-registration, Register>> your new artifacts with Spring.
+. <<core.appendix.xsd-custom-registration, Register>> your new artifacts with Spring.

 For a unified example, we create an
 XML extension (a custom XML element) that lets us configure objects of the type
@@ -696,7 +694,7 @@ through the basic steps of making a custom extension.)



-[[xsd-custom-schema]]
+[[core.appendix.xsd-custom-schema]]
 === Authoring the Schema

 Creating an XML configuration extension for use with Spring's IoC container starts with
@@ -752,7 +750,7 @@ essentially the same as the following XML snippet:
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<bean id="dateFormat" class="java.text.SimpleDateFormat">
-		<constructor-arg value="yyyy-HH-dd HH:mm"/>
+		<constructor-arg value="yyyy-MM-dd HH:mm"/>
 		<property name="lenient" value="true"/>
 	</bean>
 ----
@@ -768,7 +766,7 @@ defined in the enumeration.



-[[xsd-custom-namespacehandler]]
+[[core.appendix.xsd-custom-namespacehandler]]
 === Coding a `NamespaceHandler`

 In addition to the schema, we need a `NamespaceHandler` to parse all elements of
@@ -839,7 +837,7 @@ custom element, as we can see in the next step.



-[[xsd-custom-parser]]
+[[core.appendix.xsd-custom-parser]]
 === Using `BeanDefinitionParser`

 A `BeanDefinitionParser` is used if the `NamespaceHandler` encounters an XML
@@ -929,7 +927,7 @@ is the extraction and setting of the bean definition's unique identifier.



-[[xsd-custom-registration]]
+[[core.appendix.xsd-custom-registration]]
 === Registering the Handler and the Schema

 The coding is finished. All that remains to be done is to make the Spring XML
@@ -941,7 +939,7 @@ XML parsing infrastructure automatically picks up your new extension by consumin
 these special properties files, the formats of which are detailed in the next two sections.


-[[xsd-custom-registration-spring-handlers]]
+[[core.appendix.xsd-custom-registration-spring-handlers]]
 ==== Writing `META-INF/spring.handlers`

 The properties file called `spring.handlers` contains a mapping of XML Schema URIs to
@@ -960,7 +958,7 @@ namespace extension and needs to exactly match exactly the value of the `targetN
 attribute, as specified in your custom XSD schema.


-[[xsd-custom-registration-spring-schemas]]
+[[core.appendix.xsd-custom-registration-spring-schemas]]
 ==== Writing 'META-INF/spring.schemas'

 The properties file called `spring.schemas` contains a mapping of XML Schema locations
@@ -984,7 +982,7 @@ the `NamespaceHandler` and `BeanDefinitionParser` classes on the classpath.



-[[xsd-custom-using]]
+[[core.appendix.xsd-custom-using]]
 === Using a Custom Extension in Your Spring XML Configuration

 Using a custom extension that you yourself have implemented is no different from using
@@ -1018,13 +1016,13 @@ in a Spring XML configuration file:



-[[xsd-custom-meat]]
+[[core.appendix.xsd-custom-meat]]
 === More Detailed Examples

 This section presents some more detailed examples of custom XML extensions.


-[[xsd-custom-custom-nested]]
+[[core.appendix.xsd-custom-custom-nested]]
 ==== Nesting Custom Elements within Custom Elements

 The example presented in this section shows how you to write the various artifacts required
@@ -1198,7 +1196,7 @@ setter property for the `components` property. The following listing shows such

 This works nicely, but it exposes a lot of Spring plumbing to the end user. What we are
 going to do is write a custom extension that hides away all of this Spring plumbing.
-If we stick to <<xsd-custom-introduction, the steps described previously>>, we start off
+If we stick to <<core.appendix.xsd-custom-introduction, the steps described previously>>, we start off
 by creating the XSD schema to define the structure of our custom tag, as the following
 listing shows:

@@ -1225,7 +1223,7 @@ listing shows:
 	</xsd:schema>
 ----

-Again following <<xsd-custom-introduction, the process described earlier>>,
+Again following <<core.appendix.xsd-custom-introduction, the process described earlier>>,
 we then create a custom `NamespaceHandler`:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
@@ -1376,7 +1374,7 @@ http\://www.foo.example/schema/component/component.xsd=com/foo/component.xsd
 ----


-[[xsd-custom-custom-just-attributes]]
+[[core.appendix.xsd-custom-custom-just-attributes]]
 ==== Custom Attributes on "`Normal`" Elements

 Writing your own custom parser and the associated artifacts is not hard. However,
@@ -1613,7 +1611,7 @@ http\://www.foo.example/schema/jcache/jcache.xsd=com/foo/jcache.xsd
 ----


-[[application-startup-steps]]
+[[core.appendix.application-startup-steps]]
 == Application Startup Steps

 This part of the appendix lists the existing `StartupSteps` that the core container is instrumented with.
@@ -33,12 +33,12 @@ is a sub-interface of `BeanFactory`. It adds:
 * Application-layer specific contexts such as the `WebApplicationContext`
 for use in web applications.

-In short, the `BeanFactory` provides the configuration framework and basic
-functionality, and the `ApplicationContext` adds more enterprise-specific functionality.
-The `ApplicationContext` is a complete superset of the `BeanFactory` and is used
-exclusively in this chapter in descriptions of Spring's IoC container. For more
-information on using the `BeanFactory` instead of the `ApplicationContext,` see
-<<beans-beanfactory>>.
+In short, the `BeanFactory` provides the configuration framework and basic functionality,
+and the `ApplicationContext` adds more enterprise-specific functionality. The
+`ApplicationContext` is a complete superset of the `BeanFactory` and is used exclusively
+in this chapter in descriptions of Spring's IoC container. For more information on using
+the `BeanFactory` instead of the `ApplicationContext,` see the section covering the
+<<beans-beanfactory, `BeanFactory` API>>.

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

 [NOTE]
 ====
@@ -693,10 +693,11 @@ able to call this method (with optional arguments, as described later) and retur
 object, which subsequently is treated as if it had been created through a constructor.
 One use for such a bean definition is to call `static` factories in legacy code.

-The following bean definition specifies that the bean be created by calling a
+The following bean definition specifies that the bean will be created by calling a
 factory method. The definition does not specify the type (class) of the returned object,
-only the class containing the factory method. In this example, the `createInstance()`
-method must be a static method. The following example shows how to specify a factory method:
+but rather the class containing the factory method. In this example, the
+`createInstance()` method must be a `static` method. The following example shows how to
+specify a factory method:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -725,6 +726,7 @@ The following example shows a class that would work with the preceding bean defi
 	class ClientService private constructor() {
 		companion object {
 			private val clientService = ClientService()
+			@JvmStatic
 			fun createInstance() = clientService
 		}
 	}
@@ -1024,7 +1026,7 @@ by type without help. Consider the following class:

 	class ExampleBean(
 		private val years: Int, // Number of years to calculate the Ultimate Answer
-		private val ultimateAnswer: String// The Answer to Life, the Universe, and Everything
+		private val ultimateAnswer: String // The Answer to Life, the Universe, and Everything
 	)
 ----

@@ -1166,7 +1168,7 @@ load an entire Spring IoC container instance.
 ****
 Since you can mix constructor-based and setter-based DI, it is a good rule of thumb to
 use constructors for mandatory dependencies and setter methods or configuration methods
-for optional dependencies. Note that use of the <<beans-required-annotation, @Required>>
+for optional dependencies. Note that use of the <<beans-autowired-annotation, @Autowired>>
 annotation on a setter method can be used to make the property be a required dependency;
 however, constructor injection with programmatic validation of arguments is preferable.

@@ -1366,7 +1368,7 @@ The following example shows the corresponding `ExampleBean` class:
 		}
 	}
 ----
-[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 class ExampleBean(
@@ -1425,6 +1427,7 @@ The following example shows the corresponding `ExampleBean` class:
 			// a static factory method; the arguments to this method can be
 			// considered the dependencies of the bean that is returned,
 			// regardless of how those arguments are actually used.
+			@JvmStatic
 			fun createInstance(anotherBean: AnotherBean, yetAnotherBean: YetAnotherBean, i: Int): ExampleBean {
 				val eb = ExampleBean (...)
 				// some other operations...
@@ -1608,7 +1611,7 @@ listings shows how to use the `parent` attribute:
 ----
 	<!-- in the parent context -->
 	<bean id="accountService" class="com.something.SimpleAccountService">
-		<!-- insert dependencies as required as here -->
+		<!-- insert dependencies as required here -->
 	</bean>
 ----

@@ -1690,7 +1693,7 @@ respectively. The following example shows how to use them:
 		<property name="someMap">
 			<map>
 				<entry key="an entry" value="just some string"/>
-				<entry key ="a ref" value-ref="myDataSource"/>
+				<entry key="a ref" value-ref="myDataSource"/>
 			</map>
 		</property>
 		<!-- results in a setSomeSet(java.util.Set) call -->
@@ -1788,7 +1791,7 @@ a parent collection definition is redundant and does not result in the desired m
 [[beans-collection-elements-strongly-typed]]
 ===== Strongly-typed collection

-With the introduction of generic types in Java 5, you can use strongly typed collections.
+Thanks to Java's support for generic types, you can use strongly typed collections.
 That is, it is possible to declare a `Collection` type such that it can only contain
 (for example) `String` elements. If you use Spring to dependency-inject a
 strongly-typed `Collection` into a bean, you can take advantage of Spring's
@@ -1834,7 +1837,7 @@ class SomeClass {
 When the `accounts` property of the `something` bean is prepared for injection, the generics
 information about the element type of the strongly-typed `Map<String, Float>` is
 available by reflection. Thus, Spring's type conversion infrastructure recognizes the
-various value elements as being of type `Float`, and the string values (`9.99, 2.75`, and
+various value elements as being of type `Float`, and the string values (`9.99`, `2.75`, and
 `3.99`) are converted into an actual `Float` type.


@@ -1897,7 +1900,7 @@ The preceding configuration is equivalent to the following Java code:
 The p-namespace lets you use the `bean` element's attributes (instead of nested
 `<property/>` elements) to describe your property values collaborating beans, or both.

-Spring supports extensible configuration formats <<core.adoc#xsd-schemas,with namespaces>>,
+Spring supports extensible configuration formats <<core.adoc#core.appendix.xsd-schemas,with namespaces>>,
 which are based on an XML Schema definition. The `beans` configuration format discussed in
 this chapter is defined in an XML Schema document. However, the p-namespace is not defined
 in an XSD file and exists only in the core of Spring.
@@ -2028,7 +2031,7 @@ not commonly used since the plain order of declaration is usually sufficient the
 In practice, the constructor resolution
 <<beans-factory-ctor-arguments-resolution,mechanism>> is quite efficient in matching
 arguments, so unless you really need to, we recommend using the name notation
-through-out your configuration.
+throughout your configuration.


 [[beans-compound-property-names]]
@@ -2503,13 +2506,13 @@ declared return type of the lookup method:
 	public abstract class CommandManager {

 		public Object process(Object commandState) {
-			MyCommand command = createCommand();
+			Command command = createCommand();
 			command.setState(commandState);
 			return command.execute();
 		}

 		@Lookup
-		protected abstract MyCommand createCommand();
+		protected abstract Command createCommand();
 	}
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -2604,9 +2607,9 @@ interface provides the new method definition, as the following example shows:
 .Kotlin
 ----
 	/**
-	* meant to be used to override the existing computeValue(String)
-	* implementation in MyValueCalculator
-	*/
+	 * meant to be used to override the existing computeValue(String)
+	 * implementation in MyValueCalculator
+	 */
 	class ReplacementComputeValue : MethodReplacer {

 		override fun reimplement(obj: Any, method: Method, args: Array<out Any>): Any {
@@ -2806,7 +2809,7 @@ prototype-scoped bean repeatedly at runtime. You cannot dependency-inject a
 prototype-scoped bean into your singleton bean, because that injection occurs only
 once, when the Spring container instantiates the singleton bean and resolves
 and injects its dependencies. If you need a new instance of a prototype bean at
-runtime more than once, see <<beans-factory-method-injection>>
+runtime more than once, see <<beans-factory-method-injection>>.



@@ -2835,12 +2838,11 @@ If you access scoped beans within Spring Web MVC, in effect, within a request th
 processed by the Spring `DispatcherServlet`, no special setup is necessary.
 `DispatcherServlet` already exposes all relevant state.

-If you use a Servlet 2.5 web container, with requests processed outside of Spring's
+If you use a Servlet web container, with requests processed outside of Spring's
 `DispatcherServlet` (for example, when using JSF or Struts), you need to register the
 `org.springframework.web.context.request.RequestContextListener` `ServletRequestListener`.
-For Servlet 3.0+, this can be done programmatically by using the `WebApplicationInitializer`
-interface. Alternatively, or for older containers, add the following declaration to
-your web application's `web.xml` file:
+This can be done programmatically by using the `WebApplicationInitializer` interface.
+Alternatively, add the following declaration to your web application's `web.xml` file:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -2969,6 +2971,8 @@ When using annotation-driven components or Java configuration, you can use the
 ----


+
+
 [[beans-factory-scopes-application]]
 ==== Application Scope

@@ -2984,7 +2988,7 @@ The Spring container creates a new instance of the `AppPreferences` bean by usin
 `appPreferences` bean is scoped at the `ServletContext` level and stored as a regular
 `ServletContext` attribute. This is somewhat similar to a Spring singleton bean but
 differs in two important ways: It is a singleton per `ServletContext`, not per Spring
-'ApplicationContext' (for which there may be several in any given web application),
+`ApplicationContext` (for which there may be several in any given web application),
 and it is actually exposed and therefore visible as a `ServletContext` attribute.

 When using annotation-driven components or Java configuration, you can use the
@@ -3012,6 +3016,17 @@ following example shows how to do so:



+
+[[beans-factory-scopes-websocket]]
+==== WebSocket Scope
+
+WebSocket scope is associated with the lifecycle of a WebSocket session and applies to
+STOMP over WebSocket applications, see
+<<web.adoc#websocket-stomp-websocket-scope,WebSocket scope>> for more details.
+
+
+
+
 [[beans-factory-scopes-other-injection]]
 ==== Scoped Beans as Dependencies

@@ -3039,7 +3054,7 @@ constructor or setter argument or autowired field) as `ObjectFactory<MyTargetBea
 allowing for a `getObject()` call to retrieve the current instance on demand every
 time it is needed -- without holding on to the instance or storing it separately.

-As an extended variant, you may declare `ObjectProvider<MyTargetBean>`, which delivers
+As an extended variant, you may declare `ObjectProvider<MyTargetBean>` which delivers
 several additional access variants, including `getIfAvailable` and `getIfUnique`.

 The JSR-330 variant of this is called `Provider` and is used with a `Provider<MyTargetBean>`
@@ -3079,7 +3094,7 @@ understand the "`why`" as well as the "`how`" behind it:

 To create such a proxy, you insert a child `<aop:scoped-proxy/>` element into a scoped
 bean definition (see <<beans-factory-scopes-other-injection-proxies>> and
-<<core.adoc#xsd-schemas, XML Schema-based configuration>>).
+<<core.adoc#core.appendix.xsd-schemas, XML Schema-based configuration>>).
 Why do definitions of beans scoped at the `request`, `session` and custom-scope
 levels require the `<aop:scoped-proxy/>` element?
 Consider the following singleton bean definition and contrast it with
@@ -3100,7 +3115,7 @@ to the HTTP `Session`-scoped bean (`userPreferences`). The salient point here is
 `userManager` bean is a singleton: it is instantiated exactly once per
 container, and its dependencies (in this case only one, the `userPreferences` bean) are
 also injected only once. This means that the `userManager` bean operates only on the
-exact same `userPreferences` object (that is, the one with which it was originally injected.
+exact same `userPreferences` object (that is, the one with which it was originally injected).

 This is not the behavior you want when injecting a shorter-lived scoped bean into a
 longer-lived scoped bean (for example, injecting an HTTP `Session`-scoped collaborating
@@ -3928,7 +3943,7 @@ shows the definition of the BeanNameAware interface:
 ----

 The callback is invoked after population of normal bean properties but before an
-initialization callback such as `InitializingBean`, `afterPropertiesSet`, or a custom
+initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom
 init-method.


@@ -3960,7 +3975,7 @@ dependency type. The following table summarizes the most important `Aware` inter

 | `BeanFactoryAware`
 | Declaring `BeanFactory`.
-| <<beans-factory-aware>>
+| <<beans-beanfactory>>

 | `BeanNameAware`
 | Name of the declaring bean.
@@ -4142,7 +4157,7 @@ or it may wrap a bean with a proxy. Some Spring AOP infrastructure classes are
 implemented as bean post-processors in order to provide proxy-wrapping logic.

 An `ApplicationContext` automatically detects any beans that are defined in the
-configuration metadata that implements the `BeanPostProcessor` interface. The
+configuration metadata that implement the `BeanPostProcessor` interface. The
 `ApplicationContext` registers these beans as post-processors so that they can be called
 later, upon bean creation. Bean post-processors can be deployed in the container in the
 same fashion as any other beans.
@@ -4585,22 +4600,21 @@ source code and that, in terms of tooling, all configuration styles are supporte
 https://spring.io/tools[Spring Tools for Eclipse].
 ****

-An alternative to XML setup is provided by annotation-based configuration, which relies on
-the bytecode metadata for wiring up components instead of angle-bracket declarations.
+An alternative to XML setup is provided by annotation-based configuration, which relies
+on the bytecode metadata for wiring up components instead of angle-bracket declarations.
 Instead of using XML to describe a bean wiring, the developer moves the configuration
 into the component class itself by using annotations on the relevant class, method, or
 field declaration. As mentioned in <<beans-factory-extension-bpp-examples-aabpp>>, using
 a `BeanPostProcessor` in conjunction with annotations is a common means of extending the
-Spring IoC container. For example, Spring 2.0 introduced the possibility of enforcing
-required properties with the <<beans-required-annotation,`@Required`>> annotation. Spring
-2.5 made it possible to follow that same general approach to drive Spring's dependency
-injection. Essentially, the `@Autowired` annotation provides the same capabilities as
-described in <<beans-factory-autowire>> but with more fine-grained control and wider
-applicability. Spring 2.5 also added support for JSR-250 annotations, such as
-`@PostConstruct` and `@PreDestroy`. Spring 3.0 added support for JSR-330 (Dependency
-Injection for Java) annotations contained in the `javax.inject` package such as `@Inject`
-and `@Named`. Details about those annotations can be found in the
-<<beans-standard-annotations,relevant section>>.
+Spring IoC container. For example, Spring 2.5 introduced an annotation-based approach to
+drive Spring's dependency injection. Essentially, the <<beans-autowired-annotation,
+`@Autowired`>> annotation provides the same capabilities as described in
+<<beans-factory-autowire>> but with more fine-grained control and wider applicability.
+Spring 2.5 also added support for JSR-250 annotations, such as `@PostConstruct` and
+`@PreDestroy`. Spring 3.0 added support for JSR-330 (Dependency Injection for Java)
+annotations contained in the `jakarta.inject` package such as `@Inject` and `@Named`.
+Details about those annotations can be found in the <<beans-standard-annotations,
+relevant section>>.

 [NOTE]
 ====
@@ -4647,63 +4661,6 @@ it only checks for `@Autowired` beans in your controllers, and not your services



-[[beans-required-annotation]]
-=== @Required
-
-The `@Required` annotation applies to bean property setter methods, as in the following
-example:
-
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
----
-	public class SimpleMovieLister {
-
-		private MovieFinder movieFinder;
-
-		@Required
-		public void setMovieFinder(MovieFinder movieFinder) {
-			this.movieFinder = movieFinder;
-		}
-
-		// ...
-	}
----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	class SimpleMovieLister {
-
-	@Required
-	lateinit var movieFinder: MovieFinder
-
-	// ...
-}
----
-
-This annotation indicates that the affected bean property must be populated at
-configuration time, through an explicit property value in a bean definition or through
-autowiring. The container throws an exception if the affected bean property has not been
-populated. This allows for eager and explicit failure, avoiding `NullPointerException`
-instances or the like later on. We still recommend that you put assertions into the
-bean class itself (for example, into an init method). Doing so enforces those required
-references and values even when you use the class outside of a container.
-
-[TIP]
-====
-The {api-spring-framework}/beans/factory/annotation/RequiredAnnotationBeanPostProcessor.html[`RequiredAnnotationBeanPostProcessor`]
-must be registered as a bean to enable support for the `@Required` annotation.
-====
-
-[NOTE]
-====
-The `@Required` annotation and `RequiredAnnotationBeanPostProcessor` are formally
-deprecated as of Spring Framework 5.1, in favor of using constructor injection for
-required settings (or a custom implementation of `InitializingBean.afterPropertiesSet()`
-or a custom `@PostConstruct` method along with bean property setter methods).
-====
-
-
-
 [[beans-autowired-annotation]]
 === Using `@Autowired`

@@ -4770,7 +4727,7 @@ as the following example shows:
 ----
 	class SimpleMovieLister {

-		@Autowired
+		@set:Autowired
 		lateinit var movieFinder: MovieFinder

 		// ...
@@ -4938,7 +4895,7 @@ use the same bean class). `@Order` values may influence priorities at injection
 but be aware that they do not influence singleton startup order, which is an
 orthogonal concern determined by dependency relationships and `@DependsOn` declarations.

-Note that the standard `javax.annotation.Priority` annotation is not available at the
+Note that the standard `jakarta.annotation.Priority` annotation is not available at the
 `@Bean` level, since it cannot be declared on methods. Its semantics can be modeled
 through `@Order` values in combination with `@Primary` on a single bean for each type.
 ====
@@ -5010,10 +4967,19 @@ non-required (i.e., by setting the `required` attribute in `@Autowired` to `fals
 	}
 ----

+[NOTE]
+====
 A non-required method will not be called at all if its dependency (or one of its
 dependencies, in case of multiple arguments) is not available. A non-required field will
 not get populated at all in such cases, leaving its default value in place.

+In other words, setting the `required` attribute to `false` indicates that the
+corresponding property is _optional_ for autowiring purposes, and the property will be
+ignored if it cannot be autowired. This allows properties to be assigned default values
+that can be optionally overridden via dependency injection.
+====
+
+
 [[beans-autowired-annotation-constructor-resolution]]

 Injected constructor and factory method arguments are a special case since the `required`
@@ -5041,13 +5007,6 @@ declares multiple constructors but none of them is annotated with `@Autowired`,
 primary/default constructor (if present) will be used. If a class only declares a single
 constructor to begin with, it will always be used, even if not annotated. Note that an
 annotated constructor does not have to be public.
-
-The `required` attribute of `@Autowired` is recommended over the deprecated `@Required`
-annotation on setter methods. Setting the `required` attribute to `false` indicates that
-the property is not required for autowiring purposes, and the property is ignored if it
-cannot be autowired. `@Required`, on the other hand, is stronger in that it enforces the
-property to be set by any means supported by the container, and if no value is defined,
-a corresponding exception is raised.
 ====

 Alternatively, you can express the non-required nature of a particular dependency
@@ -5373,7 +5332,7 @@ Letting qualifier values select against target bean names, within the type-match
 candidates, does not require a `@Qualifier` annotation at the injection point.
 If there is no other resolution indicator (such as a qualifier or a primary marker),
 for a non-unique dependency situation, Spring matches the injection point name
-(that is, the field name or parameter name) against the target bean names and choose the
+(that is, the field name or parameter name) against the target bean names and chooses the
 same-named candidate, if any.
 ====

@@ -5388,7 +5347,7 @@ matching an `account` qualifier against beans marked with the same qualifier lab

 For beans that are themselves defined as a collection, `Map`, or array type, `@Resource`
 is a fine solution, referring to the specific collection or array bean by unique name.
-That said, as of 4.3, collection, you can match `Map`, and array types through Spring's
+That said, as of 4.3, you can match collection, `Map`, and array types through Spring's
 `@Autowired` type matching algorithm as well, as long as the element type information
 is preserved in `@Bean` return type signatures or collection inheritance hierarchies.
 In this case, you can use qualifier values to select among same-typed collections,
@@ -5863,8 +5822,8 @@ attribute set to `true`, it is selected.
 === Injection with `@Resource`

 Spring also supports injection by using the JSR-250 `@Resource` annotation
-(`javax.annotation.Resource`) on fields or bean property setter methods.
-This is a common pattern in Java EE: for example, in JSF-managed beans and JAX-WS
+(`jakarta.annotation.Resource`) on fields or bean property setter methods.
+This is a common pattern in Jakarta EE: for example, in JSF-managed beans and JAX-WS
 endpoints. Spring supports this pattern for Spring-managed objects as well.

 `@Resource` takes a name attribute. By default, Spring interprets that value as
@@ -5921,7 +5880,7 @@ named `movieFinder` injected into its setter method:
 ----
 	class SimpleMovieLister {

-		@Resource
+		@set:Resource
 		private lateinit var movieFinder: MovieFinder

 	}
@@ -6042,14 +6001,14 @@ example shows:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-    @Configuration
-    public class AppConfig {
+	@Configuration
+	public class AppConfig {

-         @Bean
-         public static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
-               return new PropertySourcesPlaceholderConfigurer();
-         }
-    }
+		@Bean
+		public static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
+			return new PropertySourcesPlaceholderConfigurer();
+		}
+	}
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
@@ -6075,7 +6034,7 @@ will get properties from `application.properties` and `application.yml` files.

 Built-in converter support provided by Spring allows simple type conversion (to `Integer`
 or `int` for example) to be automatically handled. Multiple comma-separated values can be
-automatically converted to String array without extra effort.
+automatically converted to `String` array without extra effort.

 It is possible to provide a default value as following:

@@ -6099,8 +6058,8 @@ It is possible to provide a default value as following:
 	class MovieRecommender(@Value("\${catalog.name:defaultCatalog}") private val catalog: String)
 ----

-A Spring `BeanPostProcessor` uses a `ConversionService` behind the scene to handle the
-process for converting the String value in `@Value` to the target type. If you want to
+A Spring `BeanPostProcessor` uses a `ConversionService` behind the scenes to handle the
+process for converting the `String` value in `@Value` to the target type. If you want to
 provide conversion support for your own custom type, you can provide your own
 `ConversionService` bean instance as the following example shows:

@@ -6126,7 +6085,7 @@ provide conversion support for your own custom type, you can provide your own

 		@Bean
 		fun conversionService(): ConversionService {
-				return DefaultFormattingConversionService().apply {
+			return DefaultFormattingConversionService().apply {
 				addConverter(MyCustomConverter())
 			}
 		}
@@ -6186,8 +6145,8 @@ SpEL also enables the use of more complex data structures:
 === Using `@PostConstruct` and `@PreDestroy`

 The `CommonAnnotationBeanPostProcessor` not only recognizes the `@Resource` annotation
-but also the JSR-250 lifecycle annotations: `javax.annotation.PostConstruct` and
-`javax.annotation.PreDestroy`. Introduced in Spring 2.5, the support for these
+but also the JSR-250 lifecycle annotations: `jakarta.annotation.PostConstruct` and
+`jakarta.annotation.PreDestroy`. Introduced in Spring 2.5, the support for these
 annotations offers an alternative to the lifecycle callback mechanism described in
 <<beans-factory-lifecycle-initializingbean,initialization callbacks>> and
 <<beans-factory-lifecycle-disposablebean,destruction callbacks>>. Provided that the
@@ -6238,8 +6197,9 @@ For details about the effects of combining various lifecycle mechanisms, see
 Like `@Resource`, the `@PostConstruct` and `@PreDestroy` annotation types were a part
 of the standard Java libraries from JDK 6 to 8. However, the entire `javax.annotation`
 package got separated from the core Java modules in JDK 9 and eventually removed in
-JDK 11. If needed, the `javax.annotation-api` artifact needs to be obtained via Maven
-Central now, simply to be added to the application's classpath like any other library.
+JDK 11. As of Jakarta EE 9, the package lives in `jakarta.annotation` now. If needed,
+the `jakarta.annotation-api` artifact needs to be obtained via Maven Central now,
+simply to be added to the application's classpath like any other library.
 ====


@@ -6315,7 +6275,7 @@ is meta-annotated with `@Component`, as the following example shows:
 		// ...
 	}
 ----
-<1> The `Component` causes `@Service` to be treated in the same way as `@Component`.
+<1> The `@Component` causes `@Service` to be treated in the same way as `@Component`.

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
@@ -6329,7 +6289,7 @@ is meta-annotated with `@Component`, as the following example shows:
 		// ...
 	}
 ----
-<1> The `Component` causes `@Service` to be treated in the same way as `@Component`.
+<1> The `@Component` causes `@Service` to be treated in the same way as `@Component`.

 You can also combine meta-annotations to create "`composed annotations`". For example,
 the `@RestController` annotation from Spring MVC is composed of `@Controller` and
@@ -6591,14 +6551,14 @@ and using "`stub`" repositories instead:
 			includeFilters = @Filter(type = FilterType.REGEX, pattern = ".*Stub.*Repository"),
 			excludeFilters = @Filter(Repository.class))
 	public class AppConfig {
-		...
+		// ...
 	}
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	@Configuration
-	@ComponentScan(basePackages = "org.example",
+	@ComponentScan(basePackages = ["org.example"],
 			includeFilters = [Filter(type = FilterType.REGEX, pattern = [".*Stub.*Repository"])],
 			excludeFilters = [Filter(Repository::class)])
 	class AppConfig {
@@ -6675,9 +6635,11 @@ factory method and other bean definition properties, such as a qualifier value t
 the `@Qualifier` annotation. Other method-level annotations that can be specified are
 `@Scope`, `@Lazy`, and custom qualifier annotations.

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

 Autowired fields and methods are supported, as previously discussed, with additional
 support for autowiring of `@Bean` methods. The following example shows how to do so:
@@ -7157,7 +7119,7 @@ configuration, as shown in the following example:
 With Gradle 4.6 and later, the dependency should be declared in the `annotationProcessor`
 configuration, as shown in the following example:

-[source,groovy,indent=0subs="verbatim,quotes,attributes"]
+[source,groovy,indent=0,subs="verbatim,quotes,attributes"]
 ----
 	dependencies {
 		annotationProcessor "org.springframework:spring-context-indexer:{spring-version}"
@@ -7190,16 +7152,16 @@ annotations. To use them, you need to have the relevant jars in your classpath.

 [NOTE]
 =====
-If you use Maven, the `javax.inject` artifact is available in the standard Maven
+If you use Maven, the `jakarta.inject` artifact is available in the standard Maven
 repository (
-https://repo1.maven.org/maven2/javax/inject/javax.inject/1/[https://repo1.maven.org/maven2/javax/inject/javax.inject/1/]).
+https://repo1.maven.org/maven2/jakarta/inject/jakarta.inject-api/2.0.0/[https://repo1.maven.org/maven2/jakarta/inject/jakarta.inject-api/2.0.0/]).
 You can add the following dependency to your file pom.xml:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<dependency>
-		<groupId>javax.inject</groupId>
-		<artifactId>javax.inject</artifactId>
+		<groupId>jakarta.inject</groupId>
+		<artifactId>jakarta.inject-api</artifactId>
 		<version>1</version>
 	</dependency>
 ----
@@ -7210,12 +7172,12 @@ You can add the following dependency to your file pom.xml:
 [[beans-inject-named]]
 === Dependency Injection with `@Inject` and `@Named`

-Instead of `@Autowired`, you can use `@javax.inject.Inject` as follows:
+Instead of `@Autowired`, you can use `@jakarta.inject.Inject` as follows:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	import javax.inject.Inject;
+	import jakarta.inject.Inject;

 	public class SimpleMovieLister {

@@ -7235,7 +7197,7 @@ Instead of `@Autowired`, you can use `@javax.inject.Inject` as follows:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	import javax.inject.Inject
+	import jakarta.inject.Inject

 	class SimpleMovieLister {

@@ -7259,8 +7221,8 @@ preceding example:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	import javax.inject.Inject;
-	import javax.inject.Provider;
+	import jakarta.inject.Inject;
+	import jakarta.inject.Provider;

 	public class SimpleMovieLister {

@@ -7280,16 +7242,16 @@ preceding example:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	import javax.inject.Inject
+	import jakarta.inject.Inject

 	class SimpleMovieLister {

 		@Inject
-		lateinit var movieFinder: MovieFinder
+		lateinit var movieFinder: Provider<MovieFinder>


 		fun listMovies() {
-			movieFinder.findMovies(...)
+			movieFinder.get().findMovies(...)
 			// ...
 		}
 	}
@@ -7301,8 +7263,8 @@ you should use the `@Named` annotation, as the following example shows:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	import javax.inject.Inject;
-	import javax.inject.Named;
+	import jakarta.inject.Inject;
+	import jakarta.inject.Named;

 	public class SimpleMovieLister {

@@ -7319,8 +7281,8 @@ you should use the `@Named` annotation, as the following example shows:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	import javax.inject.Inject
-	import javax.inject.Named
+	import jakarta.inject.Inject
+	import jakarta.inject.Named

 	class SimpleMovieLister {

@@ -7377,14 +7339,14 @@ a `required` attribute. The following pair of examples show how to use `@Inject`
 [[beans-named]]
 === `@Named` and `@ManagedBean`: Standard Equivalents to the `@Component` Annotation

-Instead of `@Component`, you can use `@javax.inject.Named` or `javax.annotation.ManagedBean`,
+Instead of `@Component`, you can use `@jakarta.inject.Named` or `jakarta.annotation.ManagedBean`,
 as the following example shows:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	import javax.inject.Inject;
-	import javax.inject.Named;
+	import jakarta.inject.Inject;
+	import jakarta.inject.Named;

 	@Named("movieListener")  // @ManagedBean("movieListener") could be used as well
 	public class SimpleMovieLister {
@@ -7402,8 +7364,8 @@ as the following example shows:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	import javax.inject.Inject
-	import javax.inject.Named
+	import jakarta.inject.Inject
+	import jakarta.inject.Named

 	@Named("movieListener")  // @ManagedBean("movieListener") could be used as well
 	class SimpleMovieLister {
@@ -7421,8 +7383,8 @@ It is very common to use `@Component` without specifying a name for the componen
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	import javax.inject.Inject;
-	import javax.inject.Named;
+	import jakarta.inject.Inject;
+	import jakarta.inject.Named;

 	@Named
 	public class SimpleMovieLister {
@@ -7440,8 +7402,8 @@ It is very common to use `@Component` without specifying a name for the componen
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	import javax.inject.Inject
-	import javax.inject.Named
+	import jakarta.inject.Inject
+	import jakarta.inject.Named

 	@Named
 	class SimpleMovieLister {
@@ -7475,7 +7437,7 @@ exact same way as when you use Spring annotations, as the following example show
 	}
 ----

-NOTE: In contrast to `@Component`, the JSR-330 `@Named` and the JSR-250 `ManagedBean`
+NOTE: In contrast to `@Component`, the JSR-330 `@Named` and the JSR-250 `@ManagedBean`
 annotations are not composable. You should use Spring's stereotype model for building
 custom component annotations.

@@ -7490,7 +7452,7 @@ features are not available, as the following table shows:
 [[annotations-comparison]]
 .Spring component model elements versus JSR-330 variants
 |===
-| Spring| javax.inject.*| javax.inject restrictions / comments
+| Spring| jakarta.inject.*| jakarta.inject restrictions / comments

 | @Autowired
 | @Inject
@@ -7505,31 +7467,27 @@ features are not available, as the following table shows:
 | The JSR-330 default scope is like Spring's `prototype`. However, in order to keep it
  consistent with Spring's general defaults, a JSR-330 bean declared in the Spring
  container is a `singleton` by default. In order to use a scope other than `singleton`,
-  you should use Spring's `@Scope` annotation. `javax.inject` also provides a
-  https://download.oracle.com/javaee/6/api/javax/inject/Scope.html[@Scope] annotation.
-  Nevertheless, this one is only intended to be used for creating your own annotations.
+  you should use Spring's `@Scope` annotation. `jakarta.inject` also provides a
+  `jakarta.inject.Scope` annotation: however, this one is only intended to be used
+  for creating custom annotations.

 | @Qualifier
 | @Qualifier / @Named
-| `javax.inject.Qualifier` is just a meta-annotation for building custom qualifiers.
+| `jakarta.inject.Qualifier` is just a meta-annotation for building custom qualifiers.
  Concrete `String` qualifiers (like Spring's `@Qualifier` with a value) can be associated
-  through `javax.inject.Named`.
+  through `jakarta.inject.Named`.

 | @Value
 | -
 | no equivalent

-| @Required
-| -
-| no equivalent
-
 | @Lazy
 | -
 | no equivalent

 | ObjectFactory
 | Provider
-| `javax.inject.Provider` is a direct alternative to Spring's `ObjectFactory`,
+| `jakarta.inject.Provider` is a direct alternative to Spring's `ObjectFactory`,
  only with a shorter `get()` method name. It can also be used in combination with
  Spring's `@Autowired` or with non-annotated constructors and setter methods.
 |===
@@ -7631,7 +7589,7 @@ to reduce subtle bugs that can be hard to track down when operating in "`lite`"
 ****

 The `@Bean` and `@Configuration` annotations are discussed in depth in the following sections.
-First, however, we cover the various ways of creating a spring container using by
+First, however, we cover the various ways of creating a spring container by using
 Java-based configuration.


@@ -7758,7 +7716,7 @@ To enable component scanning, you can annotate your `@Configuration` class as fo
 	@Configuration
 	@ComponentScan(basePackages = "com.acme") // <1>
 	public class AppConfig  {
-		...
+		// ...
 	}
 ----
 <1> This annotation enables component scanning.
@@ -7885,6 +7843,10 @@ init-param):
 	</web-app>
 ----

+NOTE: For programmatic use cases, a `GenericWebApplicationContext` can be used as an
+alternative to `AnnotationConfigWebApplicationContext`. See the
+{api-spring-framework}/web/context/support/GenericWebApplicationContext.html[`GenericWebApplicationContext`]
+javadoc for details.


 [[beans-java-bean-annotation]]
@@ -7892,6 +7854,7 @@ init-param):

 `@Bean` is a method-level annotation and a direct analog of the XML `<bean/>` element.
 The annotation supports some of the attributes offered by `<bean/>`, such as:
+
 * <<beans-factory-lifecycle-initializingbean, init-method>>
 * <<beans-factory-lifecycle-disposablebean, destroy-method>>
 * <<beans-factory-autowire,autowiring>>
@@ -7950,6 +7913,26 @@ following text image shows:
 transferService -> com.acme.TransferServiceImpl
 ----

+You can also use default methods to define beans. This allows composition of bean
+configurations by implementing interfaces with bean definitions on default methods.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	public interface BaseConfig {
+
+		@Bean
+		default TransferServiceImpl transferService() {
+			return new TransferServiceImpl();
+		}
+	}
+
+	@Configuration
+	public class AppConfig implements BaseConfig {
+
+	}
+----
+
 You can also declare your `@Bean` method with an interface (or base class)
 return type, as the following example shows:

@@ -7980,7 +7963,7 @@ return type, as the following example shows:

 However, this limits the visibility for advance type prediction to the specified
 interface type (`TransferService`). Then, with the full type (`TransferServiceImpl`)
-known to the container only once, the affected singleton bean has been instantiated.
+known to the container only once the affected singleton bean has been instantiated.
 Non-lazy singleton beans get instantiated according to their declaration order,
 so you may see different type matching results depending on when another component
 tries to match by a non-declared type (such as `@Autowired TransferServiceImpl`,
@@ -8121,7 +8104,7 @@ default `(inferred)` mode.

 You may want to do that by default for a resource that you acquire with JNDI, as its
 lifecycle is managed outside the application. In particular, make sure to always do it
-for a `DataSource`, as it is known to be problematic on Java EE application servers.
+for a `DataSource`, as it is known to be problematic on Jakarta EE application servers.

 The following example shows how to prevent an automatic destruction callback for a
 `DataSource`:
@@ -8295,7 +8278,7 @@ as the following example shows:
 	@Configuration
 	public class AppConfig {

-		@Bean(name = "myThing")
+		@Bean("myThing")
 		public Thing thing() {
 			return new Thing();
 		}
@@ -8388,7 +8371,7 @@ annotation, as the following example shows:
 === Using the `@Configuration` annotation

 `@Configuration` is a class-level annotation indicating that an object is a source of
-bean definitions. `@Configuration` classes declare beans through `@Bean` annotated
+bean definitions. `@Configuration` classes declare beans through `@Bean`-annotated
 methods. Calls to `@Bean` methods on `@Configuration` classes can also be used to define
 inter-bean dependencies. See <<beans-java-basic-concepts>> for a general introduction.

@@ -9137,7 +9120,7 @@ method that returns `true` or `false`. For example, the following listing shows
 		val attrs = metadata.getAllAnnotationAttributes(Profile::class.java.name)
 		if (attrs != null) {
 			for (value in attrs["value"]!!) {
-				if (context.environment.acceptsProfiles(Profiles .of(*value as Array<String>))) {
+				if (context.environment.acceptsProfiles(Profiles.of(*value as Array<String>))) {
 					return true
 				}
 			}
@@ -9280,7 +9263,7 @@ is not strictly required.
 --
 Because `@Configuration` is meta-annotated with `@Component`, `@Configuration`-annotated
 classes are automatically candidates for component scanning. Using the same scenario as
-describe in the previous example, we can redefine `system-test-config.xml` to take advantage of component-scanning.
+described in the previous example, we can redefine `system-test-config.xml` to take advantage of component-scanning.
 Note that, in this case, we need not explicitly declare
 `<context:annotation-config/>`, because `<context:component-scan/>` enables the same
 functionality.
@@ -9611,7 +9594,7 @@ of creating a custom composed annotation. The following example defines a custom
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	@Target(AnnotationTarget.TYPE)
+	@Target(AnnotationTarget.CLASS)
 	@Retention(AnnotationRetention.RUNTIME)
 	@Profile("production")
 	annotation class Production
@@ -9901,7 +9884,7 @@ as a way to provide a default definition for one or more beans. If any
 profile is enabled, the default profile does not apply.

 You can change the name of the default profile by using `setDefaultProfiles()` on
-the `Environment` or ,declaratively, by using the `spring.profiles.default` property.
+the `Environment` or, declaratively, by using the `spring.profiles.default` property.



@@ -9939,9 +9922,9 @@ is configured with two PropertySource objects -- one representing the set of JVM

 NOTE: These default property sources are present for `StandardEnvironment`, for use in standalone
 applications. {api-spring-framework}/web/context/support/StandardServletEnvironment.html[`StandardServletEnvironment`]
-is populated with additional default property sources including servlet config and servlet
-context parameters. It can optionally enable a {api-spring-framework}/jndi/JndiPropertySource.html[`JndiPropertySource`].
-See the javadoc for details.
+is populated with additional default property sources including servlet config, servlet
+context parameters, and a {api-spring-framework}/jndi/JndiPropertySource.html[`JndiPropertySource`]
+if JNDI is available.

 Concretely, when you use the `StandardEnvironment`, the call to `env.containsProperty("my-property")`
 returns true if a `my-property` system property or `my-property` environment variable is present at
@@ -10175,7 +10158,7 @@ interfaces to provide additional functionality in a more application
 framework-oriented style. Many people use the `ApplicationContext` in a completely
 declarative fashion, not even creating it programmatically, but instead relying on
 support classes such as `ContextLoader` to automatically instantiate an
-`ApplicationContext` as part of the normal startup process of a Java EE web application.
+`ApplicationContext` as part of the normal startup process of a Jakarta EE web application.

 To enhance `BeanFactory` functionality in a more framework-oriented style, the context
 package also provides the following functionality:
@@ -10406,6 +10389,10 @@ You can also use the `MessageSourceAware` interface to acquire a reference to an
 `ApplicationContext` that implements the `MessageSourceAware` interface is injected with
 the application context's `MessageSource` when the bean is created and configured.

+NOTE: Because Spring's `MessageSource` is based on Java's `ResourceBundle`, it does not merge
+bundles with the same base name, but will only use the first bundle found.
+Subsequent message bundles with the same base name are ignored.
+
 NOTE: As an alternative to `ResourceBundleMessageSource`, Spring provides a
 `ReloadableResourceBundleMessageSource` class. This variant supports the same bundle
 file format but is more flexible than the standard JDK based
@@ -10595,7 +10582,7 @@ shows such a class:
 ----
 	class BlockedListNotifier : ApplicationListener<BlockedListEvent> {

-		lateinit var notificationAddres: String
+		lateinit var notificationAddress: String

 		override fun onApplicationEvent(event: BlockedListEvent) {
 			// notify appropriate parties via notificationAddress...
@@ -10716,7 +10703,7 @@ following example shows how to do so:
 ----

 It is also possible to add additional runtime filtering by using the `condition` attribute
-of the annotation that defines a <<expressions, `SpEL` expression>> , which should match
+of the annotation that defines a <<expressions, `SpEL` expression>>, which should match
 to actually invoke the method for a particular event.

 The following example shows how our notifier can be rewritten to be invoked only if the
@@ -10828,10 +10815,12 @@ The following example shows how to do so:
 Be aware of the following limitations when using asynchronous events:

 * If an asynchronous event listener throws an `Exception`, it is not propagated to the
-  caller. See `AsyncUncaughtExceptionHandler` for more details.
+  caller. See
+  {api-spring-framework}/aop/interceptor/AsyncUncaughtExceptionHandler.html[`AsyncUncaughtExceptionHandler`]
+  for more details.
 * Asynchronous event listener methods cannot publish a subsequent event by returning a
  value. If you need to publish another event as the result of the processing, inject an
-  {api-spring-framework}/aop/interceptor/AsyncUncaughtExceptionHandler.html[`ApplicationEventPublisher`]
+  {api-spring-framework}/context/ApplicationEventPublisher.html[`ApplicationEventPublisher`]
  to publish the event manually.


@@ -11006,7 +10995,7 @@ Here is an example of instrumentation in the `AnnotationConfigApplicationContext
 The application context is already instrumented with multiple steps.
 Once recorded, these startup steps can be collected, displayed and analyzed with specific tools.
 For a complete list of existing startup steps, you can check out the
-<<application-startup-steps, dedicated appendix section>>.
+<<core.appendix.application-startup-steps, dedicated appendix section>>.

 The default `ApplicationStartup` implementation is a no-op variant, for minimal overhead.
 This means no metrics will be collected during application startup by default.
@@ -11062,15 +11051,15 @@ Examples are `/WEB-INF/{asterisk}Context.xml` (for all files with names that end


 [[context-deploy-rar]]
-=== Deploying a Spring `ApplicationContext` as a Java EE RAR File
+=== Deploying a Spring `ApplicationContext` as a Jakarta EE RAR File

 It is possible to deploy a Spring `ApplicationContext` as a RAR file, encapsulating the
-context and all of its required bean classes and library JARs in a Java EE RAR deployment
+context and all of its required bean classes and library JARs in a Jakarta EE RAR deployment
 unit. This is the equivalent of bootstrapping a stand-alone `ApplicationContext` (only hosted
-in Java EE environment) being able to access the Java EE servers facilities. RAR deployment
+in Jakarta EE environment) being able to access the Jakarta EE servers facilities. RAR deployment
 is a more natural alternative to a scenario of deploying a headless WAR file -- in effect,
 a WAR file without any HTTP entry points that is used only for bootstrapping a Spring
-`ApplicationContext` in a Java EE environment.
+`ApplicationContext` in a Jakarta EE environment.

 RAR deployment is ideal for application contexts that do not need HTTP entry points but
 rather consist only of message endpoints and scheduled jobs. Beans in such a context can
@@ -11084,13 +11073,13 @@ See the javadoc of the
 {api-spring-framework}/jca/context/SpringContextResourceAdapter.html[`SpringContextResourceAdapter`]
 class for the configuration details involved in RAR deployment.

-For a simple deployment of a Spring ApplicationContext as a Java EE RAR file:
+For a simple deployment of a Spring ApplicationContext as a Jakarta EE RAR file:

 . Package
 all application classes into a RAR file (which is a standard JAR file with a different
 file extension).
-.Add all required library JARs into the root of the RAR archive.
-.Add a
+. Add all required library JARs into the root of the RAR archive.
+. Add a
 `META-INF/ra.xml` deployment descriptor (as shown in the {api-spring-framework}/jca/context/SpringContextResourceAdapter.html[javadoc for `SpringContextResourceAdapter`])
 and the corresponding Spring XML bean definition file(s) (typically
 `META-INF/applicationContext.xml`).
@@ -11109,7 +11098,7 @@ by other application modules on the same machine.


 [[beans-beanfactory]]
-== The `BeanFactory`
+== The `BeanFactory` API

 The `BeanFactory` API provides the underlying basis for Spring's IoC functionality.
 Its specific contracts are mostly used in integration with other parts of Spring and
@@ -11184,7 +11173,7 @@ The following table lists features provided by the `BeanFactory` and
 | No
 | Yes

-| Convenient `MessageSource` access (for internalization)
+| Convenient `MessageSource` access (for internationalization)
 | No
 | Yes

@@ -12,7 +12,7 @@ APIs as follows:
 * <<databuffers-buffer>> represents a byte buffer, which may be
 <<databuffers-buffer-pooled, pooled>>.
 * <<databuffers-utils>> offers utility methods for data buffers.
-* <<Codecs>> decode or encode streams data buffer streams into higher level objects.
+* <<Codecs>> decode or encode data buffer streams into higher level objects.



@@ -125,11 +125,11 @@ release it immediately, it can do so via `DataBufferUtils.release(dataBuffer)`.
 . If a `Decoder` is using `Flux` or `Mono` operators such as `flatMap`, `reduce`, and
 others that prefetch and cache data items internally, or is using operators such as
 `filter`, `skip`, and others that leave out items, then
-`doOnDiscard(PooledDataBuffer.class, DataBufferUtils::release)` must be added to the
+`doOnDiscard(DataBuffer.class, DataBufferUtils::release)` must be added to the
 composition chain to ensure such buffers are released prior to being discarded, possibly
-also as a result an error or cancellation signal.
+also as a result of an error or cancellation signal.
 . If a `Decoder` holds on to one or more data buffers in any other way, it must
-ensure they are released when fully read, or in case an error or cancellation signals that
+ensure they are released when fully read, or in case of an error or cancellation signals that
 take place before the cached data buffers have been read and released.

 Note that `DataBufferUtils#join` offers a safe and efficient way to aggregate a data
@@ -357,7 +357,7 @@ the list:
 	// Turn on:
 	// - auto null reference initialization
 	// - auto collection growing
-	SpelParserConfiguration config = new SpelParserConfiguration(true,true);
+	SpelParserConfiguration config = new SpelParserConfiguration(true, true);

 	ExpressionParser parser = new SpelExpressionParser(config);

@@ -465,7 +465,7 @@ following example shows how to do so:
 .Java
 ----
 	SpelParserConfiguration config = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
-		this.getClass().getClassLoader());
+			this.getClass().getClassLoader());

 	SpelExpressionParser parser = new SpelExpressionParser(config);

@@ -1052,8 +1052,9 @@ The Spring Expression Language supports the following kinds of operators:
 ==== Relational Operators

 The relational operators (equal, not equal, less than, less than or equal, greater than,
-and greater than or equal) are supported by using standard operator notation. The
-following listing shows a few examples of operators:
+and greater than or equal) are supported by using standard operator notation.
+These operators work on `Number` types as well as types implementing `Comparable`.
+The following listing shows a few examples of operators:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1066,6 +1067,9 @@ following listing shows a few examples of operators:

 	// evaluates to true
 	boolean trueValue = parser.parseExpression("'black' < 'block'").getValue(Boolean.class);
+
+	// uses CustomValue:::compareTo
+	boolean trueValue = parser.parseExpression("new CustomValue(1) < new CustomValue(2)").getValue(Boolean.class);
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
@@ -1078,6 +1082,9 @@ following listing shows a few examples of operators:

 	// evaluates to true
 	val trueValue = parser.parseExpression("'black' < 'block'").getValue(Boolean::class.java)
+
+	// uses CustomValue:::compareTo
+	val trueValue = parser.parseExpression("new CustomValue(1) < new CustomValue(2)").getValue(Boolean::class.java);
 ----

 [NOTE]
@@ -1677,7 +1684,7 @@ ternary operator.
 === The Elvis Operator

 The Elvis operator is a shortening of the ternary operator syntax and is used in the
-http://www.groovy-lang.org/operators.html#_elvis_operator[Groovy] language.
+https://www.groovy-lang.org/operators.html#_elvis_operator[Groovy] language.
 With the ternary operator syntax, you usually have to repeat a variable twice, as the
 following example shows:

@@ -1756,7 +1763,7 @@ This will inject a system property `pop3.port` if it is defined or 25 if not.
 === Safe Navigation Operator

 The safe navigation operator is used to avoid a `NullPointerException` and comes from
-the http://www.groovy-lang.org/operators.html#_safe_navigation_operator[Groovy]
+the https://www.groovy-lang.org/operators.html#_safe_navigation_operator[Groovy]
 language. Typically, when you have a reference to an object, you might need to verify that
 it is not null before accessing methods or properties of the object. To avoid this, the
 safe navigation operator returns null instead of throwing an exception. The following
@@ -215,7 +215,7 @@ as the following example shows:
 Validation errors are reported to the `Errors` object passed to the validator. In the case
 of Spring Web MVC, you can use the `<spring:bind/>` tag to inspect the error messages, but
 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].
+methods it offers can be found in the {api-spring-framework}/validation/Errors.html[javadoc].



@@ -382,7 +382,7 @@ properties:
 ----

 The following code snippets show some examples of how to retrieve and manipulate some of
-the properties of instantiated `Companies` and `Employees`:
+the properties of instantiated ``Company``s and ``Employee``s:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -629,7 +629,7 @@ Note that all bean factories and application contexts automatically use a number
 built-in property editors, through their use of a `BeanWrapper` to
 handle property conversions. The standard property editors that the `BeanWrapper`
 registers are listed in the <<beans-beans-conversion, previous section>>.
-Additionally, `ApplicationContexts` also override or add additional editors to handle
+Additionally, ``ApplicationContext``s also override or add additional editors to handle
 resource lookups in a manner appropriate to the specific application context type.

 Standard JavaBeans `PropertyEditor` instances are used to convert property values
@@ -790,10 +790,10 @@ The following example shows how to create your own `PropertyEditorRegistrar` imp

 See also the `org.springframework.beans.support.ResourceEditorRegistrar` for an example
 `PropertyEditorRegistrar` implementation. Notice how in its implementation of the
-`registerCustomEditors(..)` method ,it creates new instances of each property editor.
+`registerCustomEditors(..)` method, it creates new instances of each property editor.

-The next example shows how to configure a `CustomEditorConfigurer` and inject an instance of our
-`CustomPropertyEditorRegistrar` into it:
+The next example shows how to configure a `CustomEditorConfigurer` and inject an instance
+of our `CustomPropertyEditorRegistrar` into it:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -809,50 +809,51 @@ The next example shows how to configure a `CustomEditorConfigurer` and inject an
 		class="com.foo.editors.spring.CustomPropertyEditorRegistrar"/>
 ----

-Finally (and in a bit of a departure from the focus of this chapter for those of you
-using <<web.adoc#mvc, Spring's MVC web framework>>), using `PropertyEditorRegistrars` in
-conjunction with data-binding `Controllers` (such as `SimpleFormController`) can be very
-convenient. The following example uses a `PropertyEditorRegistrar` in the
-implementation of an `initBinder(..)` method:
+Finally (and in a bit of a departure from the focus of this chapter) for those of you
+using <<web.adoc#mvc, Spring's MVC web framework>>, using a `PropertyEditorRegistrar` in
+conjunction with data-binding web controllers can be very convenient. The following
+example uses a `PropertyEditorRegistrar` in the implementation of an `@InitBinder` method:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	public final class RegisterUserController extends SimpleFormController {
+	@Controller
+	public class RegisterUserController {

 		private final PropertyEditorRegistrar customPropertyEditorRegistrar;

-		public RegisterUserController(PropertyEditorRegistrar propertyEditorRegistrar) {
+		RegisterUserController(PropertyEditorRegistrar propertyEditorRegistrar) {
 			this.customPropertyEditorRegistrar = propertyEditorRegistrar;
 		}

-		protected void initBinder(HttpServletRequest request,
-				ServletRequestDataBinder binder) throws Exception {
+		@InitBinder
+		void initBinder(WebDataBinder binder) {
 			this.customPropertyEditorRegistrar.registerCustomEditors(binder);
 		}

-		// other methods to do with registering a User
+		// other methods related to registering a User
 	}
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
+	@Controller
 	class RegisterUserController(
-		private val customPropertyEditorRegistrar: PropertyEditorRegistrar) : SimpleFormController() {
+		private val customPropertyEditorRegistrar: PropertyEditorRegistrar) {

-		protected fun initBinder(request: HttpServletRequest,
-								binder: ServletRequestDataBinder) {
+		@InitBinder
+		fun initBinder(binder: WebDataBinder) {
 			this.customPropertyEditorRegistrar.registerCustomEditors(binder)
 		}

-		// other methods to do with registering a User
+		// other methods related to registering a User
 	}
 ----

 This style of `PropertyEditor` registration can lead to concise code (the implementation
-of `initBinder(..)` is only one line long) and lets common `PropertyEditor`
-registration code be encapsulated in a class and then shared amongst as many
-`Controllers` as needed.
+of the `@InitBinder` method is only one line long) and lets common `PropertyEditor`
+registration code be encapsulated in a class and then shared amongst as many controllers
+as needed.



@@ -1347,6 +1348,7 @@ listing shows the definition of the `AnnotationFormatterFactory` interface:
 ----

 To create an implementation:
+
 . Parameterize A to be the field `annotationType` with which you wish to associate
 formatting  logic -- for example `org.springframework.format.annotation.DateTimeFormat`.
 . Have `getFieldTypes()` return the types of fields on which the annotation can be used.
@@ -1470,7 +1472,7 @@ The following example uses `@DateTimeFormat` to format a `java.util.Date` as an
 .Kotlin
 ----
 	class MyModel(
-		@DateTimeFormat(iso= ISO.DATE) private val date: Date
+		@DateTimeFormat(iso=ISO.DATE) private val date: Date
 	)
 ----

@@ -1737,8 +1739,8 @@ bean, keep reading.

 Spring provides full support for the Bean Validation API including the bootstrapping of a
 Bean Validation provider as a Spring bean. This lets you inject a
-`javax.validation.ValidatorFactory` or `javax.validation.Validator` wherever validation is
-needed in your application.
+`jakarta.validation.ValidatorFactory` or `jakarta.validation.Validator` wherever validation
+is needed in your application.

 You can use the `LocalValidatorFactoryBean` to configure a default Validator as a Spring
 bean, as the following example shows:
@@ -1772,18 +1774,18 @@ Validator, is expected to be present in the classpath and is automatically detec
 [[validation-beanvalidation-spring-inject]]
 ==== Injecting a Validator

-`LocalValidatorFactoryBean` implements both `javax.validation.ValidatorFactory` and
-`javax.validation.Validator`, as well as Spring's `org.springframework.validation.Validator`.
+`LocalValidatorFactoryBean` implements both `jakarta.validation.ValidatorFactory` and
+`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 `javax.validation.Validator` if you prefer to work with the Bean
+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:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	import javax.validation.Validator;
+	import jakarta.validation.Validator;

 	@Service
 	public class MyService {
@@ -1795,7 +1797,7 @@ Validation API directly, as the following example shows:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	import javax.validation.Validator;
+	import jakarta.validation.Validator;

 	@Service
 	class MyService(@Autowired private val validator: Validator)
@@ -1832,7 +1834,7 @@ requires the Spring Validation API, as the following example shows:
 Each bean validation constraint consists of two parts:

 * A `@Constraint` annotation that declares the constraint and its configurable properties.
-* An implementation of the `javax.validation.ConstraintValidator` interface that implements
+* An implementation of the `jakarta.validation.ConstraintValidator` interface that implements
 the constraint's behavior.

 To associate a declaration with an implementation, each `@Constraint` annotation
@@ -1868,7 +1870,7 @@ The following example shows a custom `@Constraint` declaration followed by an as
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	import javax.validation.ConstraintValidator;
+	import jakarta.validation.ConstraintValidator;

 	public class MyConstraintValidator implements ConstraintValidator {

@@ -1881,7 +1883,7 @@ The following example shows a custom `@Constraint` declaration followed by an as
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	import javax.validation.ConstraintValidator
+	import jakarta.validation.ConstraintValidator

 	class MyConstraintValidator(private val aDependency: Foo) : ConstraintValidator {

@@ -1,7 +1,5 @@
 [[spring-data-tier]]
 = Data Access
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :toc: left
 :toclevels: 4
 :tabsize: 4
@@ -60,7 +58,7 @@ and <<transaction-solutions-to-common-problems, solutions to common problems>>.
 [[transaction-motivation]]
 === Advantages of the Spring Framework's Transaction Support Model

-Traditionally, Java EE developers have had two choices for transaction management:
+Traditionally, EE application developers have had two choices for transaction management:
 global or local transactions, both of which have profound limitations. Global
 and local transaction management is reviewed in the next two sections, followed by a
 discussion of how the Spring Framework's transaction management support addresses the
@@ -133,9 +131,9 @@ Typically, you need an application server's JTA capability only if your applicat
 to handle transactions across multiple resources, which is not a requirement for many
 applications. Many high-end applications use a single, highly scalable database (such as
 Oracle RAC) instead. Stand-alone transaction managers (such as
-https://www.atomikos.com/[Atomikos Transactions] and http://jotm.objectweb.org/[JOTM])
+https://www.atomikos.com/[Atomikos Transactions] and https://jotm.ow2.org/[JOTM])
 are other options. Of course, you may need other application server capabilities, such as
-Java Message Service (JMS) and Java EE Connector Architecture (JCA).
+Java Message Service (JMS) and Jakarta EE Connector Architecture (JCA).

 The Spring Framework gives you the choice of when to scale your application to a fully
 loaded application server. Gone are the days when the only alternative to using EJB
@@ -191,7 +189,7 @@ The `getTransaction(..)` method returns a `TransactionStatus` object, depending
 `TransactionDefinition` parameter. The returned `TransactionStatus` might represent a
 new transaction or can represent an existing transaction, if a matching transaction
 exists in the current call stack. The implication in this latter case is that, as with
-Java EE transaction contexts, a `TransactionStatus` is associated with a thread of
+Jakarta EE transaction contexts, a `TransactionStatus` is associated with a thread of
 execution.

 As of Spring Framework 5.2, Spring also provides a transaction management abstraction for
@@ -297,7 +295,7 @@ The related `PlatformTransactionManager` bean definition then has a reference to
 	</bean>
 ----

-If you use JTA in a Java EE container, then you use a container `DataSource`, obtained
+If you use JTA in a Jakarta EE container, then you use a container `DataSource`, obtained
 through JNDI, in conjunction with Spring's `JtaTransactionManager`. The following example
 shows what the JTA and JNDI lookup version would look like:

@@ -328,7 +326,7 @@ infrastructure.

 NOTE: The preceding definition of the `dataSource` bean uses the `<jndi-lookup/>` tag
 from the `jee` namespace. For more information see
-<<integration.adoc#xsd-schemas-jee, The JEE Schema>>.
+<<integration.adoc#integration.appendix.xsd-schemas-jee, The JEE Schema>>.

 NOTE: If you use JTA, your transaction manager definition should look the same, regardless
 of what data access technology you use, be it JDBC, Hibernate JPA, or any other supported
@@ -351,8 +349,8 @@ The `DataSource` bean definition is similar to the local JDBC example shown prev
 and, thus, is not shown in the following example.

 NOTE: If the `DataSource` (used by any non-JTA transaction manager) is looked up through
-JNDI and managed by a Java EE container, it should be non-transactional, because the
-Spring Framework (rather than the Java EE container) manages the transactions.
+JNDI and managed by a Jakarta EE container, it should be non-transactional, because the
+Spring Framework (rather than the Jakarta EE container) manages the transactions.

 The `txManager` bean in this case is of the `HibernateTransactionManager` type. In the
 same way as the `DataSourceTransactionManager` needs a reference to the `DataSource`, the
@@ -380,7 +378,7 @@ example declares `sessionFactory` and `txManager` beans:
 	</bean>
 ----

-If you use Hibernate and Java EE container-managed JTA transactions, you should use the
+If you use Hibernate and Jakarta EE container-managed JTA transactions, you should use the
 same `JtaTransactionManager` as in the previous JTA example for JDBC, as the following
 example shows. Also, it is recommended to make Hibernate aware of JTA through its
 transaction coordinator and possibly also its connection release mode configuration:
@@ -447,7 +445,7 @@ relevant `TransactionManager`.
 [[tx-resource-synchronization-high]]
 ==== High-level Synchronization Approach

-The preferred approach is to use Spring's highest-level template based persistence
+The preferred approach is to use Spring's highest-level template-based persistence
 integration APIs or to use native ORM APIs with transaction-aware factory beans or
 proxies for managing the native resource factories. These transaction-aware solutions
 internally handle resource creation and reuse, cleanup, optional transaction
@@ -504,7 +502,7 @@ behind the scenes and you need not write any special code.
 At the very lowest level exists the `TransactionAwareDataSourceProxy` class. This is a
 proxy for a target `DataSource`, which wraps the target `DataSource` to add awareness of
 Spring-managed transactions. In this respect, it is similar to a transactional JNDI
-`DataSource`, as provided by a Java EE server.
+`DataSource`, as provided by a Jakarta EE server.

 You should almost never need or want to use this class, except when existing
 code must be called and passed a standard JDBC `DataSource` interface implementation. In
@@ -1017,9 +1015,11 @@ to ensure completion and buffer results in the calling code.
 ==== Rolling Back a Declarative Transaction

 The previous section outlined the basics of how to specify transactional settings for
-classes, typically service layer classes, declaratively in your application. This
-section describes how you can control the rollback of transactions in a simple,
-declarative fashion.
+classes, typically service layer classes, declaratively in your application. This section
+describes how you can control the rollback of transactions in a simple, declarative
+fashion in XML configuration. For details on controlling rollback semantics declaratively
+with the `@Transactional` annotation, see
+<<transaction-declarative-attransactional-settings>>.

 The recommended way to indicate to the Spring Framework's transaction infrastructure
 that a transaction's work is to be rolled back is to throw an `Exception` from code that
@@ -1029,14 +1029,64 @@ the call stack and makes a determination whether to mark the transaction for rol

 In its default configuration, the Spring Framework's transaction infrastructure code
 marks a transaction for rollback only in the case of runtime, unchecked exceptions.
-That is, when the thrown exception is an instance or subclass of `RuntimeException`. (
-`Error` instances also, by default, result in a rollback). Checked exceptions that are
+That is, when the thrown exception is an instance or subclass of `RuntimeException`.
+(`Error` instances also, by default, result in a rollback). Checked exceptions that are
 thrown from a transactional method do not result in rollback in the default
 configuration.

 You can configure exactly which `Exception` types mark a transaction for rollback,
-including checked exceptions. The following XML snippet demonstrates how you configure
-rollback for a checked, application-specific `Exception` type:
+including checked exceptions by specifying _rollback rules_.
+
+.Rollback rules
+[[transaction-declarative-rollback-rules]]
+[NOTE]
+====
+Rollback rules determine if a transaction should be rolled back when a given exception is
+thrown, and the rules are based on exception types or exception patterns.
+
+Rollback rules may be configured in XML via the `rollback-for` and `no-rollback-for`
+attributes, which allow rules to be defined as patterns. When using
+<<transaction-declarative-attransactional-settings,`@Transactional`>>, rollback rules may
+be configured via the `rollbackFor`/`noRollbackFor` and
+`rollbackForClassName`/`noRollbackForClassName` attributes, which allow rules to be
+defined based on exception types or patterns, respectively.
+
+When a rollback rule is defined with an exception type, that type will be used to match
+against the type of a thrown exception and its super types, providing type safety and
+avoiding any unintentional matches that may occur when using a pattern. For example, a
+value of `jakarta.servlet.ServletException.class` will only match thrown exceptions of
+type `jakarta.servlet.ServletException` and its subclasses.
+
+When a rollback rule is defined with an exception pattern, the pattern can be a fully
+qualified class name or a substring of a fully qualified class name for an exception type
+(which must be a subclass of `Throwable`), with no wildcard support at present. For
+example, a value of `"jakarta.servlet.ServletException"` or `"ServletException"` will
+match `jakarta.servlet.ServletException` and its subclasses.
+
+[WARNING]
+=====
+You must carefully consider how specific a pattern is and whether to include package
+information (which isn't mandatory). For example, `"Exception"` will match nearly
+anything and will probably hide other rules. `"java.lang.Exception"` would be correct if
+`"Exception"` were meant to define a rule for all checked exceptions. With more unique
+exception names such as `"BaseBusinessException"` there is likely no need to use the
+fully qualified class name for the exception pattern.
+
+Furthermore, pattern-based rollback rules may result in unintentional matches for
+similarly named exceptions and nested classes. This is due to the fact that a thrown
+exception is considered to be a match for a given pattern-based rollback rule if the name
+of the thrown exception contains the exception pattern configured for the rollback rule.
+For example, given a rule configured to match on `"com.example.CustomException"`, that
+rule will match against an exception named `com.example.CustomExceptionV2` (an exception
+in the same package as `CustomException` but with an additional suffix) or an exception
+named `com.example.CustomException$AnotherException` (an exception declared as a nested
+class in `CustomException`).
+=====
+====
+
+The following XML snippet demonstrates how to configure rollback for a checked,
+application-specific `Exception` type by supplying an _exception pattern_ via the
+`rollback-for` attribute:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -1048,8 +1098,8 @@ rollback for a checked, application-specific `Exception` type:
 	</tx:advice>
 ----

-If you do not want a transaction rolled
-back when an exception is thrown, you can also specify 'no rollback rules'. The following example tells the Spring Framework's
+If you do not want a transaction rolled back when an exception is thrown, you can also
+specify 'no rollback' rules. The following example tells the Spring Framework's
 transaction infrastructure to commit the attendant transaction even in the face of an
 unhandled `InstrumentNotFoundException`:

@@ -1063,11 +1113,11 @@ unhandled `InstrumentNotFoundException`:
 	</tx:advice>
 ----

-When the Spring Framework's transaction infrastructure catches an exception and it
-consults the configured rollback rules to determine whether to mark the transaction for
-rollback, the strongest matching rule wins. So, in the case of the following
-configuration, any exception other than an `InstrumentNotFoundException` results in a
-rollback of the attendant transaction:
+When the Spring Framework's transaction infrastructure catches an exception and consults
+the configured rollback rules to determine whether to mark the transaction for rollback,
+the strongest matching rule wins. So, in the case of the following configuration, any
+exception other than an `InstrumentNotFoundException` results in a rollback of the
+attendant transaction:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -1078,10 +1128,10 @@ rollback of the attendant transaction:
 	</tx:advice>
 ----

-You can also indicate a required rollback programmatically. Although simple,
-this process is quite invasive and tightly couples your code to the Spring Framework's
-transaction infrastructure. The following example shows how to programmatically indicate
-a required rollback:
+You can also indicate a required rollback programmatically. Although simple, this process
+is quite invasive and tightly couples your code to the Spring Framework's transaction
+infrastructure. The following example shows how to programmatically indicate a required
+rollback:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1299,8 +1349,8 @@ source code puts the declarations much closer to the affected code. There is not
 danger of undue coupling, because code that is meant to be used transactionally is
 almost always deployed that way anyway.

-NOTE: The standard `javax.transaction.Transactional` annotation is also supported as a
-drop-in replacement to Spring's own annotation. Please refer to JTA 1.2 documentation
+NOTE: The standard `jakarta.transaction.Transactional` annotation is also supported as
+a drop-in replacement to Spring's own annotation. Please refer to the JTA documentation
 for more details.

 The ease-of-use afforded by the use of the `@Transactional` annotation is best
@@ -1475,7 +1525,7 @@ programming arrangements as the following listing shows:

 Note that there are special considerations for the returned `Publisher` with regards to
 Reactive Streams cancellation signals. See the <<tx-prog-operator-cancel>> section under
-"Using the TransactionOperator" for more details.
+"Using the TransactionalOperator" for more details.


 [[transaction-declarative-annotations-method-visibility]]
@@ -1663,7 +1713,8 @@ The default `@Transactional` settings are as follows:
 * The transaction is read-write.
 * The transaction timeout defaults to the default timeout of the underlying transaction
  system, or to none if timeouts are not supported.
-* Any `RuntimeException` triggers rollback, and any checked `Exception` does not.
+* Any `RuntimeException` or `Error` triggers rollback, and any checked `Exception` does
+  not.

 You can change these default settings. The following table summarizes the various
 properties of the `@Transactional` annotation:
@@ -1677,6 +1728,14 @@ properties of the `@Transactional` annotation:
 | `String`
 | Optional qualifier that specifies the transaction manager to be used.

+| `transactionManager`
+| `String`
+| Alias for `value`.
+
+| `label`
+| Array of `String` labels to add an expressive description to the transaction.
+| Labels may be evaluated by transaction managers to associate implementation-specific behavior with the actual transaction.
+
 | <<tx-propagation,propagation>>
 | `enum`: `Propagation`
 | Optional propagation setting.
@@ -1689,32 +1748,35 @@ properties of the `@Transactional` annotation:
 | `int` (in seconds of granularity)
 | Optional transaction timeout. Applies only to propagation values of `REQUIRED` or `REQUIRES_NEW`.

+| `timeoutString`
+| `String` (in seconds of granularity)
+| Alternative for specifying the `timeout` in seconds as a `String` value -- for example, as a placeholder.
+
 | `readOnly`
 | `boolean`
 | Read-write versus read-only transaction. Only applicable to values of `REQUIRED` or `REQUIRES_NEW`.

 | `rollbackFor`
 | Array of `Class` objects, which must be derived from `Throwable.`
-| Optional array of exception classes that must cause rollback.
+| Optional array of exception types that must cause rollback.

 | `rollbackForClassName`
-| Array of class names. The classes must be derived from `Throwable.`
-| Optional array of names of exception classes that must cause rollback.
+| Array of exception name patterns.
+| Optional array of exception name patterns that must cause rollback.

 | `noRollbackFor`
 | Array of `Class` objects, which must be derived from `Throwable.`
-| Optional array of exception classes that must not cause rollback.
+| Optional array of exception types that must not cause rollback.

 | `noRollbackForClassName`
-| Array of `String` class names, which must be derived from `Throwable.`
-| Optional array of names of exception classes that must not cause rollback.
-
-| `label`
-| Array of `String` labels to add an expressive description to the transaction.
-| Labels may be evaluated by transaction managers to associate
-implementation-specific behavior with the actual transaction.
+| Array of exception name patterns.
+| Optional array of exception name patterns that must not cause rollback.
 |===

+TIP: See <<transaction-declarative-rollback-rules, Rollback rules>> for further details
+on rollback rule semantics, patterns, and warnings regarding possible unintentional
+matches for pattern-based rollback rules.
+
 Currently, you cannot have explicit control over the name of a transaction, where 'name'
 means the transaction name that appears in a transaction monitor, if applicable
 (for example, WebLogic's transaction monitor), and in logging output. For declarative
@@ -1880,7 +1942,7 @@ rollback rules, timeouts, and other features.
 ==== Transaction Propagation

 This section describes some semantics of transaction propagation in Spring. Note
-that this section is not an introduction to transaction propagation proper. Rather, it
+that this section is not a proper introduction to transaction propagation. Rather, it
 details some of the semantics regarding transaction propagation in Spring.

 In Spring-managed transactions, be aware of the difference between physical and
@@ -2123,7 +2185,7 @@ declarative approach:

 		<aop:config>
 			<aop:pointcut id="entryPointMethod" expression="execution(* x.y..*Service.*(..))"/>
-			<!-- runs after the profiling advice (c.f. the order attribute) -->
+			<!-- runs after the profiling advice (cf. the order attribute) -->

 			<aop:advisor advice-ref="txAdvice" pointcut-ref="entryPointMethod" order="2"/>
 			<!-- order value is higher than the profiling aspect -->
@@ -2166,7 +2228,7 @@ container by means of an AspectJ aspect. To do so, first annotate your classes
 (and optionally your classes' methods) with the `@Transactional` annotation,
 and then link (weave) your application with the
 `org.springframework.transaction.aspectj.AnnotationTransactionAspect` defined in the
-`spring-aspects.jar` file. You must also configure The aspect with a transaction
+`spring-aspects.jar` file. You must also configure the aspect with a transaction
 manager. You can use the Spring Framework's IoC container to take care of
 dependency-injecting the aspect. The simplest way to configure the transaction
 management aspect is to use the `<tx:annotation-driven/>` element and specify the `mode`
@@ -2417,39 +2479,39 @@ different settings (for example, a different isolation level), you need to creat
 two distinct `TransactionTemplate` instances.

 [[tx-prog-operator]]
-==== Using the `TransactionOperator`
+==== Using the `TransactionalOperator`

-The `TransactionOperator` follows an operator design that is similar to other reactive
+The `TransactionalOperator` follows an operator design that is similar to other reactive
 operators. It uses a callback approach (to free application code from having to do the
 boilerplate acquisition and release transactional resources) and results in code that is
 intention driven, in that your code focuses solely on what you want to do.

-NOTE: As the examples that follow show, using the `TransactionOperator` absolutely
+NOTE: As the examples that follow show, using the `TransactionalOperator` absolutely
 couples you to Spring's transaction infrastructure and APIs. Whether or not programmatic
 transaction management is suitable for your development needs is a decision that you have
 to make yourself.

 Application code that must run in a transactional context and that explicitly uses
-the `TransactionOperator` resembles the next example:
+the `TransactionalOperator` resembles the next example:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
 	public class SimpleService implements Service {

-		// single TransactionOperator shared amongst all methods in this instance
+		// single TransactionalOperator shared amongst all methods in this instance
 		private final TransactionalOperator transactionalOperator;

 		// use constructor-injection to supply the ReactiveTransactionManager
 		public SimpleService(ReactiveTransactionManager transactionManager) {
-			this.transactionOperator = TransactionalOperator.create(transactionManager);
+			this.transactionalOperator = TransactionalOperator.create(transactionManager);
 		}

 		public Mono<Object> someServiceMethod() {
-			
+
 			// the code in this method runs in a transactional context
-			
-            Mono<Object> update = updateOperation1();
+
+			Mono<Object> update = updateOperation1();

 			return update.then(resultOfUpdateOperation2).as(transactionalOperator::transactional);
 		}
@@ -2587,8 +2649,7 @@ following example shows how to do so:
 	TransactionStatus status = txManager.getTransaction(def);
 	try {
 		// put your business logic here
-	}
-	catch (MyException ex) {
+	} catch (MyException ex) {
 		txManager.rollback(status);
 		throw ex;
 	}
@@ -2753,7 +2814,7 @@ supporting transaction suspension. See the
 {api-spring-framework}/transaction/jta/JtaTransactionManager.html[`JtaTransactionManager`]
 javadoc for details.

-Spring's `JtaTransactionManager` is the standard choice to run on Java EE application
+Spring's `JtaTransactionManager` is the standard choice to run on Jakarta EE application
 servers and is known to work on all common servers. Advanced functionality, such as
 transaction suspension, works on many servers as well (including GlassFish, JBoss and
 Geronimo) without any special configuration required. However, for fully supported
@@ -2819,7 +2880,7 @@ treats them as errors.

 For more information about the Spring Framework's transaction support, see:

-* https://www.javaworld.com/javaworld/jw-01-2009/jw-01-spring-transactions.html[Distributed
+* https://www.infoworld.com/article/2077963/distributed-transactions-in-spring--with-and-without-xa.html[Distributed
  transactions in Spring, with and without XA] is a JavaWorld presentation in which
  Spring's David Syer guides you through seven patterns for distributed
  transactions in Spring applications, three of them with XA and four without.
@@ -3111,7 +3172,7 @@ class and the related support classes. See <<jdbc-core>>, <<jdbc-advanced-jdbc>>

 * `datasource`: The `org.springframework.jdbc.datasource` package contains a utility class for easy
 `DataSource` access and various simple `DataSource` implementations that you can use for
-testing and running unmodified JDBC code outside of a Java EE container. A subpackage
+testing and running unmodified JDBC code outside of a Jakarta EE container. A subpackage
 named `org.springfamework.jdbc.datasource.embedded` provides support for creating
 embedded databases by using Java database engines, such as HSQL, H2, and Derby. See
 <<jdbc-connections>> and <<jdbc-embedded-database-support>>.
@@ -3297,7 +3358,7 @@ For example, it may be better to write the preceding code snippet as follows:
 	};

 	public List<Actor> findAllActors() {
-		return this.jdbcTemplate.query( "select first_name, last_name from t_actor", actorRowMapper);
+		return this.jdbcTemplate.query("select first_name, last_name from t_actor", actorRowMapper);
 	}
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -3607,7 +3668,7 @@ variable and the corresponding value that is plugged into the `namedParameters`
 variable (of type `MapSqlParameterSource`).

 Alternatively, you can pass along named parameters and their corresponding values to a
-`NamedParameterJdbcTemplate` instance by using the `Map`-based style.The remaining
+`NamedParameterJdbcTemplate` instance by using the `Map`-based style. The remaining
 methods exposed by the `NamedParameterJdbcOperations` and implemented by the
 `NamedParameterJdbcTemplate` class follow a similar pattern and are not covered here.

@@ -3745,7 +3806,7 @@ See also <<jdbc-JdbcTemplate-idioms>> for guidelines on using the
 ==== Using `SQLExceptionTranslator`

 `SQLExceptionTranslator` is an interface to be implemented by classes that can translate
-between `SQLExceptions` and Spring's own `org.springframework.dao.DataAccessException`,
+between ``SQLException``s and Spring's own `org.springframework.dao.DataAccessException`,
 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.
@@ -3801,9 +3862,9 @@ You can extend `SQLErrorCodeSQLExceptionTranslator`, as the following example sh

 		override fun customTranslate(task: String, sql: String?, sqlEx: SQLException): DataAccessException? {
 			if (sqlEx.errorCode == -12345) {
-					return DeadlockLoserDataAccessException(task, sqlEx)
-				}
-				return null;
+				return DeadlockLoserDataAccessException(task, sqlEx)
+			}
+			return null
 		}
 	}
 ----
@@ -4036,7 +4097,7 @@ The following example updates a column for a certain primary key:

 In the preceding example,
 an SQL statement has placeholders for row parameters. You can pass the parameter values
-in as varargs or ,alternatively, as an array of objects. Thus, you should explicitly wrap primitives
+in as varargs or, alternatively, as an array of objects. Thus, you should explicitly wrap primitives
 in the primitive wrapper classes, or you should use auto-boxing.


@@ -4252,7 +4313,7 @@ The `DriverManagerDataSource` class is an implementation of the standard `DataSo
 interface that configures a plain JDBC driver through bean properties and returns a new
 `Connection` every time.

-This implementation is useful for test and stand-alone environments outside of a Java EE
+This implementation is useful for test and stand-alone environments outside of a Jakarta EE
 container, either as a `DataSource` bean in a Spring IoC container or in conjunction
 with a simple JNDI environment. Pool-assuming `Connection.close()` calls
 close the connection, so any `DataSource`-aware persistence code should work. However,
@@ -4266,7 +4327,7 @@ environment, that it is almost always preferable to use such a connection pool o

 `TransactionAwareDataSourceProxy` is a proxy for a target `DataSource`. The proxy wraps that
 target `DataSource` to add awareness of Spring-managed transactions. In this respect, it
-is similar to a transactional JNDI `DataSource`, as provided by a Java EE server.
+is similar to a transactional JNDI `DataSource`, as provided by a Jakarta EE server.

 NOTE: It is rarely desirable to use this class, except when already existing code must be
 called and passed a standard JDBC `DataSource` interface implementation. In this case,
@@ -4288,7 +4349,7 @@ specified data source to the currently executing thread, potentially allowing fo
 thread connection per data source.

 Application code is required to retrieve the JDBC connection through
-`DataSourceUtils.getConnection(DataSource)` instead of Java EE's standard
+`DataSourceUtils.getConnection(DataSource)` instead of Jakarta EE's standard
 `DataSource.getConnection`. It throws unchecked `org.springframework.dao` exceptions
 instead of checked `SQLExceptions`. All framework classes (such as `JdbcTemplate`) use this
 strategy implicitly. If not used with this transaction manager, the lookup strategy
@@ -4579,7 +4640,7 @@ The following example shows a batch update that uses a batch size of 100:
 	}
 ----

-The batch update methods for this call returns an array of `int` arrays that contains an
+The batch update method for this call returns an array of `int` arrays that contains an
 array entry for each batch with an array of the number of affected rows for each update.
 The top-level array's length indicates the number of batches run, and the second level
 array's length indicates the number of updates in that batch. The number of updates in
@@ -5175,11 +5236,9 @@ as the following example shows:
 ----
 	public class JdbcActorDao implements ActorDao {

-		private JdbcTemplate jdbcTemplate;
 		private SimpleJdbcCall funcGetActorName;

 		public void setDataSource(DataSource dataSource) {
-			this.jdbcTemplate = new JdbcTemplate(dataSource);
 			JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
 			jdbcTemplate.setResultsMapCaseInsensitive(true);
 			this.funcGetActorName = new SimpleJdbcCall(jdbcTemplate)
@@ -5445,7 +5504,7 @@ example shows such a method:
 The `SqlUpdate` class encapsulates an SQL update. As with a query, an update object is
 reusable, and, as with all `RdbmsOperation` classes, an update can have parameters and is
 defined in SQL. This class provides a number of `update(..)` methods analogous to the
-`execute(..)` methods of query objects. The `SQLUpdate` class is concrete. It can be
+`execute(..)` methods of query objects. The `SqlUpdate` class is concrete. It can be
 subclassed -- for example, to add a custom update method.
 However, you do not have to subclass the `SqlUpdate`
 class, since it can easily be parameterized by setting SQL and declaring parameters.
@@ -6032,8 +6091,8 @@ limit is 1000.

 In addition to the primitive values in the value list, you can create a `java.util.List`
 of object arrays. This list can support multiple expressions being defined for the `in`
-clause, such as `select * from T_ACTOR where (id, last_name) in \((1, 'Johnson'), (2,
-'Harrop'\))`. This, of course, requires that your database supports this syntax.
+clause, such as `+++select * from T_ACTOR where (id, last_name) in ((1, 'Johnson'), (2,
+'Harrop'))+++`. This, of course, requires that your database supports this syntax.


 [[jdbc-complex-types]]
@@ -6170,7 +6229,7 @@ it with values from the Java `ARRAY`, as the following example shows:
 === Embedded Database Support

 The `org.springframework.jdbc.datasource.embedded` package provides support for embedded
-Java database engines. Support for http://www.hsqldb.org[HSQL],
+Java database engines. Support for https://www.hsqldb.org[HSQL],
 https://www.h2database.com[H2], and https://db.apache.org/derby[Derby] is provided
 natively. You can also use an extensible API to plug in new embedded database types and
 `DataSource` implementations.
@@ -6793,20 +6852,20 @@ You can take control over result mapping by supplying a `Function<Row, T>` that
 called for each `Row` so it can can return arbitrary values (singular values,
 collections and maps, and objects).

-The following example extracts the `id` column and emits its value:
+The following example extracts the `name` column and emits its value:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
 	Flux<String> names = client.sql("SELECT name FROM person")
-	        .map(row -> row.get("id", String.class))
+	        .map(row -> row.get("name", String.class))
 	        .all();
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	val names = client.sql("SELECT name FROM person")
-	        .map{ row: Row -> row.get("id", String.class) }
+	        .map{ row: Row -> row.get("name", String.class) }
 	        .flow()
 ----

@@ -7095,7 +7154,7 @@ databases, you may want multiple `DatabaseClient` instances, which requires mult
 instances.

 [[r2dbc-auto-generated-keys]]
-== Retrieving Auto-generated Keys
+=== Retrieving Auto-generated Keys

 `INSERT` statements may generate keys when inserting rows into a table
 that defines an auto-increment or identity column. To get full control over
@@ -7389,7 +7448,9 @@ examples (one for Java configuration and one for XML configuration) show how to
 ----
 	@Repository
 	class ProductDaoImpl : ProductDao {
+
 		// class body here...
+
 	}
 ----

@@ -7429,7 +7490,7 @@ cover the other ORM technologies and show brief examples.

 NOTE: As of Spring Framework 5.3, Spring requires Hibernate ORM 5.2+ for Spring's
 `HibernateJpaVendorAdapter` as well as for a native Hibernate `SessionFactory` setup.
-Is is strongly recommended to go with Hibernate ORM 5.4 for a newly started application.
+It is strongly recommended to go with Hibernate ORM 5.4 for a newly started application.
 For use with `HibernateJpaVendorAdapter`, Hibernate Search needs to be upgraded to 5.11.6.


@@ -7812,7 +7873,7 @@ resource definitions in the container or locally within the application is mainl
 matter of the transaction strategy that you use. Compared to a Spring-defined local
 `SessionFactory`, a manually registered JNDI `SessionFactory` does not provide any
 benefits. Deploying a `SessionFactory` through Hibernate's JCA connector provides the
-added value of participating in the Java EE server's management infrastructure, but does
+added value of participating in the Jakarta EE server's management infrastructure, but does
 not add actual value beyond that.

 Spring's transaction support is not bound to a container. When configured with any strategy
@@ -7822,11 +7883,7 @@ local transaction support is a lightweight and powerful alternative to JTA. When
 local EJB stateless session beans to drive transactions, you depend both on an EJB
 container and on JTA, even if you access only a single database and use only stateless
 session beans to provide declarative transactions through container-managed
-transactions. Direct use of JTA programmatically also requires a Java EE environment.
-JTA does not involve only container dependencies in terms of JTA itself and of
-JNDI `DataSource` instances. For non-Spring, JTA-driven Hibernate transactions, you have
-to use the Hibernate JCA connector or extra Hibernate transaction code with the
-`TransactionManagerLookup` configured for proper JVM-level caching.
+transactions. Direct use of JTA programmatically also requires a Jakarta EE environment.

 Spring-driven transactions can work as well with a locally defined Hibernate
 `SessionFactory` as they do with a local JDBC `DataSource`, provided they access a
@@ -7834,12 +7891,7 @@ single database. Thus, you need only use Spring's JTA transaction strategy when
 have distributed transaction requirements. A JCA connector requires container-specific
 deployment steps, and (obviously) JCA support in the first place. This configuration
 requires more work than deploying a simple web application with local resource
-definitions and Spring-driven transactions. Also, you often need the Enterprise Edition
-of your container if you use, for example, WebLogic Express, which does not
-provide JCA. A Spring application with local resources and transactions that span one
-single database works in any Java EE web container (without JTA, JCA, or EJB), such as
-Tomcat, Resin, or even plain Jetty. Additionally, you can easily reuse such a middle
-tier in desktop applications or test suites.
+definitions and Spring-driven transactions.

 All things considered, if you do not use EJBs, stick with local `SessionFactory` setup
 and Spring's `HibernateTransactionManager` or `JtaTransactionManager`. You get all of
@@ -7960,18 +8012,18 @@ persistence unit name. The following XML example configures such a bean:
 This form of JPA deployment is the simplest and the most limited. You cannot refer to an
 existing JDBC `DataSource` bean definition, and no support for global transactions
 exists. Furthermore, weaving (byte-code transformation) of persistent classes is
-provider-specific, often requiring a specific JVM agent to specified on startup. This
+provider-specific, often requiring a specific JVM agent to be specified on startup. This
 option is sufficient only for stand-alone applications and test environments, for which
 the JPA specification is designed.

 [[orm-jpa-setup-jndi]]
 ===== Obtaining an EntityManagerFactory from JNDI

-You can use this option when deploying to a Java EE server. Check your server's documentation
+You can use this option when deploying to a Jakarta EE server. Check your server's documentation
 on how to deploy a custom JPA provider into your server, allowing for a different
 provider than the server's default.

-Obtaining an `EntityManagerFactory` from JNDI (for example in a Java EE environment),
+Obtaining an `EntityManagerFactory` from JNDI (for example in a Jakarta EE environment),
 is a matter of changing the XML configuration, as the following example shows:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -7981,13 +8033,13 @@ is a matter of changing the XML configuration, as the following example shows:
 	</beans>
 ----

-This action assumes standard Java EE bootstrapping. The Java EE server auto-detects
+This action assumes standard Jakarta EE bootstrapping. The Jakarta EE server auto-detects
 persistence units (in effect, `META-INF/persistence.xml` files in application jars) and
-`persistence-unit-ref` entries in the Java EE deployment descriptor (for example,
+`persistence-unit-ref` entries in the Jakarta EE deployment descriptor (for example,
 `web.xml`) and defines environment naming context locations for those persistence units.

 In such a scenario, the entire persistence unit deployment, including the weaving
-(byte-code transformation) of persistent classes, is up to the Java EE server. The JDBC
+(byte-code transformation) of persistent classes, is up to the Jakarta EE server. The JDBC
 `DataSource` is defined through a JNDI location in the `META-INF/persistence.xml` file.
 `EntityManager` transactions are integrated with the server's JTA subsystem. Spring merely
 uses the obtained `EntityManagerFactory`, passing it on to application objects through
@@ -8059,12 +8111,12 @@ so on. However, it also imposes requirements on the runtime environment, such as
 availability of a weaving-capable class loader if the persistence provider demands
 byte-code transformation.

-This option may conflict with the built-in JPA capabilities of a Java EE server. In a
-full Java EE environment, consider obtaining your `EntityManagerFactory` from JNDI.
+This option may conflict with the built-in JPA capabilities of a Jakarta EE server. In a
+full Jakarta EE environment, consider obtaining your `EntityManagerFactory` from JNDI.
 Alternatively, specify a custom `persistenceXmlLocation` on your
 `LocalContainerEntityManagerFactoryBean` definition (for example,
 META-INF/my-persistence.xml) and include only a descriptor with that name in your
-application jar files. Because the Java EE server looks only for default
+application jar files. Because the Jakarta EE server looks only for default
 `META-INF/persistence.xml` files, it ignores such custom persistence units and, hence,
 avoids conflicts with a Spring-driven JPA setup upfront. (This applies to Resin 3.1, for
 example.)
@@ -8095,7 +8147,7 @@ more insight regarding the `LoadTimeWeaver` implementations and their setup, eit
 generic or customized to various platforms (such as Tomcat, JBoss and WebSphere).

 As described in <<core.adoc#aop-aj-ltw-spring, Spring configuration>>, you can configure
-a context-wide `LoadTimeWeaver` by using the `@EnableLoadTimeWeaving` annotation of the
+a context-wide `LoadTimeWeaver` by using the `@EnableLoadTimeWeaving` annotation or the
 `context:load-time-weaver` XML element. Such a global weaver is automatically picked up
 by all JPA `LocalContainerEntityManagerFactoryBean` instances. The following example
 shows the preferred way of setting up a load-time weaver, delivering auto-detection
@@ -8224,11 +8276,17 @@ that uses the `@PersistenceUnit` annotation:
 		}

 		public Collection loadProductsByCategory(String category) {
-			try (EntityManager em = this.emf.createEntityManager()) {
+			EntityManager em = this.emf.createEntityManager();
+			try {
 				Query query = em.createQuery("from Product as p where p.category = ?1");
 				query.setParameter(1, category);
 				return query.getResultList();
 			}
+			finally {
+				if (em != null) {
+					em.close();
+				}
+			}
 		}
 	}
 ----
@@ -8346,7 +8404,7 @@ protected, or private) does not matter.

 What about class-level annotations?

-On the Java EE platform, they are used for dependency declaration and not for resource
+On the Jakarta EE platform, they are used for dependency declaration and not for resource
 injection.
 ****

@@ -8419,13 +8477,13 @@ more details of its operations and how they are used within Spring's JPA support
 ==== Setting up JPA with JTA Transaction Management

 As an alternative to `JpaTransactionManager`, Spring also allows for multi-resource
-transaction coordination through JTA, either in a Java EE environment or with a
+transaction coordination through JTA, either in a Jakarta EE environment or with a
 stand-alone transaction coordinator, such as Atomikos. Aside from choosing Spring's
 `JtaTransactionManager` instead of `JpaTransactionManager`, you need to take few further
 steps:

 * The underlying JDBC connection pools need to be XA-capable and be integrated with
-your transaction coordinator. This is usually straightforward in a Java EE environment,
+your transaction coordinator. This is usually straightforward in a Jakarta EE environment,
 exposing a different kind of `DataSource` through JNDI. See your application server
 documentation for details. Analogously, a standalone transaction coordinator usually
 comes with special XA-integrated `DataSource` variants. Again, check its documentation.
@@ -1,9 +1,10 @@
+[[data.access.appendix]]
 = Appendix




-[[xsd-schemas]]
+[[data.access.xsd-schemas]]
 == XML Schemas

 This part of the appendix lists XML schemas for data access, including the following:
@@ -0,0 +1,9 @@
+<div id="header">
+<h1>Spring Framework Documentation</h1>
+<!--
+<div class="details">
+<span id="revnumber">{revnumber}</span>
+</div>
+-->
+<span><strong>{revnumber}</strong></span>
+</div>
@@ -1,16 +1,11 @@
+:noheader:
 = Spring Framework Documentation

-****
-_What's New_, _Upgrade Notes_, _Supported Versions_, and other topics,
-independent of release cadence, are maintained externally on the project's
-https://github.com/spring-projects/spring-framework/wiki[*Github Wiki*].
-****
-
 [horizontal]
 <<overview.adoc#overview, Overview>> :: history, design philosophy, feedback,
 getting started.
 <<core.adoc#spring-core, Core>> :: IoC Container, Events, Resources, i18n,
-Validation, Data Binding, Type Conversion, SpEL, AOP.
+Validation, Data Binding, Type Conversion, SpEL, AOP, AOT.
 <<testing.adoc#testing, Testing>> :: Mock Objects, TestContext Framework,
 Spring MVC Test, WebTestClient.
 <<data-access.adoc#spring-data-tier, Data Access>> :: Transactions, DAO Support,
@@ -19,10 +14,14 @@ JDBC, R2DBC, O/R Mapping, XML Marshalling.
 STOMP Messaging.
 <<web-reactive.adoc#spring-webflux, Web Reactive>> :: Spring WebFlux, WebClient,
 WebSocket, RSocket.
-<<integration.adoc#spring-integration, Integration>> :: Remoting, JMS, JCA, JMX,
+<<integration.adoc#spring-integration, Integration>> :: REST Clients, JMS, JCA, JMX,
 Email, Tasks, Scheduling, Caching.
 <<languages.adoc#languages, Languages>> :: Kotlin, Groovy, Dynamic Languages.
-<<appendix.adoc#appendix, Appendix>> :: miscellaneous topics.
+<<appendix.adoc#appendix, Appendix>> :: Spring properties.
+https://github.com/spring-projects/spring-framework/wiki[*Wiki*] :: What's New,
+Upgrade Notes, Supported Versions, and other cross-version information.
+
+NOTE: This documentation is available in {docs-spring-framework}/reference/html/index.html[HTML] and {docs-spring-framework}/reference/pdf/spring-framework.pdf[PDF] formats.

 Rod Johnson, Juergen Hoeller, Keith Donald, Colin Sampaleanu, Rob Harrop, Thomas Risberg,
 Alef Arendsen, Darren Davison, Dmitriy Kopylenko, Mark Pollack, Thierry Templier, Erwin
@@ -31,7 +30,7 @@ Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clem
 Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane
 Nicoll, Sebastien Deleuze, Jay Bryant, Mark Paluch

-Copyright © 2002 - 2021 Pivotal, Inc. All Rights Reserved.
+Copyright © 2002 - 2022 VMware, Inc. All Rights Reserved.

 Copies of this document may be made for your own use and for distribution to others,
 provided that you do not charge any fee for such copies and further provided that each
@@ -1,19 +1,20 @@
+[[integration.appendix]]
 = Appendix




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

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



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

-The `jee` elements deal with issues related to Java EE (Java Enterprise Edition) configuration,
+The `jee` elements deal with issues related to Jakarta EE (Enterprise Edition) configuration,
 such as looking up a JNDI object and defining EJB references.

 To use the elements in the `jee` schema, you need to have the following preamble at the top
@@ -37,7 +38,7 @@ correct schema so that the elements in the `jee` namespace are available to you:



-[[xsd-schemas-jee-jndi-lookup]]
+[[integration.appendix.xsd-schemas-jee-jndi-lookup]]
 ==== <jee:jndi-lookup/> (simple)

 The following example shows how to use JNDI to look up a data source without the `jee` schema:
@@ -68,7 +69,7 @@ schema:



-[[xsd-schemas-jee-jndi-lookup-environment-single]]
+[[integration.appendix.xsd-schemas-jee-jndi-lookup-environment-single]]
 ==== `<jee:jndi-lookup/>` (with Single JNDI Environment Setting)

 The following example shows how to use JNDI to look up an environment variable without
@@ -96,7 +97,7 @@ The following example shows how to use JNDI to look up an environment variable w
 ----


-[[xsd-schemas-jee-jndi-lookup-evironment-multiple]]
+[[integration.appendix.xsd-schemas-jee-jndi-lookup-environment-multiple]]
 ==== `<jee:jndi-lookup/>` (with Multiple JNDI Environment Settings)

 The following example shows how to use JNDI to look up multiple environment variables
@@ -130,7 +131,7 @@ The following example shows how to use JNDI to look up multiple environment vari
 ----


-[[xsd-schemas-jee-jndi-lookup-complex]]
+[[integration.appendix.xsd-schemas-jee-jndi-lookup-complex]]
 ==== `<jee:jndi-lookup/>` (Complex)

 The following example shows how to use JNDI to look up a data source and a number of
@@ -164,7 +165,7 @@ different properties with `jee`:



-[[xsd-schemas-jee-local-slsb]]
+[[integration.appendix.xsd-schemas-jee-local-slsb]]
 ==== `<jee:local-slsb/>` (Simple)

 The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless Session Bean.
@@ -192,7 +193,7 @@ with `jee`:



-[[xsd-schemas-jee-local-slsb-complex]]
+[[integration.appendix.xsd-schemas-jee-local-slsb-complex]]
 ==== `<jee:local-slsb/>` (Complex)

 The `<jee:local-slsb/>` element configures a reference to a local EJB Stateless Session Bean.
@@ -226,7 +227,7 @@ and a number of properties with `jee`:
 ----


-[[xsd-schemas-jee-remote-slsb]]
+[[integration.appendix.xsd-schemas-jee-remote-slsb]]
 ==== <jee:remote-slsb/>

 The `<jee:remote-slsb/>` element configures a reference to a `remote` EJB Stateless Session Bean.
@@ -265,7 +266,7 @@ with `jee`:



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

 The `jms` elements deal with configuring JMS-related beans, such as Spring's
@@ -296,7 +297,7 @@ are available to you:



-[[xsd-schemas-context-mbe]]
+[[integration.appendix.xsd-schemas-context-mbe]]
 === Using `<context:mbean-export/>`

 This element is detailed in
@@ -304,7 +305,7 @@ This element is detailed in



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

 You can use the `cache` elements to enable support for Spring's `@CacheEvict`, `@CachePut`,
@@ -1,7 +1,5 @@
 [[languages]]
 = Language Support
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :toc: left
 :toclevels: 4
 :tabsize: 4
@@ -686,8 +686,8 @@ by using the Groovy dynamic language:
 	import org.springframework.web.servlet.ModelAndView
 	import org.springframework.web.servlet.mvc.Controller

-	import javax.servlet.http.HttpServletRequest
-	import javax.servlet.http.HttpServletResponse
+	import jakarta.servlet.http.HttpServletRequest
+	import jakarta.servlet.http.HttpServletResponse

 	class FortuneController implements Controller {

@@ -30,6 +30,8 @@ and https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-reflect[`kotli
 to be present on the classpath. They are provided by default if you bootstrap a Kotlin project on
 https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].

+WARNING: Kotlin https://kotlinlang.org/docs/inline-classes.html[inline classes] are not yet supported.
+
 NOTE: The https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module] is required
 for serializing or deserializing JSON data for Kotlin classes with Jackson, so make sure to add the
 `com.fasterxml.jackson.module:jackson-module-kotlin` dependency to your project if you have such need.
@@ -42,8 +44,8 @@ Kotlin https://kotlinlang.org/docs/reference/extensions.html[extensions] provide
 to extend existing classes with additional functionality. The Spring Framework Kotlin APIs
 use these extensions to add new Kotlin-specific conveniences to existing Spring APIs.

-The {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/[Spring Framework KDoc API] lists
-and documents all available the Kotlin extensions and DSLs.
+The {docs-spring-framework}/kdoc-api/[Spring Framework KDoc API] lists
+and documents all available Kotlin extensions and DSLs.

 NOTE: Keep in mind that Kotlin extensions need to be imported to be used. This means,
 for example, that the `GenericApplicationContext.registerBean` Kotlin extension
@@ -209,7 +211,7 @@ the constructor parameters will be autowired by type:
 ----

 In order to allow a more declarative approach and cleaner syntax, Spring Framework provides
-a {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.context.support/-bean-definition-dsl/[Kotlin bean definition DSL]
+a {docs-spring-framework}/kdoc-api/spring-context/org.springframework.context.support/-bean-definition-dsl/index.html[Kotlin bean definition DSL]
 It declares an `ApplicationContextInitializer` through a clean declarative API,
 which lets you deal with profiles and `Environment` for customizing
 how beans are registered.
@@ -275,9 +277,9 @@ for more details and up-to-date information. See also the experimental Kofu DSL

 Spring Framework comes with a Kotlin router DSL available in 3 flavors:

-* WebMvc.fn DSL with {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.servlet.function/router.html[router { }]
-* WebFlux.fn <<web-reactive#webflux-fn, Reactive>> DSL with {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/router.html[router { }]
-* WebFlux.fn <<Coroutines>> DSL with {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/co-router.html[coRouter { }]
+* WebMvc.fn DSL with {docs-spring-framework}/kdoc-api/spring-webmvc/org.springframework.web.servlet.function/router.html[router { }]
+* WebFlux.fn <<web-reactive#webflux-fn, Reactive>> DSL with {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/router.html[router { }]
+* WebFlux.fn <<Coroutines>> DSL with {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }]

 These DSL let you write clean and idiomatic Kotlin code to build a `RouterFunction` instance as the following example shows:

@@ -387,7 +389,7 @@ project for more details.
 === Kotlin multiplatform serialization

 As of Spring Framework 5.3, https://github.com/Kotlin/kotlinx.serialization[Kotlin multiplatform serialization] is
-supported in Spring MVC, Spring WebFlux and Spring Messaging (RSocket). The builtin support currently only targets JSON format.
+supported in Spring MVC, Spring WebFlux and Spring Messaging (RSocket). The builtin support currently targets CBOR, JSON, and ProtoBuf formats.

 To enable it, follow https://github.com/Kotlin/kotlinx.serialization#setup[those instructions] to add the related dependency and plugin.
 With Spring MVC and WebFlux, both Kotlin serialization and Jackson will be configured by default if they are in the classpath since
@@ -408,10 +410,10 @@ Spring Framework provides support for Coroutines on the following scope:

 * https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html[Deferred] and https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/index.html[Flow] return values support in Spring MVC and WebFlux annotated `@Controller`
 * Suspending function support in Spring MVC and WebFlux annotated `@Controller`
-* Extensions for WebFlux {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.client/index.html[client] and {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/index.html[server] functional API.
-* WebFlux.fn {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL
+* Extensions for WebFlux {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.client/index.html[client] and {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/index.html[server] functional API.
+* WebFlux.fn {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL
 * Suspending function and `Flow` support in RSocket `@MessageMapping` annotated methods
-* Extensions for {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.messaging.rsocket/index.html[`RSocketRequester`]
+* Extensions for {docs-spring-framework}/kdoc-api/spring-messaging/org.springframework.messaging.rsocket/index.html[`RSocketRequester`]

 === Dependencies

@@ -554,7 +556,7 @@ class CoroutinesViewController(banner: Banner) {

 === WebFlux.fn

-Here is an example of Coroutines router defined via the {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL and related handlers.
+Here is an example of Coroutines router defined via the {docs-spring-framework}/kdoc-api/spring-webflux/org.springframework.web.reactive.function.server/co-router.html[coRouter { }] DSL and related handlers.

 [source,kotlin,indent=0]
 ----
@@ -866,7 +868,7 @@ https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-featu

 ==== Constructor injection

-As described in the <<testing#testcontext-junit-jupiter-di#spring-web-reactive, dedicated section>>,
+As described in the <<testing#testcontext-junit-jupiter-di, dedicated section>>,
 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)`]
@@ -44,7 +44,7 @@ parallel, the Spring WebFlux reactive web framework.
 A note about modules: Spring's framework jars allow for deployment to JDK 9's module path
 ("Jigsaw"). For use in Jigsaw-enabled applications, the Spring Framework 5 jars come with
 "Automatic-Module-Name" manifest entries which define stable language-level module names
-("spring.core", "spring.context" etc) independent from jar artifact names (the jars follow
+("spring.core", "spring.context", etc.) independent from jar artifact names (the jars follow
 the same naming pattern with "-" instead of ".", e.g. "spring-core" and "spring-context").
 Of course, Spring's framework jars keep working fine on the classpath on both JDK 8 and 9+.

@@ -56,9 +56,10 @@ Of course, Spring's framework jars keep working fine on the classpath on both JD

 Spring came into being in 2003 as a response to the complexity of the early
 https://en.wikipedia.org/wiki/Java_Platform,_Enterprise_Edition[J2EE] specifications.
-While some consider Java EE and Spring to be in competition, Spring is, in fact, complementary
-to Java EE. The Spring programming model does not embrace the Java EE platform specification;
-rather, it integrates with carefully selected individual specifications from the EE umbrella:
+While some consider Java EE and its modern-day successor Jakarta EE to be in
+competition with Spring, they are in fact complementary. The Spring programming
+model does not embrace the Jakarta EE platform specification; rather, it integrates
+with carefully selected individual specifications from the traditional EE umbrella:

 * Servlet API (https://jcp.org/en/jsr/detail?id=340[JSR 340])
 * WebSocket API (https://www.jcp.org/en/jsr/detail?id=356[JSR 356])
@@ -71,19 +72,22 @@ rather, it integrates with carefully selected individual specifications from the

 The Spring Framework also supports the Dependency Injection
 (https://www.jcp.org/en/jsr/detail?id=330[JSR 330]) and Common Annotations
-(https://jcp.org/en/jsr/detail?id=250[JSR 250]) specifications, which application developers
-may choose to use instead of the Spring-specific mechanisms provided by the Spring Framework.
+(https://jcp.org/en/jsr/detail?id=250[JSR 250]) specifications, which application
+developers may choose to use instead of the Spring-specific mechanisms provided
+by the Spring Framework. Originally, those were based on common `javax` packages.

-As of Spring Framework 5.0, Spring requires the Java EE 7 level (e.g. Servlet 3.1+, JPA 2.1+)
-as a minimum - while at the same time providing out-of-the-box integration with newer APIs
-at the Java EE 8 level (e.g. Servlet 4.0, JSON Binding API) when encountered at runtime.
-This keeps Spring fully compatible with e.g. Tomcat 8 and 9, WebSphere 9, and JBoss EAP 7.
+As of Spring Framework 6.0, Spring has been upgraded to the Jakarta EE 9 level
+(e.g. Servlet 5.0+, JPA 3.0+), based on the `jakarta` namespace instead of the
+traditional `javax` packages. With EE 9 as the minimum and EE 10 supported already,
+Spring is prepared to provide out-of-the-box support for the further evolution of
+the Jakarta EE APIs. Spring Framework 6.0 is fully compatible with Tomcat 10.1,
+Jetty 11 and Undertow 2.3 as web servers, and also with Hibernate ORM 6.1.

-Over time, the role of Java EE in application development has evolved. In the early days of
-Java EE and Spring, applications were created to be deployed to an application server.
-Today, with the help of Spring Boot, applications are created in a devops- and
-cloud-friendly way, with the Servlet container embedded and trivial to change.
-As of Spring Framework 5, a WebFlux application does not even use the Servlet API directly
+Over time, the role of Java/Jakarta EE in application development has evolved. In the
+early days of J2EE and Spring, applications were created to be deployed to an application
+server. Today, with the help of Spring Boot, applications are created in a devops- and
+cloud-friendly way, with the Servlet container embedded and trivial to change. As of
+Spring Framework 5, a WebFlux application does not even use the Servlet API directly
 and can run on servers (such as Netty) that are not Servlet containers.

 Spring continues to innovate and to evolve. Beyond the Spring Framework, there are other
@@ -125,7 +129,7 @@ clean code structure with  no circular dependencies between packages.
 == Feedback and Contributions

 For how-to questions or diagnosing or debugging issues, we suggest using Stack Overflow. Click
-https://stackoverflow.com/questions/tagged/spring+or+spring-mvc+or+spring-aop+or+spring-jdbc+or+spring-r2dbc+or+spring-transactions+or+spring-annotations+or+spring-jms+or+spring-el+or+spring-test+or+spring+or+spring-remoting+or+spring-orm+or+spring-jmx+or+spring-cache+or+spring-webflux+or+spring-rsocket?tab=Newest[here]
+https://stackoverflow.com/questions/tagged/spring+or+spring-mvc+or+spring-aop+or+spring-jdbc+or+spring-r2dbc+or+spring-transactions+or+spring-annotations+or+spring-jms+or+spring-el+or+spring-test+or+spring+or+spring-orm+or+spring-jmx+or+spring-cache+or+spring-webflux+or+spring-rsocket?tab=Newest[here]
 for a list of the suggested tags to use on Stack Overflow. If you're fairly certain that
 there is a problem in the Spring Framework or would like to suggest a feature, please use
 the https://github.com/spring-projects/spring-framework/issues[GitHub Issues].
@@ -2,7 +2,7 @@
 = RSocket
 :gh-rsocket: https://github.com/rsocket
 :gh-rsocket-java: {gh-rsocket}/rsocket-java
-:gh-rsocket-extentions: {gh-rsocket}/rsocket/blob/master/Extensions
+:gh-rsocket-extensions: {gh-rsocket}/rsocket/blob/master/Extensions

 This section describes Spring Framework's support for the RSocket protocol.

@@ -53,7 +53,7 @@ through RSocket across the network.
 === The Protocol

 One of the benefits of RSocket is that it has well defined behavior on the wire and an
-easy to read https://rsocket.io/docs/Protocol[specification] along with some protocol
+easy to read https://rsocket.io/about/protocol[specification] along with some protocol
 {gh-rsocket}/rsocket/tree/master/Extensions[extensions]. Therefore it is
 a good idea to read the spec, independent of language implementations and higher level
 framework APIs. This section provides a succinct overview to establish some context.
@@ -99,9 +99,9 @@ and therefore only included in the first message on a request, i.e. with one of

 Protocol extensions define common metadata formats for use in applications:

-* {gh-rsocket-extentions}/CompositeMetadata.md[Composite Metadata]-- multiple,
+* {gh-rsocket-extensions}/CompositeMetadata.md[Composite Metadata]-- multiple,
  independently formatted metadata entries.
-* {gh-rsocket-extentions}/Routing.md[Routing] -- the route for a request.
+* {gh-rsocket-extensions}/Routing.md[Routing] -- the route for a request.



@@ -218,7 +218,7 @@ established transparently and used.

 For data, the default mime type is derived from the first configured `Decoder`. For
 metadata, the default mime type is
-{gh-rsocket-extentions}/CompositeMetadata.md[composite metadata] which allows multiple
+{gh-rsocket-extensions}/CompositeMetadata.md[composite metadata] which allows multiple
 metadata value and mime type pairs per request. Typically both don't need to be changed.

 Data and metadata in the `SETUP` frame is optional. On the server side,
@@ -291,7 +291,7 @@ infrastructure that's used on a server, but registered programmatically as follo
 ----
 <1> Use `PathPatternRouteMatcher`, if `spring-web` is present, for efficient
    route matching.
-<2> Create a responder from a class with `@MessageMaping` and/or `@ConnectMapping` methods.
+<2> Create a responder from a class with `@MessageMapping` and/or `@ConnectMapping` methods.
 <3> Register the responder.

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -310,7 +310,7 @@ infrastructure that's used on a server, but registered programmatically as follo
 ----
 <1> Use `PathPatternRouteMatcher`, if `spring-web` is present, for efficient
 route matching.
-<2> Create a responder from a class with `@MessageMaping` and/or `@ConnectMapping` methods.
+<2> Create a responder from a class with `@MessageMapping` and/or `@ConnectMapping` methods.
 <3> Register the responder.

 Note the above is only a shortcut designed for programmatic registration of client
@@ -494,7 +494,7 @@ The `data(Object)` step is optional. Skip it for requests that don't send data:
 ----

 Extra metadata values can be added if using
-{gh-rsocket-extentions}/CompositeMetadata.md[composite metadata] (the default) and if the
+{gh-rsocket-extensions}/CompositeMetadata.md[composite metadata] (the default) and if the
 values are supported by a registered `Encoder`. For example:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
@@ -605,8 +605,8 @@ Then start an RSocket server through the Java RSocket API and plug the
 ----

 `RSocketMessageHandler` supports
-{gh-rsocket-extentions}/CompositeMetadata.md[composite] and
-{gh-rsocket-extentions}/Routing.md[routing] metadata by default. You can set its
+{gh-rsocket-extensions}/CompositeMetadata.md[composite] and
+{gh-rsocket-extensions}/Routing.md[routing] metadata by default. You can set its
 <<rsocket-metadata-extractor>> if you need to switch to a
 different mime type or register additional metadata mime types.

@@ -821,7 +821,7 @@ requests to the `RSocketRequester` for the connection. See
 == MetadataExtractor

 Responders must interpret metadata.
-{gh-rsocket-extentions}/CompositeMetadata.md[Composite metadata] allows independently
+{gh-rsocket-extensions}/CompositeMetadata.md[Composite metadata] allows independently
 formatted metadata values (e.g. for routing, security, tracing) each with its own mime
 type. Applications need a way to configure metadata mime types to support, and a way
 to access extracted values.
@@ -832,7 +832,7 @@ in annotated handler methods.

 `DefaultMetadataExtractor` can be given `Decoder` instances to decode metadata. Out of
 the box it has built-in support for
-{gh-rsocket-extentions}/Routing.md["message/x.rsocket.routing.v0"] which it decodes to
+{gh-rsocket-extensions}/Routing.md["message/x.rsocket.routing.v0"] which it decodes to
 `String` and saves under the "route" key. For any other mime type you'll need to provide
 a `Decoder` and register the mime type as follows:

@@ -904,3 +904,79 @@ simply use a callback to customize registrations as follows:
 			}
 			.build()
 ----
+
+
+
+
+[[rsocket-interface]]
+== RSocket Interface
+
+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 <<rsocket-requester>>.
+
+One, declare an interface with `@RSocketExchange` methods:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	interface RadarService {
+
+		@RSocketExchange("radars")
+		Flux<AirportLocation> getRadars(@Payload MapRequest request);
+
+		// more RSocket exchange methods...
+
+	}
+----
+
+Two, create a proxy that will perform the declared RSocket exchanges:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	RSocketRequester requester = ... ;
+	RSocketServiceProxyFactory factory = RSocketServiceProxyFactory.builder(requester).build();
+
+	RepositoryService service = factory.createClient(RadarService.class);
+----
+
+
+[[rsocket-interface-method-parameters]]
+=== Method Parameters
+
+Annotated, RSocket exchange methods support flexible method signatures with the following
+method parameters:
+
+[cols="1,2", options="header"]
+|===
+| Method argument | Description
+
+| `@DestinationVariable`
+| Add a route variable to pass to `RSocketRequester` along with the route from the
+  `@RSocketExchange` annotation in order to expand template placeholders in the route.
+  This variable can be a String or any Object, which is then formatted via `toString()`.
+
+| `@Payload`
+| Set the input payload(s) for the request. This can be a concrete value, or any producer
+  of values that can be adapted to a Reactive Streams `Publisher` via
+  `ReactiveAdapterRegistry`
+
+| `Object`, if followed by `MimeType`
+| The value for a metadata entry in the input payload. This can be any `Object` as long
+  as the next argument is the metadata entry `MimeType`. The value can be a concrete
+  value or any producer of a single value that can be adapted to a Reactive Streams
+  `Publisher` via `ReactiveAdapterRegistry`.
+
+| `MimeType`
+| The `MimeType` for a metadata entry. The preceding method argument is expected to be
+  the metadata value.
+
+|===
+
+
+[[rsocket-interface-return-values]]
+=== Return Values
+
+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`.
@@ -0,0 +1,25 @@
+:noheader:
+= Spring Framework Documentation
+
+include::overview.adoc[leveloffset=+1]
+include::core.adoc[leveloffset=+1]
+include::testing.adoc[leveloffset=+1]
+include::data-access.adoc[leveloffset=+1]
+include::web.adoc[leveloffset=+1]
+include::web-reactive.adoc[leveloffset=+1]
+include::integration.adoc[leveloffset=+1]
+include::languages.adoc[leveloffset=+1]
+include::appendix.adoc[leveloffset=+1]
+
+Rod Johnson, Juergen Hoeller, Keith Donald, Colin Sampaleanu, Rob Harrop, Thomas Risberg,
+Alef Arendsen, Darren Davison, Dmitriy Kopylenko, Mark Pollack, Thierry Templier, Erwin
+Vervaet, Portia Tung, Ben Hale, Adrian Colyer, John Lewis, Costin Leau, Mark Fisher, Sam
+Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clement, Dave
+Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane
+Nicoll, Sebastien Deleuze, Jay Bryant, Mark Paluch
+
+Copyright © 2002 - 2022 VMware, Inc. All Rights Reserved.
+
+Copies of this document may be made for your own use and for distribution to others,
+provided that you do not charge any fee for such copies and further provided that each
+copy contains this Copyright Notice, whether distributed in print or electronically.
@@ -1,7 +1,5 @@
 [[testing]]
 = Testing
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :doc-spring-boot: {doc-root}/spring-boot/docs/current/reference
 :toc: left
 :toclevels: 4
@@ -34,8 +32,8 @@ manual.)
 == Unit Testing

 Dependency injection should make your code less dependent on the container than it would
-be with traditional Java EE development. The POJOs that make up your application should
-be testable in JUnit or TestNG tests, with objects instantiated by using the `new`
+be with traditional J2EE / Java EE development. The POJOs that make up your application
+should be testable in JUnit or TestNG tests, with objects instantiated by using the `new`
 operator, without Spring or any other container. You can use <<mock-objects, mock objects>>
 (in conjunction with other valuable testing techniques) to test your code in isolation.
 If you follow the architecture recommendations for Spring, the resulting clean layering
@@ -80,7 +78,7 @@ out-of-container tests for code that depends on environment-specific properties.
 The `org.springframework.mock.jndi` package contains a partial implementation of the JNDI
 SPI, which you can use to set up a simple JNDI environment for test suites or stand-alone
 applications. If, for example, JDBC `DataSource` instances get bound to the same JNDI
-names in test code as they do in a Java EE container, you can reuse both application code
+names in test code as they do in a Jakarta EE container, you can reuse both application code
 and configuration in testing scenarios without modification.

 WARNING: The mock JNDI support in the `org.springframework.mock.jndi` package is
@@ -94,11 +92,11 @@ parties such as https://github.com/h-thurow/Simple-JNDI[Simple-JNDI].
 The `org.springframework.mock.web` package contains a comprehensive set of Servlet API
 mock objects that are useful for testing web contexts, controllers, and filters. These
 mock objects are targeted at usage with Spring's Web MVC framework and are generally more
-convenient to use than dynamic mock objects (such as http://easymock.org/[EasyMock])
+convenient to use than dynamic mock objects (such as https://easymock.org/[EasyMock])
 or alternative Servlet API mock objects (such as http://www.mockobjects.com[MockObjects]).

-TIP: Since Spring Framework 5.0, the mock objects in `org.springframework.mock.web` are
-based on the Servlet 4.0 API.
+TIP: Since Spring Framework 6.0, the mock objects in `org.springframework.mock.web` are
+based on the Servlet 6.0 API.

 The Spring MVC Test framework builds on the mock Servlet API objects to provide an
 integration testing framework for Spring MVC. See <<spring-mvc-test-framework>>.
@@ -144,11 +142,20 @@ categories:
 The `org.springframework.test.util` package contains several general purpose utilities
 for use in unit and integration testing.

-`ReflectionTestUtils` is a collection of reflection-based utility methods. You can use
-these methods in testing scenarios where you need to change the value of a constant, set
-a non-`public` field, invoke a non-`public` setter method, or invoke a non-`public`
-configuration or lifecycle callback method when testing application code for use cases
-such as the following:
+{api-spring-framework}/test/util/AopTestUtils.html[`AopTestUtils`] is a collection of
+AOP-related utility methods. You can use these methods to obtain a reference to the
+underlying target object hidden behind one or more Spring proxies. For example, if you
+have configured a bean as a dynamic mock by using a library such as EasyMock or Mockito,
+and the mock is wrapped in a Spring proxy, you may need direct access to the underlying
+mock to configure expectations on it and perform verifications. For Spring's core AOP
+utilities, see {api-spring-framework}/aop/support/AopUtils.html[`AopUtils`] and
+{api-spring-framework}/aop/framework/AopProxyUtils.html[`AopProxyUtils`].
+
+{api-spring-framework}/test/util/ReflectionTestUtils.html[`ReflectionTestUtils`] is a
+collection of reflection-based utility methods. You can use these methods in testing
+scenarios where you need to change the value of a constant, set a non-`public` field,
+invoke a non-`public` setter method, or invoke a non-`public` configuration or lifecycle
+callback method when testing application code for use cases such as the following:

 * ORM frameworks (such as JPA and Hibernate) that condone `private` or `protected` field
  access as opposed to `public` setter methods for properties in a domain entity.
@@ -158,14 +165,20 @@ such as the following:
 * Use of annotations such as `@PostConstruct` and `@PreDestroy` for lifecycle callback
  methods.

-{api-spring-framework}/test/util/AopTestUtils.html[`AopTestUtils`] is a collection of
-AOP-related utility methods. You can use these methods to obtain a reference to the
-underlying target object hidden behind one or more Spring proxies. For example, if you
-have configured a bean as a dynamic mock by using a library such as EasyMock or Mockito,
-and the mock is wrapped in a Spring proxy, you may need direct access to the underlying
-mock to configure expectations on it and perform verifications. For Spring's core AOP
-utilities, see {api-spring-framework}/aop/support/AopUtils.html[`AopUtils`] and
-{api-spring-framework}/aop/framework/AopProxyUtils.html[`AopProxyUtils`].
+{api-spring-framework}/test/util/TestSocketUtils.html[`TestSocketUtils`] is a simple
+utility for finding available TCP ports on `localhost` for use in integration testing
+scenarios.
+
+[NOTE]
+====
+`TestSocketUtils` can be used in integration tests which start an external server on an
+available random port. However, these utilities make no guarantee about the subsequent
+availability of a given port and are therefore unreliable. Instead of using
+`TestSocketUtils` to find an available local port for a server, it is recommended that
+you rely on a server's ability to start on a random ephemeral port that it selects or is
+assigned by the operating system. To interact with that server, you should query the
+server for the port it is currently using.
+====


 [[unit-testing-spring-mvc]]
@@ -216,7 +229,7 @@ Doing so lets you test things such as:
 The Spring Framework provides first-class support for integration testing in the
 `spring-test` module. The name of the actual JAR file might include the release version
 and might also be in the long `org.springframework.test` form, depending on where you get
-it from (see the <<core.adoc#dependency-management, section on Dependency Management>>
+it from (see the <<core.adoc#beans-dependencies, section on Dependency Management>>
 for an explanation). This library includes the `org.springframework.test` package, which
 contains valuable classes for integration testing with a Spring container. This testing
 does not rely on an application server or other deployment environment. Such tests are
@@ -500,16 +513,17 @@ The following example shows such a case:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	@ContextConfiguration(initializers = CustomContextIntializer.class) // <1>
+	@ContextConfiguration(initializers = CustomContextInitializer.class) // <1>
 	class ContextInitializerTests {
 		// class body...
 	}
 ----
+<1> Declaring an initializer class.

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	@ContextConfiguration(initializers = [CustomContextIntializer::class]) // <1>
+	@ContextConfiguration(initializers = [CustomContextInitializer::class]) // <1>
 	class ContextInitializerTests {
 		// class body...
 	}
@@ -1099,10 +1113,10 @@ javadoc.
 [[spring-testing-annotation-testexecutionlisteners]]
 ===== `@TestExecutionListeners`

-`@TestExecutionListeners` defines class-level metadata for configuring the
-`TestExecutionListener` implementations that should be registered with the
-`TestContextManager`. Typically, `@TestExecutionListeners` is used in conjunction with
-`@ContextConfiguration`.
+`@TestExecutionListeners` is used to register listeners for a particular test class, its
+subclasses, and its nested classes. If you wish to register a listener globally, you
+should register it via the automatic discovery mechanism described in
+<<testcontext-tel-config>>.

 The following example shows how to register two `TestExecutionListener` implementations:

@@ -1133,7 +1147,9 @@ By default, `@TestExecutionListeners` provides support for inheriting listeners
 superclasses or enclosing classes. See
 <<testcontext-junit-jupiter-nested-test-configuration>> and the 
 {api-spring-framework}/test/context/TestExecutionListeners.html[`@TestExecutionListeners`
-javadoc] for an example and further details.
+javadoc] for an example and further details. If you discover that you need to switch
+back to using the default `TestExecutionListener` implementations, see the note
+in <<testcontext-tel-config-registering-tels>>.

 [[spring-testing-annotation-recordapplicationevents]]
 ===== `@RecordApplicationEvents`
@@ -1477,13 +1493,12 @@ and can be used anywhere in the Spring Framework.
 * `@Autowired`
 * `@Qualifier`
 * `@Value`
-* `@Resource` (javax.annotation) if JSR-250 is present
-* `@ManagedBean` (javax.annotation) if JSR-250 is present
-* `@Inject` (javax.inject) if JSR-330 is present
-* `@Named` (javax.inject) if JSR-330 is present
-* `@PersistenceContext` (javax.persistence) if JPA is present
-* `@PersistenceUnit` (javax.persistence) if JPA is present
-* `@Required`
+* `@Resource` (jakarta.annotation) if JSR-250 is present
+* `@ManagedBean` (jakarta.annotation) if JSR-250 is present
+* `@Inject` (jakarta.inject) if JSR-330 is present
+* `@Named` (jakarta.inject) if JSR-330 is present
+* `@PersistenceContext` (jakarta.persistence) if JPA is present
+* `@PersistenceUnit` (jakarta.persistence) if JPA is present
 * `@Transactional` (org.springframework.transaction.annotation)
  _with <<testcontext-tx-attribute-support, limited attribute support>>_

@@ -1659,8 +1674,10 @@ before failing.
 times that the test method is to be run is specified in the annotation.

 The scope of execution to be repeated includes execution of the test method itself as
-well as any setting up or tearing down of the test fixture. The following example shows
-how to use the `@Repeat` annotation:
+well as any setting up or tearing down of the test fixture. When used with the
+<<testcontext-junit4-rules, `SpringMethodRule`>>, the scope additionally includes
+preparation of the test instance by `TestExecutionListener` implementations. The
+following example shows how to use the `@Repeat` annotation:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1870,7 +1887,7 @@ Spring test configuration annotations are processed within enclosing class hiera
 for inner test classes.

 If `@NestedTestConfiguration` is not present or meta-present on a test class, in its
-super type hierarchy, or in its enclosing class hierarchy, the default _enclosing
+supertype hierarchy, or in its enclosing class hierarchy, the default _enclosing
 configuration inheritance mode_ will be used. See the tip below for details on how to
 change the default mode.

@@ -1959,6 +1976,19 @@ example, you can create a custom `@EnabledOnMac` annotation as follows:
 	annotation class EnabledOnMac {}
 ----

+[NOTE]
+====
+`@EnabledOnMac` is meant only as an example of what is possible. If you have that exact
+use case, please use the built-in `@EnabledOnOs(MAC)` support in JUnit Jupiter.
+====
+
+[WARNING]
+====
+Since JUnit 5.7, JUnit Jupiter also has a condition annotation named `@EnabledIf`. Thus,
+if you wish to use Spring's `@EnabledIf` support make sure you import the annotation type
+from the correct package.
+====
+
 [[integration-testing-annotations-junit-jupiter-disabledif]]
 ===== `@DisabledIf`

@@ -2007,6 +2037,19 @@ example, you can create a custom `@DisabledOnMac` annotation as follows:
 	annotation class DisabledOnMac {}
 ----

+[NOTE]
+====
+`@DisabledOnMac` is meant only as an example of what is possible. If you have that exact
+use case, please use the built-in `@DisabledOnOs(MAC)` support in JUnit Jupiter.
+====
+
+[WARNING]
+====
+Since JUnit 5.7, JUnit Jupiter also has a condition annotation named `@DisabledIf`. Thus,
+if you wish to use Spring's `@DisabledIf` support make sure you import the annotation type
+from the correct package.
+====
+
 [[integration-testing-annotations-meta]]
 ==== Meta-Annotation Support for Testing

@@ -2433,12 +2476,46 @@ by default, exactly in the following order:
 [[testcontext-tel-config-registering-tels]]
 ===== Registering `TestExecutionListener` Implementations

-You can register `TestExecutionListener` implementations for a test class and its
-subclasses by using the `@TestExecutionListeners` annotation. See
+You can register `TestExecutionListener` implementations explicitly for a test class, its
+subclasses, and its nested classes by using the `@TestExecutionListeners` annotation. See
 <<integration-testing-annotations, annotation support>> and the javadoc for
 {api-spring-framework}/test/context/TestExecutionListeners.html[`@TestExecutionListeners`]
 for details and examples.

+.Switching to default `TestExecutionListener` implementations
+[NOTE]
+====
+If you extend a class that is annotated with `@TestExecutionListeners` and you need to
+switch to using the default set of listeners, you can annotate your class with the
+following.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	// Switch to default listeners
+	@TestExecutionListeners(
+		listeners = {},
+		inheritListeners = false,
+		mergeMode = MERGE_WITH_DEFAULTS)
+	class MyTest extends BaseTest {
+		// class body...
+	}
+----
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	// Switch to default listeners
+	@TestExecutionListeners(
+		listeners = [],
+		inheritListeners = false,
+		mergeMode = MERGE_WITH_DEFAULTS)
+	class MyTest : BaseTest {
+		// class body...
+	}
+----
+====
+
 [[testcontext-tel-config-automatic-discovery]]
 ===== Automatic Discovery of Default `TestExecutionListener` Implementations

@@ -2496,7 +2573,7 @@ listeners. The following listing demonstrates this style of configuration:
 	}
 ----

-[source,java,indent=0,subs="verbatim,quotes",role="secondary"]
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	@ContextConfiguration
@@ -2613,7 +2690,7 @@ published while invoking a method in a Spring-managed component:
 			// Invoke method in OrderService that publishes an event
 			orderService.submitOrder(new Order(/* ... */));
 			// Verify that an OrderSubmitted event was published
-			int numEvents = events.stream(OrderSubmitted.class).count(); // <3>
+			long numEvents = events.stream(OrderSubmitted.class).count(); // <3>
 			assertThat(numEvents).isEqualTo(1);
 		}
 	}
@@ -2671,8 +2748,6 @@ test's `ApplicationContext` can listen to the following events published by the
 * `AfterTestMethodEvent`
 * `AfterTestClassEvent`

-NOTE: These events are only published if the `ApplicationContext` has already been loaded.
-
 These events may be consumed for various reasons, such as resetting mock beans or tracing
 test execution. One advantage of consuming test execution events rather than implementing
 a custom `TestExecutionListener` is that test execution events may be consumed by any
@@ -2680,6 +2755,32 @@ Spring bean registered in the test `ApplicationContext`, and such beans may bene
 directly from dependency injection and other features of the `ApplicationContext`. In
 contrast, a `TestExecutionListener` is not a bean in the `ApplicationContext`.

+[NOTE]
+====
+The `EventPublishingTestExecutionListener` is registered by default; however, it only
+publishes events if the `ApplicationContext` has _already been loaded_. This prevents the
+`ApplicationContext` from being loaded unnecessarily or too early.
+
+Consequently, a `BeforeTestClassEvent` will not be published until after the
+`ApplicationContext` has been loaded by another `TestExecutionListener`. For example, with
+the default set of `TestExecutionListener` implementations registered, a
+`BeforeTestClassEvent` will not be published for the first test class that uses a
+particular test `ApplicationContext`, but a `BeforeTestClassEvent` _will_ be published for
+any subsequent test class in the same test suite that uses the same test
+`ApplicationContext` since the context will already have been loaded when subsequent test
+classes run (as long as the context has not been removed from the `ContextCache` via
+`@DirtiesContext` or the max-size eviction policy).
+
+If you wish to ensure that a `BeforeTestClassEvent` is always published for every test
+class, you need to register a `TestExecutionListener` that loads the `ApplicationContext`
+in the `beforeTestClass` callback, and that `TestExecutionListener` must be registered
+_before_ the `EventPublishingTestExecutionListener`.
+
+Similarly, if `@DirtiesContext` is used to remove the `ApplicationContext` from the
+context cache after the last test method in a given test class, the `AfterTestClassEvent`
+will not be published for that test class.
+====
+
 In order to listen to test execution events, a Spring bean may choose to implement the
 `org.springframework.context.ApplicationListener` interface. Alternatively, listener
 methods can be annotated with `@EventListener` and configured to listen to one of the
@@ -3087,7 +3188,7 @@ The term "`component class`" can refer to any of the following:

 * A class annotated with `@Configuration`.
 * A component (that is, a class annotated with `@Component`, `@Service`, `@Repository`, or other stereotype annotations).
-* A JSR-330 compliant class that is annotated with `javax.inject` annotations.
+* A JSR-330 compliant class that is annotated with `jakarta.inject` annotations.
 * Any class that contains `@Bean`-methods.
 * Any other class that is intended to be registered as a Spring component (i.e., a Spring
  bean in the `ApplicationContext`), potentially taking advantage of automatic autowiring
@@ -4244,7 +4345,7 @@ properties.

 		@DynamicPropertySource
 		static void redisProperties(DynamicPropertyRegistry registry) {
-			registry.add("redis.host", redis::getContainerIpAddress);
+			registry.add("redis.host", redis::getHost);
 			registry.add("redis.port", redis::getMappedPort);
 		}

@@ -4268,7 +4369,7 @@ properties.
 			@DynamicPropertySource
 			@JvmStatic
 			fun redisProperties(registry: DynamicPropertyRegistry) {
-				registry.add("redis.host", redis::getContainerIpAddress)
+				registry.add("redis.host", redis::getHost)
 				registry.add("redis.port", redis::getMappedPort)
 			}
 		}
@@ -4428,8 +4529,9 @@ annotations by specifying a Spring resource prefix:

 Contrast the comments in this example with the previous example.

-.[[testcontext-ctx-management-web-mocks]]Working with Web Mocks
--
+[[testcontext-ctx-management-web-mocks]]
+===== Working with Web Mocks
+
 To provide comprehensive web testing support, the TestContext framework has a
 `ServletTestExecutionListener` that is enabled by default. When testing against a
 `WebApplicationContext`, this <<testcontext-key-abstractions, `TestExecutionListener`>>
@@ -4503,7 +4605,6 @@ managed per test method by the `ServletTestExecutionListener`.
 		//...
 	}
 ----
--

 [[testcontext-ctx-management-caching]]
 ===== Context Caching
@@ -4658,7 +4759,7 @@ have different levels in a context hierarchy configured using different resource
 The remaining JUnit Jupiter based examples in this section show common configuration
 scenarios for integration tests that require the use of context hierarchies.

-.Single test class with context hierarchy
+**Single test class with context hierarchy**
 --
 `ControllerIntegrationTests` represents a typical integration testing scenario for a
 Spring MVC web application by declaring a context hierarchy that consists of two levels,
@@ -4704,8 +4805,7 @@ lowest context in the hierarchy). The following listing shows this configuration
 ----
 --

-
-.Class hierarchy with implicit parent context
+**Class hierarchy with implicit parent context**
 --
 The test classes in this example define a context hierarchy within a test class
 hierarchy. `AbstractWebTests` declares the configuration for a root
@@ -4751,7 +4851,7 @@ configuration scenario:
 ----
 --

-.Class hierarchy with merged context hierarchy configuration
+**Class hierarchy with merged context hierarchy configuration**
 --
 The classes in this example show the use of named hierarchy levels in order to merge the
 configuration for specific levels in a context hierarchy. `BaseTests` defines two levels
@@ -4797,7 +4897,7 @@ The following listing shows this configuration scenario:
 ----
 --

-.Class hierarchy with overridden context hierarchy configuration
+**Class hierarchy with overridden context hierarchy configuration**
 --
 In contrast to the previous example, this example demonstrates how to override the
 configuration for a given named level in a context hierarchy by setting the
@@ -5623,7 +5723,6 @@ following example shows the relevant annotations:

 [[testcontext-tx-false-positives]]
 .Avoid false positives when testing ORM code
-
 [NOTE]
 =====
 When you test application code that manipulates the state of a Hibernate session or JPA
@@ -5745,6 +5844,86 @@ The following example shows matching methods for JPA:
 ----
 =====

+[[testcontext-tx-orm-lifecycle-callbacks]]
+.Testing ORM entity lifecycle callbacks
+[NOTE]
+=====
+Similar to the note about avoiding <<testcontext-tx-false-positives, false positives>>
+when testing ORM code, if your application makes use of entity lifecycle callbacks (also
+known as entity listeners), make sure to flush the underlying unit of work within test
+methods that run that code. Failing to _flush_ or _clear_ the underlying unit of work can
+result in certain lifecycle callbacks not being invoked.
+
+For example, when using JPA, `@PostPersist`, `@PreUpdate`, and `@PostUpdate` callbacks
+will not be called unless `entityManager.flush()` is invoked after an entity has been
+saved or updated. Similarly, if an entity is already attached to the current unit of work
+(associated with the current persistence context), an attempt to reload the entity will
+not result in a `@PostLoad` callback unless `entityManager.clear()` is invoked before the
+attempt to reload the entity.
+
+The following example shows how to flush the `EntityManager` to ensure that
+`@PostPersist` callbacks are invoked when an entity is persisted. An entity listener with
+a `@PostPersist` callback method has been registered for the `Person` entity used in the
+example.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	// ...
+
+	@Autowired
+	JpaPersonRepository repo;
+
+	@PersistenceContext
+	EntityManager entityManager;
+
+	@Transactional
+	@Test
+	void savePerson() {
+		// EntityManager#persist(...) results in @PrePersist but not @PostPersist
+		repo.save(new Person("Jane"));
+
+		// Manual flush is required for @PostPersist callback to be invoked
+		entityManager.flush();
+
+		// Test code that relies on the @PostPersist callback
+		// having been invoked...
+	}
+
+	// ...
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	// ...
+
+	@Autowired
+	lateinit var repo: JpaPersonRepository
+
+	@PersistenceContext
+	lateinit var entityManager: EntityManager
+
+	@Transactional
+	@Test
+	fun savePerson() {
+		// EntityManager#persist(...) results in @PrePersist but not @PostPersist
+		repo.save(Person("Jane"))
+
+		// Manual flush is required for @PostPersist callback to be invoked
+		entityManager.flush()
+
+		// Test code that relies on the @PostPersist callback
+		// having been invoked...
+	}
+
+	// ...
+----
+
+See
+https://github.com/spring-projects/spring-framework/blob/main/spring-test/src/test/java/org/springframework/test/context/junit/jupiter/orm/JpaEntityListenerTests.java[JpaEntityListenerTests]
+in the Spring Framework test suite for working examples using all JPA lifecycle callbacks.
+=====
+

 [[testcontext-executing-sql]]
 ==== Executing SQL Scripts
@@ -6803,6 +6982,65 @@ classes by using `@ContextConfiguration`, `@TestExecutionListeners`, and so on a
 manually instrumenting your test class with a `TestContextManager`. See the source code
 of `AbstractTestNGSpringContextTests` for an example of how to instrument your test class.

+[[testcontext-aot]]
+==== Ahead of Time Support for Tests
+
+This chapter covers Spring's Ahead of Time (AOT) support for integration tests using the
+Spring TestContext Framework.
+
+The testing support extends Spring's <<core.adoc#aot,core AOT support>> with the
+following features.
+
+* Build-time detection of all integration tests in the current project that use the
+  TestContext framework to load an `ApplicationContext`.
+  - Provides explicit support for test classes based on JUnit Jupiter and JUnit 4 as well
+    as implicit support for TestNG and other testing frameworks that use Spring's core
+    testing annotations -- as long as the tests are run using a JUnit Platform
+    `TestEngine` that is registered for the current project.
+* Build-time AOT processing: each unique test `ApplicationContext` in the current project
+  will be <<core.adoc#aot-refresh,refreshed for AOT processing>>.
+* Runtime AOT support: when executing in AOT runtime mode, a Spring integration test will
+  use an AOT-optimized `ApplicationContext` that participates transparently with the
+  <<testcontext-ctx-management-caching, context cache>>.
+
+[WARNING]
+====
+The `@ContextHierarchy` annotation is currently not supported in AOT mode.
+====
+
+To provide test-specific runtime hints for use within a GraalVM native image, you have
+the following options.
+
+* Implement a custom
+  {api-spring-framework}/test/context/aot/TestRuntimeHintsRegistrar.html[`TestRuntimeHintsRegistrar`]
+  and register it globally via `META-INF/spring/aot.factories`.
+* Implement a custom {api-spring-framework}/aot/hint/RuntimeHintsRegistrar.html[`RuntimeHintsRegistrar`]
+  and register it globally via `META-INF/spring/aot.factories` or locally on a test class
+  via {api-spring-framework}/context/annotation/ImportRuntimeHints.html[`@ImportRuntimeHints`].
+* Annotate a test class with {api-spring-framework}/aot/hint/annotation/Reflective.html[`@Reflective`] or
+  {api-spring-framework}/aot/hint/annotation/RegisterReflectionForBinding.html[`@RegisterReflectionForBinding`].
+* See <<core.adoc#aot-hints,Runtime Hints>> for details on Spring's core runtime hints
+  and annotation support.
+
+[TIP]
+====
+The `TestRuntimeHintsRegistrar` API serves as a companion to the core
+`RuntimeHintsRegistrar` API. If you need to register global hints for testing support
+that are not specific to particular test classes, favor implementing
+`RuntimeHintsRegistrar` over the test-specific API.
+====
+
+If you implement a custom `ContextLoader`, it must implement
+{api-spring-framework}/test/context/aot/AotContextLoader.html[`AotContextLoader`] in
+order to provide AOT build-time processing and AOT runtime execution support. Note,
+however, that all context loader implementations provided by the Spring Framework and
+Spring Boot already implement `AotContextLoader`.
+
+If you implement a custom `TestExecutionListener`, it must implement
+{api-spring-framework}/test/context/aot/AotTestExecutionListener.html[`AotTestExecutionListener`]
+in order to participate in AOT processing. See the `SqlScriptsTestExecutionListener` in
+the `spring-test` module for an example.
+


 include::testing/testing-webtestclient.adoc[leveloffset=+2]
@@ -6834,7 +7072,7 @@ do they involve any of the supporting `@InitBinder`, `@ModelAttribute`, or

 The Spring MVC Test framework, also known as `MockMvc`, aims to provide more complete
 testing for Spring MVC controllers without a running server. It does that by invoking
-the `DispacherServlet` and passing
+the `DispatcherServlet` and passing
 <<mock-objects-servlet, "`mock`" implementations of the Servlet API>> from the
 `spring-test` module which replicates the full Spring MVC request handling without
 a running server.
@@ -6922,7 +7160,7 @@ To set up MockMvc through Spring configuration, use the following:

 		@BeforeEach
 		void setup(WebApplicationContext wac) {
-			this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
+			this.mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
 		}

 		// ...
@@ -7219,8 +7457,9 @@ they must be specified on every request.
 [[spring-mvc-test-server-defining-expectations]]
 ===== Defining Expectations

-You can define expectations by appending one or more `.andExpect(..)` calls after
-performing a request, as the following example shows:
+You can define expectations by appending one or more `andExpect(..)` calls after
+performing a request, as the following example shows. As soon as one expectation fails,
+no other expectations will be asserted.

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -7236,10 +7475,25 @@ performing a request, as the following example shows:
 	import org.springframework.test.web.servlet.get

 	mockMvc.get("/accounts/1").andExpect {
-		status().isOk()
+		status { isOk() }
 	}
 ----

+You can define multiple expectations by appending `andExpectAll(..)` after performing a
+request, as the following example shows. In contrast to `andExpect(..)`,
+`andExpectAll(..)` guarantees that all supplied expectations will be asserted and that
+all failures will be tracked and reported.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	// static import of MockMvcRequestBuilders.* and MockMvcResultMatchers.*
+
+	mockMvc.perform(get("/accounts/1")).andExpectAll(
+		status().isOk(),
+		content().contentType("application/json;charset=UTF-8"));
+----
+
 `MockMvcResultMatchers.*` provides a number of expectations, some of which are further
 nested with more detailed expectations.

@@ -7269,7 +7523,7 @@ The following test asserts that binding or validation failed:
 	import org.springframework.test.web.servlet.post

 	mockMvc.post("/persons").andExpect {
-		status().isOk()
+		status { isOk() }
 		model {
 			attributeHasErrors("person")
 		}
@@ -7297,7 +7551,7 @@ request. You can do so as follows, where `print()` is a static import from
 	mockMvc.post("/persons").andDo {
 			print()
 		}.andExpect {
-			status().isOk()
+			status { isOk() }
 			model {
 				attributeHasErrors("person")
 			}
@@ -7327,7 +7581,7 @@ other expectations, as the following example shows:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	var mvcResult = mockMvc.post("/persons").andExpect { status().isOk() }.andReturn()
+	var mvcResult = mockMvc.post("/persons").andExpect { status { isOk() } }.andReturn()
 	// ...
 ----

@@ -7407,10 +7661,10 @@ If using MockMvc through the <<webtestclient>>, there is nothing special to do t
 asynchronous requests work as the `WebTestClient` automatically does what is described
 in this section.

-Servlet 3.0 asynchronous requests,
-<<web.adoc#mvc-ann-async,supported in Spring MVC>>, work by exiting the Servlet container
-thread and allowing the application to compute the response asynchronously, after which
-an async dispatch is made to complete processing on a Servlet container thread.
+Servlet asynchronous requests, <<web.adoc#mvc-ann-async,supported in Spring MVC>>,
+work by exiting the Servlet container thread and allowing the application to compute
+the response asynchronously, after which an async dispatch is made to complete
+processing on a Servlet container thread.

 In Spring MVC Test, async requests can be tested by asserting the produced async value
 first, then manually performing the async dispatch, and finally verifying the response.
@@ -7447,7 +7701,7 @@ or reactive type such as Reactor `Mono`:
 	@Test
 	fun test() {
 		var mvcResult = mockMvc.get("/path").andExpect {
-			status().isOk() // <1>
+			status { isOk() } // <1>
 			request { asyncStarted() } // <2>
 			// TODO Remove unused generic parameter
 			request { asyncResult<Nothing>("body") } // <3>
@@ -7456,7 +7710,7 @@ or reactive type such as Reactor `Mono`:

 		mockMvc.perform(asyncDispatch(mvcResult)) // <4>
 				.andExpect {
-					status().isOk() // <5>
+					status { isOk() } // <5>
 					content().string("body")
 				}
 	}
@@ -7583,13 +7837,13 @@ WebTestClient]. Browse these examples for further ideas.
 ==== HtmlUnit Integration

 Spring provides integration between <<spring-mvc-test-server, MockMvc>> and
-http://htmlunit.sourceforge.net/[HtmlUnit]. This simplifies performing end-to-end testing
+https://htmlunit.sourceforge.io/[HtmlUnit]. This simplifies performing end-to-end testing
 when using HTML-based views. This integration lets you:

 * Easily test HTML pages by using tools such as
-  http://htmlunit.sourceforge.net/[HtmlUnit],
+  https://htmlunit.sourceforge.io/[HtmlUnit],
  https://www.seleniumhq.org[WebDriver], and
-  http://www.gebish.org/manual/current/#spock-junit-testng[Geb] without the need to
+  https://www.gebish.org/manual/current/#spock-junit-testng[Geb] without the need to
  deploy to a Servlet container.
 * Test JavaScript within pages.
 * Optionally, test using mock services to speed up testing.
@@ -7916,11 +8170,11 @@ First, we no longer have to explicitly verify our form and then create a request
 looks like the form. Instead, we request the form, fill it out, and submit it, thereby
 significantly reducing the overhead.

-Another important factor is that http://htmlunit.sourceforge.net/javascript.html[HtmlUnit
+Another important factor is that https://htmlunit.sourceforge.io/javascript.html[HtmlUnit
 uses the Mozilla Rhino engine] to evaluate JavaScript. This means that we can also test
 the behavior of JavaScript within our pages.

-See the http://htmlunit.sourceforge.net/gettingStarted.html[HtmlUnit documentation] for
+See the https://htmlunit.sourceforge.io/gettingStarted.html[HtmlUnit documentation] for
 additional information about using HtmlUnit.

 [[spring-mvc-test-server-htmlunit-mah-advanced-builder]]
@@ -8527,7 +8781,7 @@ TIP: For additional information on creating a `MockMvc` instance, see
 ===== MockMvc and Geb

 In the previous section, we saw how to use MockMvc with WebDriver. In this section, we
-use http://www.gebish.org/[Geb] to make our tests even Groovy-er.
+use https://www.gebish.org/[Geb] to make our tests even Groovy-er.

 [[spring-mvc-test-server-htmlunit-geb-why]]
 ====== Why Geb and MockMvc?
@@ -8630,7 +8884,7 @@ if we were at the wrong page.

 Next, we create a `content` closure that specifies all the areas of interest within the
 page. We can use a
-http://www.gebish.org/manual/current/#the-jquery-ish-navigator-api[jQuery-ish Navigator
+https://www.gebish.org/manual/current/#the-jquery-ish-navigator-api[jQuery-ish Navigator
 API] to select the content in which we are interested.

 Finally, we can verify that a new message was created successfully, as follows:
@@ -8647,7 +8901,7 @@ message == expectedMessage
 ----

 For further details on how to get the most out of Geb, see
-http://www.gebish.org/manual/current/[The Book of Geb] user's manual.
+https://www.gebish.org/manual/current/[The Book of Geb] user's manual.


 [[spring-mvc-test-client]]
@@ -1,7 +1,5 @@
 [[webtestclient]]
 = WebTestClient
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework

 `WebTestClient` is an HTTP client designed for testing server applications. It wraps
 Spring's <<web-reactive.adoc#webflux-client, WebClient>> and uses it to perform requests
@@ -47,7 +45,7 @@ to handle requests:
 ----

 For Spring MVC, use the following which delegates to the
-{api-spring-framework}/https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/test/web/servlet/setup/StandaloneMockMvcBuilder.html[StandaloneMockMvcBuilder]
+{api-spring-framework}/test/web/servlet/setup/StandaloneMockMvcBuilder.html[StandaloneMockMvcBuilder]
 to load infrastructure equivalent to the <<web.adoc#mvc-config, WebMvc Java config>>,
 registers the given controller(s), and creates an instance of
 <<testing.adoc#spring-mvc-test-framework, MockMvc>> to handle requests:
@@ -264,19 +262,36 @@ To assert the response status and headers, use the following:
 .Java
 ----
 	client.get().uri("/persons/1")
-				.accept(MediaType.APPLICATION_JSON)
-				.exchange()
-				.expectStatus().isOk()
-				.expectHeader().contentType(MediaType.APPLICATION_JSON)
+		.accept(MediaType.APPLICATION_JSON)
+		.exchange()
+		.expectStatus().isOk()
+		.expectHeader().contentType(MediaType.APPLICATION_JSON);
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	client.get().uri("/persons/1")
-			.accept(MediaType.APPLICATION_JSON)
-			.exchange()
-			.expectStatus().isOk()
-			.expectHeader().contentType(MediaType.APPLICATION_JSON)
+		.accept(MediaType.APPLICATION_JSON)
+		.exchange()
+		.expectStatus().isOk()
+		.expectHeader().contentType(MediaType.APPLICATION_JSON)
+----
+
+If you would like for all expectations to be asserted even if one of them fails, you can
+use `expectAll(..)` instead of multiple chained `expect*(..)` calls. This feature is
+similar to the _soft assertions_ support in AssertJ and the `assertAll()` support in
+JUnit Jupiter.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	client.get().uri("/persons/1")
+		.accept(MediaType.APPLICATION_JSON)
+		.exchange()
+		.expectAll(
+			spec -> spec.expectStatus().isOk(),
+			spec -> spec.expectHeader().contentType(MediaType.APPLICATION_JSON)
+		);
 ----

 You can then choose to decode the response body through one of the following:
@@ -1,7 +1,5 @@
 [[spring-web-reactive]]
 = Web on Reactive Stack
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :toc: left
 :toclevels: 4
 :tabsize: 4
@@ -9,7 +7,7 @@

 This part of the documentation covers support for reactive-stack web applications built
 on a https://www.reactive-streams.org/[Reactive Streams] API to run on non-blocking
-servers, such as Netty, Undertow, and Servlet 3.1+ containers. Individual chapters cover
+servers, such as Netty, Undertow, and Servlet containers. Individual chapters cover
 the <<webflux.adoc#webflux, Spring WebFlux>> framework,
 the reactive <<webflux-client, `WebClient`>>, support for <<webflux-test, testing>>,
 and <<webflux-reactive-libraries, reactive libraries>>. For Servlet-stack web applications,
@@ -19,6 +17,18 @@ include::web/webflux.adoc[leveloffset=+1]

 include::web/webflux-webclient.adoc[leveloffset=+1]

+
+[[webflux-http-interface-client]]
+== HTTP Interface Client
+
+The Spring Frameworks lets you define an HTTP service as a Java interface with HTTP
+exchange methods. You can then generate a proxy that implements this interface and
+performs the exchanges. This helps to simplify HTTP remote access and provides additional
+flexibility for to choose an API style such as synchronous or reactive.
+
+See <<integration.adoc#rest-http-interface, REST Endpoints>> for details.
+
+
 include::web/webflux-websocket.adoc[leveloffset=+1]


@@ -36,8 +46,6 @@ discussion of mock objects.
 response objects to provide support for testing WebFlux applications without an HTTP
 server. You can use the `WebTestClient` for end-to-end integration tests, too.

-
-
 include::rsocket.adoc[leveloffset=+1]


@@ -57,14 +65,8 @@ For annotated controllers, WebFlux transparently adapts to the reactive library
 the application. This is done with the help of the
 {api-spring-framework}/core/ReactiveAdapterRegistry.html[`ReactiveAdapterRegistry`], which
 provides pluggable support for reactive library and other asynchronous types. The registry
-has built-in support for RxJava 2/3, RxJava 1 (via RxJava Reactive Streams bridge), and
-`CompletableFuture`, but you can register others, too.
-
-[NOTE]
-====
-As of Spring Framework 5.3, support for RxJava 1 is deprecated.
-====
-
+has built-in support for RxJava 3, Kotlin coroutines and SmallRye Mutiny, but you can
+register others, too.

 For functional APIs (such as <<webflux-fn>>, the `WebClient`, and others), the general rules
 for WebFlux APIs apply -- `Flux` and `Mono` as return values and a Reactive Streams
@@ -1,7 +1,5 @@
 [[spring-web]]
 = Web on Servlet Stack
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :toc: left
 :toclevels: 4
 :tabsize: 4
@@ -29,14 +29,14 @@ entry points into a server-side application, and it delegates to service objects
 (facades) that are defined in a service layer to satisfy business-specific (and
 presentation-technology agnostic) use cases. In Spring, these service objects, any other
 business-specific objects, data-access objects, and others exist in a distinct "`business
-context`", which contains no web or presentation layer objects (presentation objects
-,such as Spring MVC controllers, are typically configured in a distinct "`presentation
+context`", which contains no web or presentation layer objects (presentation objects,
+such as Spring MVC controllers, are typically configured in a distinct "`presentation
 context`"). This section details how you can configure a Spring container (a
 `WebApplicationContext`) that contains all of the 'business beans' in your application.

-Moving on to specifics, all you one need to do is declare a
+Moving on to specifics, all you need to do is declare a
 {api-spring-framework}/web/context/ContextLoaderListener.html[`ContextLoaderListener`]
-in the standard Java EE servlet `web.xml` file of your web application and add a
+in the standard Jakarta EE servlet `web.xml` file of your web application and add a
 `contextConfigLocation`<context-param/> section (in the same file) that defines which
 set of Spring XML configuration files to load.

@@ -102,7 +102,7 @@ on its specific integration strategies.
 == JSF

 JavaServer Faces (JSF) is the JCP's standard component-based, event-driven web
-user interface framework. It is an official part of the Java EE umbrella but also
+user interface framework. It is an official part of the Jakarta EE umbrella but also
 individually usable, e.g. through embedding Mojarra or MyFaces within Tomcat.

 Please note that recent versions of JSF became closely tied to CDI infrastructure
@@ -0,0 +1,95 @@
+In the context of web applications, _data binding_ involves the binding of HTTP request
+parameters (that is, form data or query parameters) to properties in a model object and
+its nested objects.
+
+Only `public` properties following the
+https://www.oracle.com/java/technologies/javase/javabeans-spec.html[JavaBeans naming conventions]
+are exposed for data binding — for example, `public String getFirstName()` and
+`public void setFirstName(String)` methods for a `firstName` property.
+
+TIP: The model object, and its nested object graph, is also sometimes referred to as a
+_command object_, _form-backing object_, or _POJO_ (Plain Old Java Object).
+
+By default, Spring permits binding to all public properties in the model object graph.
+This means you need to carefully consider what public properties the model has, since a
+client could target any public property path, even some that are not expected to be
+targeted for a given use case.
+
+For example, given an HTTP form data endpoint, a malicious client could supply values for
+properties that exist in the model object graph but are not part of the HTML form
+presented in the browser. This could lead to data being set on the model object and any
+of its nested objects, that is not expected to be updated.
+
+The recommended approach is to use a _dedicated model object_ that exposes only
+properties that are relevant for the form submission. For example, on a form for changing
+a user's email address, the model object should declare a minimum set of properties such
+as in the following `ChangeEmailForm`.
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	public class ChangeEmailForm {
+
+		private String oldEmailAddress;
+		private String newEmailAddress;
+
+		public void setOldEmailAddress(String oldEmailAddress) {
+			this.oldEmailAddress = oldEmailAddress;
+		}
+
+		public String getOldEmailAddress() {
+			return this.oldEmailAddress;
+		}
+
+		public void setNewEmailAddress(String newEmailAddress) {
+			this.newEmailAddress = newEmailAddress;
+		}
+
+		public String getNewEmailAddress() {
+			return this.newEmailAddress;
+		}
+
+	}
+----
+
+If you cannot or do not want to use a _dedicated model object_ for each data
+binding use case, you **must** limit the properties that are allowed for data binding.
+Ideally, you can achieve this by registering _allowed field patterns_ via the
+`setAllowedFields()` method on `WebDataBinder`.
+
+For example, to register allowed field patterns in your application, you can implement an
+`@InitBinder` method in a `@Controller` or `@ControllerAdvice` component as shown below:
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	@Controller
+	public class ChangeEmailController {
+
+		@InitBinder
+		void initBinder(WebDataBinder binder) {
+			binder.setAllowedFields("oldEmailAddress", "newEmailAddress");
+		}
+
+		// @RequestMapping methods, etc.
+
+	}
+----
+
+In addition to registering allowed patterns, it is also possible to register _disallowed
+field patterns_ via the `setDisallowedFields()` method in `DataBinder` and its subclasses.
+Please note, however, that an "allow list" is safer than a "deny list". Consequently,
+`setAllowedFields()` should be favored over `setDisallowedFields()`.
+
+Note that matching against allowed field patterns is case-sensitive; whereas, matching
+against disallowed field patterns is case-insensitive. In addition, a field matching a
+disallowed pattern will not be accepted even if it also happens to match a pattern in the
+allowed list.
+
+[WARNING]
+====
+It is extremely important to properly configure allowed and disallowed field patterns
+when exposing your domain model directly for data binding purposes. Otherwise, it is a
+big security risk.
+
+Furthermore, it is strongly recommended that you do **not** use types from your domain
+model such as JPA or Hibernate entities as the model object in data binding scenarios.
+====
@@ -1,4 +1,4 @@
-[[web-uricomponents]]
+[id={chapter}.web-uricomponents]
 = UriComponents
 [.small]#Spring MVC and Spring WebFlux#

@@ -95,18 +95,17 @@ You can shorten it further still with a full URI template, as the following exam
 .Kotlin
 ----
 	val uri = UriComponentsBuilder
-		.fromUriString("https://example.com/hotels/{hotel}?q={q}")
-		.build("Westin", "123")
+			.fromUriString("https://example.com/hotels/{hotel}?q={q}")
+			.build("Westin", "123")
 ----



-
-[[web-uribuilder]]
+[id={chapter}.web-uribuilder]
 = UriBuilder
 [.small]#Spring MVC and Spring WebFlux#

-<<web-uricomponents, `UriComponentsBuilder`>> implements `UriBuilder`. You can create a
+<<{chapter}.web-uricomponents, `UriComponentsBuilder`>> implements `UriBuilder`. You can create a
 `UriBuilder`, in turn, with a `UriBuilderFactory`. Together, `UriBuilderFactory` and
 `UriBuilder` provide a pluggable mechanism to build URIs from URI templates, based on
 shared configuration, such as a base URL, encoding preferences, and other details.
@@ -194,8 +193,7 @@ that holds configuration and preferences, as the following example shows:
 ----


-
-[[web-uri-encoding]]
+[id={chapter}.web-uri-encoding]
 = URI Encoding
 [.small]#Spring MVC and Spring WebFlux#

@@ -278,7 +276,7 @@ You can shorten it further still with a full URI template, as the following exam
 ----

 The `WebClient` and the `RestTemplate` expand and encode URI templates internally through
-the `UriBuilderFactory` strategy. Both can be configured with a custom strategy.
+the `UriBuilderFactory` strategy. Both can be configured with a custom strategy,
 as the following example shows:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
@@ -1,5 +1,6 @@
 [[webflux-cors]]
 = CORS
+:doc-spring-security: {doc-root}/spring-security/reference
 [.small]#<<web.adoc#mvc-cors, Web MVC>>#

 Spring WebFlux lets you handle CORS (Cross-Origin Resource Sharing). This section
@@ -309,9 +310,8 @@ You can apply CORS support through the built-in
 good fit with <<webflux-fn, functional endpoints>>.

 NOTE: If you try to use the `CorsFilter` with Spring Security, keep in mind that Spring
-Security has
-https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#cors[built-in support]
-for CORS.
+Security has {doc-spring-security}/servlet/integrations/cors.html[built-in support] for
+CORS.

 To configure the filter, you can declare a `CorsWebFilter` bean and pass a
 `CorsConfigurationSource` to its constructor, as the following example shows:
@@ -40,7 +40,7 @@ as the following example shows:
 	PersonRepository repository = ...
 	PersonHandler handler = new PersonHandler(repository);

-	RouterFunction<ServerResponse> route = route()
+	RouterFunction<ServerResponse> route = route() <1>
 		.GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson)
 		.GET("/person", accept(APPLICATION_JSON), handler::listPeople)
 		.POST("/person", handler::createPerson)
@@ -64,6 +64,7 @@ as the following example shows:
 		}
 	}
 ----
+<1> Create router using `route()`.

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
@@ -145,7 +146,7 @@ val string = request.awaitBody<String>()


 The following example extracts the body to a `Flux<Person>` (or a `Flow<Person>` in Kotlin),
-where `Person` objects are decoded from someserialized form, such as JSON or XML:
+where `Person` objects are decoded from some serialized form, such as JSON or XML:

 [source,java,role="primary"]
 .Java
@@ -202,20 +203,63 @@ Mono<MultiValueMap<String, Part>> map = request.multipartData();
 val map = request.awaitMultipartData()
 ----

-The following example shows how to access multiparts, one at a time, in streaming fashion:
+The following example shows how to access multipart data, one at a time, in streaming fashion:

-[source,java,role="primary"]
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-Flux<Part> parts = request.body(BodyExtractors.toParts());
+Flux<PartEvent> allPartEvents = request.bodyToFlux(PartEvent.class);
+allPartsEvents.windowUntil(PartEvent::isLast)
+      .concatMap(p -> p.switchOnFirst((signal, partEvents) -> {
+          if (signal.hasValue()) {
+              PartEvent event = signal.get();
+              if (event instanceof FormPartEvent formEvent) {
+                  String value = formEvent.value();
+                  // handle form field
+              }
+              else if (event instanceof FilePartEvent fileEvent) {
+                  String filename = fileEvent.filename();
+                  Flux<DataBuffer> contents = partEvents.map(PartEvent::content);
+                  // handle file upload
+              }
+              else {
+                  return Mono.error(new RuntimeException("Unexpected event: " + event));
+              }
+          }
+          else {
+              return partEvents; // either complete or error signal
+          }
+      }));
 ----
-[source,kotlin,role="secondary"]
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-val parts = request.body(BodyExtractors.toParts()).asFlow()
+val parts = request.bodyToFlux<PartEvent>()
+allPartsEvents.windowUntil(PartEvent::isLast)
+    .concatMap {
+        it.switchOnFirst { signal, partEvents ->
+            if (signal.hasValue()) {
+                val event = signal.get()
+                if (event is FormPartEvent) {
+                    val value: String = event.value();
+                    // handle form field
+                } else if (event is FilePartEvent) {
+                    val filename: String = event.filename();
+                    val contents: Flux<DataBuffer> = partEvents.map(PartEvent::content);
+                    // handle file upload
+                } else {
+                    return Mono.error(RuntimeException("Unexpected event: " + event));
+                }
+            } else {
+                return partEvents; // either complete or error signal
+            }
+        }
+    }
+}
 ----

-
+Note that the body contents of the `PartEvent` objects must be completely consumed, relayed, or released to avoid memory leaks.

 [[webflux-fn-response]]
 === ServerResponse
@@ -590,10 +634,10 @@ RouterFunction<ServerResponse> route = route()
 	.path("/person", builder -> builder // <1>
 		.GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
 		.GET(accept(APPLICATION_JSON), handler::listPeople)
-		.POST("/person", handler::createPerson))
+		.POST(handler::createPerson))
 	.build();
 ----
-<1> Note that second parameter of `path` is a consumer that takes the a router builder.
+<1> Note that second parameter of `path` is a consumer that takes the router builder.

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
@@ -602,7 +646,7 @@ RouterFunction<ServerResponse> route = route()
 		"/person".nest {
 			GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
 			GET(accept(APPLICATION_JSON), handler::listPeople)
-			POST("/person", handler::createPerson)
+			POST(handler::createPerson)
 		}
 	}
 ----
@@ -620,7 +664,7 @@ We can further improve by using the `nest` method together with `accept`:
 			.nest(accept(APPLICATION_JSON), b2 -> b2
 				.GET("/{id}", handler::getPerson)
 				.GET(handler::listPeople))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.build();
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -631,7 +675,7 @@ We can further improve by using the `nest` method together with `accept`:
 			accept(APPLICATION_JSON).nest {
 				GET("/{id}", handler::getPerson)
 				GET(handler::listPeople)
-				POST("/person", handler::createPerson)
+				POST(handler::createPerson)
 			}
 		}
 	}
@@ -766,7 +810,7 @@ For instance, consider the following example:
 				.before(request -> ServerRequest.from(request) // <1>
 					.header("X-RequestHeader", "Value")
 					.build()))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.after((request, response) -> logResponse(response)) // <2>
 		.build();
 ----
@@ -784,7 +828,7 @@ For instance, consider the following example:
 				ServerRequest.from(it)
 						.header("X-RequestHeader", "Value").build()
 			}
-			POST("/person", handler::createPerson)
+			POST(handler::createPerson)
 			after { _, response -> // <2>
 				logResponse(response)
 			}
@@ -815,7 +859,7 @@ The following example shows how to do so:
 			.nest(accept(APPLICATION_JSON), b2 -> b2
 				.GET("/{id}", handler::getPerson)
 				.GET(handler::listPeople))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.filter((request, next) -> {
 			if (securityManager.allowAccessTo(request.path())) {
 				return next.handle(request);
@@ -835,7 +879,7 @@ The following example shows how to do so:
 			("/person" and accept(APPLICATION_JSON)).nest {
 				GET("/{id}", handler::getPerson)
 				GET("", handler::listPeople)
-				POST("/person", handler::createPerson)
+				POST(handler::createPerson)
 				filter { request, next ->
 					if (securityManager.allowAccessTo(request.path())) {
 						next(request)
@@ -26,7 +26,7 @@ configuration involves a few bean declarations, such as
 `SpringResourceTemplateResolver`, `SpringWebFluxTemplateEngine`, and
 `ThymeleafReactiveViewResolver`. For more details, see
 https://www.thymeleaf.org/documentation.html[Thymeleaf+Spring] and the WebFlux integration
-http://forum.thymeleaf.org/Thymeleaf-3-0-8-JUST-PUBLISHED-td4030687.html[announcement].
+https://web.archive.org/web/20210623051330/http%3A//forum.thymeleaf.org/Thymeleaf-3-0-8-JUST-PUBLISHED-td4030687.html[announcement].



@@ -232,7 +232,7 @@ Java 8+. Using the latest update release available is highly recommended.
 line should be added for Kotlin script support. See
 https://github.com/sdeleuze/kotlin-script-templating[this example] for more detail.

-You need to have the script templating library. One way to do that for Javascript is
+You need to have the script templating library. One way to do that for JavaScript is
 through https://www.webjars.org/[WebJars].


@@ -12,6 +12,7 @@ decode request and response content on the server side.
 support for the following:

 * https://github.com/reactor/reactor-netty[Reactor Netty]
+* https://docs.oracle.com/en/java/javase/11/docs/api/java.net.http/java/net/http/HttpClient.html[JDK HttpClient]
 * https://github.com/jetty-project/jetty-reactive-httpclient[Jetty Reactive HttpClient]
 * https://hc.apache.org/index.html[Apache HttpComponents]
 * Others can be plugged via `ClientHttpConnector`.
@@ -89,7 +90,7 @@ modified copy as follows:
 === MaxInMemorySize

 Codecs have <<web-reactive.adoc#webflux-codecs-limits,limits>> for buffering data in
-memory to avoid application memory issues. By the default those are set to 256KB.
+memory to avoid application memory issues. By default those are set to 256KB.
 If that's not enough you'll get the following error:

 ----
@@ -335,6 +336,40 @@ To configure a response timeout for a specific request:



+[[webflux-client-builder-jdk-httpclient]]
+=== JDK HttpClient
+
+The following example shows how to customize the JDK `HttpClient`:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+    HttpClient httpClient = HttpClient.newBuilder()
+        .followRedirects(Redirect.NORMAL)
+        .connectTimeout(Duration.ofSeconds(20))
+        .build();
+
+    ClientHttpConnector connector =
+            new JdkClientHttpConnector(httpClient, new DefaultDataBufferFactory());
+
+    WebClient webClient = WebClient.builder().clientConnector(connector).build();
+----
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+    val httpClient = HttpClient.newBuilder()
+        .followRedirects(Redirect.NORMAL)
+        .connectTimeout(Duration.ofSeconds(20))
+        .build()
+
+    val connector = JdkClientHttpConnector(httpClient, DefaultDataBufferFactory())
+
+    val webClient = WebClient.builder().clientConnector(connector).build()
+----
+
+
+
 [[webflux-client-builder-jetty]]
 === Jetty

@@ -382,7 +417,7 @@ shows:

 		HttpClient httpClient = new HttpClient();
 		// Further customizations...
-		
+
 		ClientHttpConnector connector =
 				new JettyClientHttpConnector(httpClient, resourceFactory()); <1>

@@ -403,7 +438,7 @@ shows:

 		val httpClient = HttpClient()
 		// Further customizations...
-			
+
 		val connector = JettyClientHttpConnector(httpClient, resourceFactory()) // <1>

 		return WebClient.builder().clientConnector(connector).build() // <2>
@@ -425,6 +460,7 @@ The following example shows how to customize Apache HttpComponents `HttpClient`
 	HttpAsyncClientBuilder clientBuilder = HttpAsyncClients.custom();
 	clientBuilder.setDefaultRequestConfig(...);
 	CloseableHttpAsyncClient client = clientBuilder.build();
+
 	ClientHttpConnector connector = new HttpComponentsClientHttpConnector(client);

 	WebClient webClient = WebClient.builder().clientConnector(connector).build();
@@ -546,20 +582,16 @@ depending on the response status:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	Mono<Object> entityMono = client.get()
+	Mono<Person> entityMono = client.get()
 			.uri("/persons/1")
 			.accept(MediaType.APPLICATION_JSON)
 			.exchangeToMono(response -> {
 				if (response.statusCode().equals(HttpStatus.OK)) {
 					return response.bodyToMono(Person.class);
 				}
-				else if (response.statusCode().is4xxClientError()) {
-					// Suppress error status code
-					return response.bodyToMono(ErrorContainer.class);
-				}
 				else {
 					// Turn to error
-					return response.createException().flatMap(Mono::error);
+					return response.createError();
 				}
 			});
 ----
@@ -573,9 +605,6 @@ val entity = client.get()
 		if (response.statusCode() == HttpStatus.OK) {
 			 return response.awaitBody<Person>()
 		}
-		else if (response.statusCode().is4xxClientError) {
-			 return response.awaitBody<ErrorContainer>()
-		}
 		else {
 			 throw response.createExceptionAndAwait()
 		}
@@ -761,9 +790,9 @@ multipart request. The following example shows how to create a `MultiValueMap<St
 		part("fieldPart", "fieldValue")
 		part("filePart1", new FileSystemResource("...logo.png"))
 		part("jsonPart", new Person("Jason"))
-		part("myPart", part) // Part from a server request	
+		part("myPart", part) // Part from a server request
 	}
-	
+
 	val parts = builder.build()
 ----

@@ -830,6 +859,54 @@ inline-style, through the built-in `BodyInserters`, as the following example sho
 			.awaitBody<Unit>()
 ----

+==== `PartEvent`
+
+To stream multipart data sequentially, you can provide multipart content through `PartEvent`
+objects.
+
+- Form fields can be created via `FormPartEvent::create`.
+- File uploads can be created via `FilePartEvent::create`.
+
+You can concatenate the streams returned from methods via `Flux::concat`, and create a request for
+the `WebClient`.
+
+For instance, this sample will POST a multipart form containing a form field and a file.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+Resource resource = ...
+Mono<String> result = webClient
+    .post()
+    .uri("https://example.com")
+    .body(Flux.concat(
+            FormPartEvent.create("field", "field value"),
+            FilePartEvent.create("file", resource)
+    ), PartEvent.class)
+    .retrieve()
+    .bodyToMono(String.class);
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+var resource: Resource = ...
+var result: Mono<String> = webClient
+	.post()
+	.uri("https://example.com")
+	.body(
+		Flux.concat(
+			FormPartEvent.create("field", "field value"),
+			FilePartEvent.create("file", resource)
+		)
+	)
+	.retrieve()
+	.bodyToMono()
+----
+
+On the server side, `PartEvent` objects that are received via `@RequestBody` or
+`ServerRequest::bodyToFlux(PartEvent.class)` can be relayed to another service
+via the `WebClient`.
+


 [[webflux-client-filter]]
@@ -1063,7 +1140,7 @@ apply to all operations. For example:
 		client.get().uri("/person/{id}", i).retrieve()
 				.awaitBody<Person>()
 	}
-	
+
 	val persons = runBlocking {
 		client.get().uri("/persons").retrieve()
 				.bodyToFlow<Person>()
@@ -1118,7 +1195,7 @@ inter-dependent, without ever blocking until the end.
 With `Flux` or `Mono`, you should never have to block in a Spring MVC or Spring WebFlux controller.
 Simply return the resulting reactive type from the controller method. The same principle apply to
 Kotlin Coroutines and Spring WebFlux, just use suspending function or return `Flow` in your
-controller method . 
+controller method .
 ====


@@ -353,7 +353,7 @@ into the attributes of the `WebSocketSession`.


 [[webflux-websocket-server-config]]
-=== Server Configation
+=== Server Configuration
 [.small]#<<web.adoc#websocket-server-runtime-configuration, Same as in the Servlet stack>>#

 The `RequestUpgradeStrategy` for each server exposes configuration specific to the
@@ -1,12 +1,13 @@
 [[webflux]]
+:chapter: webflux
 = Spring WebFlux
-:doc-spring-security: {doc-root}/spring-security/site/docs/current/reference
+:doc-spring-security: {doc-root}/spring-security/reference

 The original web framework included in the Spring Framework, Spring Web MVC, was
 purpose-built for the Servlet API and Servlet containers. The reactive-stack web framework,
 Spring WebFlux, was added later in version 5.0. It is fully non-blocking, supports
 https://www.reactive-streams.org/[Reactive Streams] back pressure, and runs on such servers as
-Netty, Undertow, and Servlet 3.1+ containers.
+Netty, Undertow, and Servlet containers.

 Both web frameworks mirror the names of their source modules
 ({spring-framework-main-code}/spring-webmvc[spring-webmvc] and
@@ -23,18 +24,18 @@ in some cases, both -- for example, Spring MVC controllers with the reactive `We
 Why was Spring WebFlux created?

 Part of the answer is the need for a non-blocking web stack to handle concurrency with a
-small number of threads and scale with fewer hardware resources. Servlet 3.1 did provide
-an API for non-blocking I/O. However, using it leads away from the rest of the Servlet API,
-where contracts are synchronous (`Filter`, `Servlet`) or blocking (`getParameter`,
-`getPart`). This was the motivation for a new common API to serve as a foundation across
-any non-blocking runtime. That is important because of servers (such as Netty) that are
-well-established in the async, non-blocking space.
+small number of threads and scale with fewer hardware resources. Servlet non-blocking I/O
+leads away from the rest of the Servlet API, where contracts are synchronous
+(`Filter`, `Servlet`) or blocking (`getParameter`, `getPart`). This was the motivation
+for a new common API to serve as a foundation across any non-blocking runtime. That is
+important because of servers (such as Netty) that are well-established in the async,
+non-blocking space.

 The other part of the answer is functional programming. Much as the addition of annotations
-in Java 5 created opportunities (such as annotated REST controllers or unit tests), the addition
-of lambda expressions in Java 8 created opportunities for functional APIs in Java.
+in Java 5 created opportunities (such as annotated REST controllers or unit tests), the
+addition of lambda expressions in Java 8 created opportunities for functional APIs in Java.
 This is a boon for non-blocking applications and continuation-style APIs (as popularized
-by `CompletableFuture` and http://reactivex.io/[ReactiveX]) that allow declarative
+by `CompletableFuture` and https://reactivex.io/[ReactiveX]) that allow declarative
 composition of asynchronous logic. At the programming-model level, Java 8 enabled Spring
 WebFlux to offer functional web endpoints alongside annotated controllers.

@@ -87,7 +88,7 @@ Spring WebFlux. It provides the
 https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Mono.html[`Mono`] and
 https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html[`Flux`] API types
 to work on data sequences of 0..1 (`Mono`) and 0..N (`Flux`) through a rich set of operators aligned with the
-ReactiveX http://reactivex.io/documentation/operators.html[vocabulary of operators].
+ReactiveX https://reactivex.io/documentation/operators.html[vocabulary of operators].
 Reactor is a Reactive Streams library and, therefore, all of its operators support non-blocking back pressure.
 Reactor has a strong focus on server-side Java. It is developed in close collaboration
 with Spring.
@@ -149,7 +150,7 @@ You have maximum choice of libraries, since, historically, most are blocking.

 * If you are already shopping for a non-blocking web stack, Spring WebFlux offers the same
 execution model benefits as others in this space and also provides a choice of servers
-(Netty, Tomcat, Jetty, Undertow, and Servlet 3.1+ containers), a choice of programming models
+(Netty, Tomcat, Jetty, Undertow, and Servlet containers), a choice of programming models
 (annotated controllers and functional web endpoints), and a choice of reactive libraries
 (Reactor, RxJava, or other).

@@ -187,7 +188,7 @@ unsure what benefits to look for, start by learning about how non-blocking I/O w
 [[webflux-server-choice]]
 === Servers

-Spring WebFlux is supported on Tomcat, Jetty, Servlet 3.1+ containers, as well as on
+Spring WebFlux is supported on Tomcat, Jetty, Servlet containers, as well as on
 non-Servlet runtimes such as Netty and Undertow. All servers are adapted to a low-level,
 <<webflux-httphandler, common API>> so that higher-level
 <<webflux-programming-models, programming models>> can be supported across servers.
@@ -205,7 +206,7 @@ used in the asynchronous, non-blocking space and lets a client and a server shar
 Tomcat and Jetty can be used with both Spring MVC and WebFlux. Keep in mind, however, that
 the way they are used is very different. Spring MVC relies on Servlet blocking I/O and
 lets applications use the Servlet API directly if they need to. Spring WebFlux
-relies on Servlet 3.1 non-blocking I/O and uses the Servlet API behind a low-level
+relies on Servlet non-blocking I/O and uses the Servlet API behind a low-level
 adapter. It is not exposed for direct use.

 For Undertow, Spring WebFlux uses Undertow APIs directly without the Servlet API.
@@ -305,7 +306,7 @@ applications:
 * For server request processing there are two levels of support.
 ** <<webflux-httphandler, HttpHandler>>: Basic contract for HTTP request handling with
 non-blocking I/O and Reactive Streams back pressure, along with adapters for Reactor Netty,
-Undertow, Tomcat, Jetty, and any Servlet 3.1+ container.
+Undertow, Tomcat, Jetty, and any Servlet container.
 ** <<webflux-web-handler-api>>: Slightly higher level, general-purpose web API for
 request handling, on top of which concrete programming models such as annotated
 controllers and functional endpoints are built.
@@ -344,16 +345,16 @@ The following table describes the supported server APIs:
 | spring-web: Undertow to Reactive Streams bridge

 | Tomcat
-| Servlet 3.1 non-blocking I/O; Tomcat API to read and write ByteBuffers vs byte[]
-| spring-web: Servlet 3.1 non-blocking I/O to Reactive Streams bridge
+| Servlet non-blocking I/O; Tomcat API to read and write ByteBuffers vs byte[]
+| spring-web: Servlet non-blocking I/O to Reactive Streams bridge

 | Jetty
-| Servlet 3.1 non-blocking I/O; Jetty API to write ByteBuffers vs byte[]
-| spring-web: Servlet 3.1 non-blocking I/O to Reactive Streams bridge
+| Servlet non-blocking I/O; Jetty API to write ByteBuffers vs byte[]
+| spring-web: Servlet non-blocking I/O to Reactive Streams bridge

-| Servlet 3.1 container
-| Servlet 3.1 non-blocking I/O
-| spring-web: Servlet 3.1 non-blocking I/O to Reactive Streams bridge
+| Servlet container
+| Servlet non-blocking I/O
+| spring-web: Servlet non-blocking I/O to Reactive Streams bridge
 |===

 The following table describes server dependencies (also see
@@ -484,9 +485,9 @@ The code snippets below show using the `HttpHandler` adapters with each server A
 	server.start()
 ----

-*Servlet 3.1+ Container*
+*Servlet Container*

-To deploy as a WAR to any Servlet 3.1+ container, you can extend and include
+To deploy as a WAR to any Servlet container, you can extend and include
 {api-spring-framework}/web/server/adapter/AbstractReactiveWebInitializer.html[`AbstractReactiveWebInitializer`]
 in the WAR. That class wraps an `HttpHandler` with `ServletHttpHandlerAdapter` and registers
 that as a `Servlet`.
@@ -619,11 +620,11 @@ https://github.com/synchronoss/nio-multipart[Synchronoss NIO Multipart] library.
 Both are configured through the `ServerCodecConfigurer` bean
 (see the <<webflux-web-handler-api, Web Handler API>>).

-To parse multipart data in streaming fashion, you can use the `Flux<Part>` returned from an
-`HttpMessageReader<Part>` instead. For example, in an annotated controller, use of
-`@RequestPart` implies `Map`-like access to individual parts by name and, hence, requires
-parsing multipart data in full. By contrast, you can use `@RequestBody` to decode the
-content to `Flux<Part>` without collecting to a `MultiValueMap`.
+To parse multipart data in streaming fashion, you can use the `Flux<PartEvent>` returned from the
+`PartEventHttpMessageReader` instead of using `@RequestPart`, as that  implies `Map`-like access
+to individual parts by name and, hence, requires parsing multipart data in full.
+By contrast, you can use `@RequestBody` to decode the content to `Flux<PartEvent>` without
+collecting to a `MultiValueMap`.


 [[webflux-forwarded-headers]]
@@ -650,7 +651,7 @@ a proxy at the boundary of trust should be configured to remove untrusted forwar
 from the outside. You can also configure the `ForwardedHeaderTransformer` with
 `removeOnly=true`, in which case it removes but does not use the headers.

-NOTE: In 5.1 `ForwardedHeaderFilter` was deprecated and superceded by
+NOTE: In 5.1 `ForwardedHeaderFilter` was deprecated and superseded by
 `ForwardedHeaderTransformer` so forwarded headers can be processed earlier, before the
 exchange is created. If the filter is configured anyway, it is taken out of the list of
 filters, and `ForwardedHeaderTransformer` is used instead.
@@ -676,8 +677,7 @@ Spring WebFlux provides fine-grained support for CORS configuration through anno
 controllers. However, when you use it with Spring Security, we advise relying on the built-in
 `CorsFilter`, which must be ordered ahead of Spring Security's chain of filters.

-See the section on <<webflux-cors>> and the <<webflux-cors.adoc#webflux-cors-webfilter>> for more details.
-
+See the section on <<webflux-cors>> and the <<webflux-cors-webfilter>> for more details.


 [[webflux-exception-handler]]
@@ -1168,19 +1168,17 @@ as a `HandlerResult`, along with some additional context, and passed to the firs
 === Exceptions
 [.small]#<<web.adoc#mvc-exceptionhandlers, Web MVC>>#

-The `HandlerResult` returned from a `HandlerAdapter` can expose a function for error
-handling based on some handler-specific mechanism. This error function is called if:
+`HandlerAdapter` implementations can handle internally exceptions from invoking a request
+handler, such as a controller method. However, an exception may be deferred if the request
+handler returns an asynchronous value.

-* The handler (for example, `@Controller`) invocation fails.
-* The handling of the handler return value through a `HandlerResultHandler` fails.
+A `HandlerAdapter` may expose its exception handling mechanism as a
+`DispatchExceptionHandler` set on the `HandlerResult` it returns. When that's set,
+`DispatcherHandler` will also apply it to the handling of the result.

-The error function can change the response (for example, to an error status), as long as an error
-signal occurs before the reactive type returned from the handler produces any data items.
-
-This is how `@ExceptionHandler` methods in `@Controller` classes are supported.
-By contrast, support for the same in Spring MVC is built on a `HandlerExceptionResolver`.
-This generally should not matter. However, keep in mind that, in WebFlux, you cannot use a
-`@ControllerAdvice` to handle exceptions that occur before a handler is chosen.
+A `HandlerAdapter` may also choose to implement `DispatchExceptionHandler`. Inn that case
+`DispatcherHandler` will apply it to exceptions that arise before a handler is mapped,
+e.g. during handler mapping, or earlier, e.g. in a `WebFilter`.

 See also <<webflux-ann-controller-exceptions>> in the "`Annotated Controller`" section or
 <<webflux-exception-handler>> in the WebHandler API section.
@@ -1200,7 +1198,7 @@ instance. The `View` is then used to render the response.

 [[webflux-viewresolution-handling]]
 ==== Handling
-[.small]#<<web.adoc#mvc-handling, Web MVC>>#
+[.small]#<<web.adoc#mvc-viewresolver-handling, Web MVC>>#

 The `HandlerResult` passed into `ViewResolutionResultHandler` contains the return value
 from the handler and the model that contains attributes added during request
@@ -1348,6 +1346,29 @@ directly to the response body versus view resolution and rendering with an HTML



+[[webflux-ann-requestmapping-proxying]]
+==== AOP Proxies
+[.small]#<<web.adoc#mvc-ann-requestmapping-proxying, Web MVC>>#
+
+In some cases, you may need to decorate a controller with an AOP proxy at runtime.
+One example is if you choose to have `@Transactional` annotations directly on the
+controller. When this is the case, for controllers specifically, we recommend
+using class-based proxying. This is automatically the case with such annotations
+directly on the controller.
+
+If the controller implements an interface, and needs AOP proxying, you may need to
+explicitly configure class-based proxying. For example, with `@EnableTransactionManagement`
+you can change to `@EnableTransactionManagement(proxyTargetClass = true)`, and with
+`<tx:annotation-driven/>` you can change to `<tx:annotation-driven proxy-target-class="true"/>`.
+
+NOTE: Keep in mind that as of 6.0, with interface proxying, Spring WebFlux no longer detects
+controllers based solely on a type-level `@RequestMapping` annotation on the interface.
+Please, enable class based proxying, or otherwise the interface must also have an
+`@Controller` annotation.
+
+
+
+
 [[webflux-ann-requestmapping]]
 === Request Mapping
 [.small]#<<web.adoc#mvc-ann-requestmapping, Web MVC>>#
@@ -1448,7 +1469,7 @@ You can map requests by using glob patterns and wildcards:

 | `+{*path}+`
 | Matches zero or more path segments until the end of the path and captures it as a variable named "path"
-| `+"/resources/{*file}"+` matches `+"/resources/images/file.png"+` and captures `+file=images/file.png+`
+| `+"/resources/{*file}"+` matches `+"/resources/images/file.png"+` and captures `+file=/images/file.png+`

 |===

@@ -1517,7 +1538,7 @@ information or with the `-parameters` compiler flag on Java 8.

 The syntax `{*varName}` declares a URI variable that matches zero or more remaining path
 segments. For example `/resources/{*path}` matches all files under `/resources/`, and the
-`"path"` variable captures the complete relative path.
+`"path"` variable captures the complete path under `/resources`.

 The syntax `{varName:regex}` declares a URI variable with a regular expression that has the
 syntax: `{varName:regex}`. For example, given a URL of `/spring-web-3.0.5.jar`, the following method
@@ -1541,9 +1562,9 @@ extracts the name, version, and file extension:
 ----

 URI path patterns can also have embedded `${...}` placeholders that are resolved on startup
-through `PropertyPlaceHolderConfigurer` against local, system, environment, and other property
-sources. You ca use this to, for example, parameterize a base URL based on some external
-configuration.
+through `PropertySourcesPlaceholderConfigurer` against local, system, environment, and
+other property sources. You can use this to, for example, parameterize a base URL based on
+some external configuration.

 NOTE: Spring WebFlux uses `PathPattern` and the `PathPatternParser` for URI path matching support.
 Both classes are located in `spring-web` and are expressly designed for use with HTTP URL
@@ -1670,7 +1691,7 @@ specific value (`myParam=myValue`). The following examples tests for a parameter
 ----
 <1> Check that `myParam` equals `myValue`.

-You can also use the same with request header conditions, as the follwing example shows:
+You can also use the same with request header conditions, as the following example shows:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1852,8 +1873,8 @@ and others) and is equivalent to `required=false`.
 | For access to name-value pairs in URI path segments. See <<webflux-ann-matrix-variables>>.

 | `@RequestParam`
-| For access to Servlet request parameters. Parameter values are converted to the declared
-  method argument type. See <<webflux-ann-requestparam>>.
+| For access to query parameters. Parameter values are converted to the declared method argument
+  type. See <<webflux-ann-requestparam>>.

  Note that use of `@RequestParam` is optional -- for example, to set its attributes.
  See "`Any other argument`" later in this table.
@@ -1945,6 +1966,14 @@ generally supported for all return values.
 | `HttpHeaders`
 | For returning a response with headers and no body.

+| `ErrorResponse`
+| To render an RFC 7807 error response with details in the body,
+  see <<webflux-ann-rest-exceptions>>
+
+| `ProblemDetail`
+| To render an RFC 7807 error response with details in the body,
+  see <<webflux-ann-rest-exceptions>>
+
 | `String`
 | A view name to be resolved with `ViewResolver` instances and used together with the implicit
  model -- determined through command objects and `@ModelAttribute` methods. The handler
@@ -1986,10 +2015,9 @@ generally supported for all return values.
  to be written (however, `text/event-stream` must be requested or declared in the mapping
  through the `produces` attribute).

-| Any other return value
-| If a return value is not matched to any of the above, it is, by default, treated as a view
-  name, if it is `String` or `void` (default view name selection applies), or as a model
-  attribute to be added to the model, unless it is a simple type, as determined by
+| Other return values
+| If a return value remains unresolved in any other way, it is treated as a model
+  attribute, unless it is a simple type as determined by
  {api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
  in which case it remains unresolved.
 |===
@@ -2257,7 +2285,7 @@ The following example gets the value of the `Accept-Encoding` and `Keep-Alive` h
 		//...
 	}
 ----
-<1> Get the value of the `Accept-Encoging` header.
+<1> Get the value of the `Accept-Encoding` header.
 <2> Get the value of the `Keep-Alive` header.

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -2270,7 +2298,7 @@ The following example gets the value of the `Accept-Encoding` and `Keep-Alive` h
 		//...
 	}
 ----
-<1> Get the value of the `Accept-Encoging` header.
+<1> Get the value of the `Accept-Encoding` header.
 <2> Get the value of the `Keep-Alive` header.

 Type conversion is applied automatically if the target method parameter type is not
@@ -2400,7 +2428,7 @@ immediately next to the `@ModelAttribute`, as the following example shows:
 <1> Adding a `BindingResult`.

 You can automatically apply validation after data binding by adding the
-`javax.validation.Valid` annotation or Spring's `@Validated` annotation (see also
+`jakarta.validation.Valid` annotation or Spring's `@Validated` annotation (see also
 <<core.adoc#validation-beanvalidation, Bean Validation>> and
 <<core.adoc#validation, Spring validation>>). The following example uses the `@Valid` annotation:

@@ -2747,7 +2775,7 @@ you can declare a concrete target `Object`, instead of `Part`, as the following
 ----
 <1> Using `@RequestPart` to get the metadata.

-You can use `@RequestPart` in combination with `javax.validation.Valid` or Spring's
+You can use `@RequestPart` in combination with `jakarta.validation.Valid` or Spring's
 `@Validated` annotation, which causes Standard Bean Validation to be applied. Validation
 errors lead to a `WebExchangeBindException` that results in a 400 (BAD_REQUEST) response.
 The exception contains a `BindingResult` with the error details and can also be handled
@@ -2795,29 +2823,100 @@ as the following example shows:
 ----
 <1> Using `@RequestBody`.

+===== `PartEvent`

-To access multipart data sequentially, in streaming fashion, you can use `@RequestBody` with
-`Flux<Part>` (or `Flow<Part>` in Kotlin) instead, as the following example shows:
+To access multipart data sequentially, in a streaming fashion, you can use `@RequestBody` with
+`Flux<PartEvent>` (or `Flow<PartEvent>` in Kotlin).
+Each part in a multipart HTTP message will produce at
+least one `PartEvent` containing both headers and a buffer with the contents of the part.
+
+- Form fields will produce a *single* `FormPartEvent`, containing the value of the field.
+- File uploads will produce *one or more* `FilePartEvent` objects, containing the filename used
+when uploading. If the file is large enough to be split across multiple buffers, the first
+`FilePartEvent` will be followed by subsequent events.
+
+
+For example:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	@PostMapping("/")
-	public String handle(@RequestBody Flux<Part> parts) { <1>
-		// ...
-	}
+  @PostMapping("/")
+  public void handle(@RequestBody Flux<PartEvent> allPartsEvents) { <1>
+      allPartsEvents.windowUntil(PartEvent::isLast) <2>
+              .concatMap(p -> p.switchOnFirst((signal, partEvents) -> { <3>
+                  if (signal.hasValue()) {
+                      PartEvent event = signal.get();
+                      if (event instanceof FormPartEvent formEvent) { <4>
+                          String value = formEvent.value();
+                          // handle form field
+                      }
+                      else if (event instanceof FilePartEvent fileEvent) { <5>
+                          String filename = fileEvent.filename();
+                          Flux<DataBuffer> contents = partEvents.map(PartEvent::content); <6>
+                          // handle file upload
+                      }
+                      else {
+                          return Mono.error(new RuntimeException("Unexpected event: " + event));
+                      }
+                  }
+                  else {
+                      return partEvents; // either complete or error signal
+                  }
+              }));
+  }
 ----
 <1> Using `@RequestBody`.
+<2> The final `PartEvent` for a particular part will have `isLast()` set to `true`, and can be
+followed by additional events belonging to subsequent parts.
+This makes the `isLast` property suitable as a predicate for the `Flux::windowUntil` operator, to
+split events from all parts into windows that each belong to a single part.
+<3> The `Flux::switchOnFirst` operator allows you to see whether you are handling a form field or
+file upload.
+<4> Handling the form field.
+<5> Handling the file upload.
+<6> The body contents must be completely consumed, relayed, or released to avoid memory leaks.

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	@PostMapping("/")
-	fun handle(@RequestBody parts: Flow<Part>): String { // <1>
-		// ...
-	}
+	fun handle(@RequestBody allPartsEvents: Flux<PartEvent>) = { // <1>
+      allPartsEvents.windowUntil(PartEvent::isLast) <2>
+          .concatMap {
+              it.switchOnFirst { signal, partEvents -> <3>
+                  if (signal.hasValue()) {
+                      val event = signal.get()
+                      if (event is FormPartEvent) { <4>
+                          val value: String = event.value();
+                          // handle form field
+                      } else if (event is FilePartEvent) { <5>
+                          val filename: String = event.filename();
+                          val contents: Flux<DataBuffer> = partEvents.map(PartEvent::content); <6>
+                          // handle file upload
+                      } else {
+                          return Mono.error(RuntimeException("Unexpected event: " + event));
+                      }
+                  } else {
+                      return partEvents; // either complete or error signal
+                  }
+              }
+          }
+}
 ----
 <1> Using `@RequestBody`.
+<2> The final `PartEvent` for a particular part will have `isLast()` set to `true`, and can be
+followed by additional events belonging to subsequent parts.
+This makes the `isLast` property suitable as a predicate for the `Flux::windowUntil` operator, to
+split events from all parts into windows that each belong to a single part.
+<3> The `Flux::switchOnFirst` operator allows you to see whether you are handling a form field or
+file upload.
+<4> Handling the form field.
+<5> Handling the file upload.
+<6> The body contents must be completely consumed, relayed, or released to avoid memory leaks.
+
+Received part events can also be relayed to another service by using the `WebClient`.
+See <<webflux-client-body-multipart>>.


 [[webflux-ann-requestbody]]
@@ -2869,7 +2968,7 @@ and fully non-blocking reading and (client-to-server) streaming.
 You can use the <<webflux-config-message-codecs>> option of the <<webflux-config>> to
 configure or customize message readers.

-You can use `@RequestBody` in combination with `javax.validation.Valid` or Spring's
+You can use `@RequestBody` in combination with `jakarta.validation.Valid` or Spring's
 `@Validated` annotation, which causes Standard Bean Validation to be applied. Validation
 errors cause a `WebExchangeBindException`, which results in a 400 (BAD_REQUEST) response.
 The exception contains a `BindingResult` with error details and can be handled in the
@@ -2976,7 +3075,7 @@ configure or customize message writing.
 	public ResponseEntity<String> handle() {
 		String body = ... ;
 		String etag = ... ;
-		return ResponseEntity.ok().eTag(etag).build(body);
+		return ResponseEntity.ok().eTag(etag).body(body);
 	}
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -3320,10 +3419,15 @@ controller-specific `Formatter` instances, as the following example shows:
 ----
 <1> Adding a custom formatter (a `DateFormatter`, in this case).

+[[webflux-ann-initbinder-model-design]]
+==== Model Design
+[.small]#<<web.adoc#mvc-ann-initbinder-model-design, Web MVC>>#
+
+include::web-data-binding-model-design.adoc[]


 [[webflux-ann-controller-exceptions]]
-=== Managing Exceptions
+=== Exceptions
 [.small]#<<web.adoc#mvc-ann-exceptionhandler, Web MVC>>#

 `@Controller` and <<webflux-ann-controller-advice, @ControllerAdvice>> classes can have
@@ -3383,21 +3487,22 @@ Support for `@ExceptionHandler` methods in Spring WebFlux is provided by the
 for more detail.


-[[webflux-ann-rest-exceptions]]
-==== REST API exceptions
-[.small]#<<web.adoc#mvc-ann-rest-exceptions, Web MVC>>#

-A common requirement for REST services is to include error details in the body of the
-response. The Spring Framework does not automatically do so, because the representation
-of error details in the response body is application-specific. However, a
-`@RestController` can use `@ExceptionHandler` methods with a `ResponseEntity` return
-value to set the status and the body of the response. Such methods can also be declared
-in `@ControllerAdvice` classes to apply them globally.
+[[webflux-ann-exceptionhandler-args]]
+==== Method Arguments
+[.small]#<<web.adoc#mvc-ann-exceptionhandler-args, Web MVC>>#

-NOTE: Note that Spring WebFlux does not have an equivalent for the Spring MVC
-`ResponseEntityExceptionHandler`, because WebFlux raises only `ResponseStatusException`
-(or subclasses thereof), and those do not need to be translated to
-an HTTP status code.
+`@ExceptionHandler` methods support the same <<webflux-ann-arguments,method arguments>>
+as `@RequestMapping` methods, except the request body might have been consumed already.
+
+
+
+[[webflux-ann-exceptionhandler-return-values]]
+==== Return Values
+[.small]#<<web.adoc#mvc-ann-exceptionhandler-return-values, Web MVC>>#
+
+`@ExceptionHandler` methods support the same <<webflux-ann-return-types,return values>>
+as `@RequestMapping` methods.



@@ -3480,22 +3585,168 @@ include::web-uris.adoc[leveloffset=+2]
 include::webflux-cors.adoc[leveloffset=+1]


+[[webflux-ann-rest-exceptions]]
+== Error Responses
+[.small]#<<webmvc.adoc#mvc-ann-rest-exceptions, Web MVC>>#
+
+A common requirement for REST services is to include details in the body of error
+responses. The Spring Framework supports the "Problem Details for HTTP APIs"
+specification, https://www.rfc-editor.org/rfc/rfc7807.html[RFC 7807].
+
+The following are the main abstractions for this support:
+
+- `ProblemDetail` -- representation for an RFC 7807 problem detail; a simple container
+for both standard fields defined in the spec, and for non-standard ones.
+- `ErrorResponse` -- contract to expose HTTP error response details including HTTP
+status, response headers, and a body in the format of RFC 7807; this allows exceptions to
+encapsulate and expose the details of how they map to an HTTP response. All Spring WebFlux
+exceptions implement this.
+- `ErrorResponseException` -- basic `ErrorResponse` implementation that others
+can use as a convenient base class.
+- `ResponseEntityExceptionHandler` -- convenient base class for an
+<<webflux-ann-controller-advice,@ControllerAdvice>> that handles all Spring WebFlux exceptions,
+and any `ErrorResponseException`, and renders an error response with a body.
+
+
+
+[[webflux-ann-rest-exceptions-render]]
+=== Render
+[.small]#<<webmvc.adoc#mvc-ann-rest-exceptions-render, Web MVC>>#
+
+You can return `ProblemDetail` or `ErrorResponse` from any `@ExceptionHandler` or from
+any `@RequestMapping` method to render an RFC 7807 response. This is processed as follows:
+
+- The `status` property of `ProblemDetail` determines the HTTP status.
+- The `instance` property of `ProblemDetail` is set from the current URL path, if not
+already set.
+- For content negotiation, the Jackson `HttpMessageConverter` prefers
+"application/problem+json" over "application/json" when rendering a `ProblemDetail`,
+and also falls back on it if no compatible media type is found.
+
+To enable RFC 7807 responses for Spring WebFlux exceptions and for any
+`ErrorResponseException`, extend `ResponseEntityExceptionHandler` and declare it as an
+<<webflux-ann-controller-advice,@ControllerAdvice>> in Spring configuration. The handler
+has an `@ExceptionHandler` method that handles any `ErrorResponse` exception, which
+includes all built-in web exceptions. You can add more exception handling methods, and
+use a protected method to map any exception to a `ProblemDetail`.
+
+
+
+[[webflux-ann-rest-exceptions-non-standard]]
+=== Non-Standard Fields
+[.small]#<<webmvc.adoc#mvc-ann-rest-exceptions-non-standard, Web MVC>>#
+
+You can extend an RFC 7807 response with non-standard fields in one of two ways.
+
+One, insert into the "properties" `Map` of `ProblemDetail`. When using the Jackson
+library, the Spring Framework registers `ProblemDetailJacksonMixin` that ensures this
+"properties" `Map` is unwrapped and rendered as top level JSON properties in the
+response, and likewise any unknown property during deserialization is inserted into
+this `Map`.
+
+You can also extend `ProblemDetail` to add dedicated non-standard properties.
+The copy constructor in `ProblemDetail` allows a subclass to make it easy to be created
+from an existing `ProblemDetail`. This could be done centrally, e.g. from an
+`@ControllerAdvice` such as `ResponseEntityExceptionHandler` that re-creates the
+`ProblemDetail` of an exception into a subclass with the additional non-standard fields.
+
+
+
+[[webflux-ann-rest-exceptions-i18n]]
+=== Internationalization
+[.small]#<<webmvc.adoc#mvc-ann-rest-exceptions-i18n, Web MVC>>#
+
+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:
+
+- Each `ErrorResponse` exposes a message code and arguments to resolve the "detail" field
+through a <<core.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.
+
+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
+
+| `UnsupportedMediaTypeStatusException`
+| (default)
+| `{0}` the media type that is not supported, `{1}` list of supported media types
+
+| `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
+
+| `NotAcceptableStatusException`
+| (default) + ".parseError"
+|
+
+| `ServerErrorException`
+| (default)
+| `{0}` the failure reason provided to the class constructor
+
+| `MethodNotAllowedException`
+| (default)
+| `{0}` the current HTTP method, `{1}` the list of supported HTTP methods
+
+|===
+
+By default, the message code for the "title" field is "problemDetail.title." + the fully
+qualified exception class name.
+
+
+
+
+[[webflux-ann-rest-exceptions-client]]
+=== Client Handling
+[.small]#<<webmvc.adoc#mvc-ann-rest-exceptions-client, Web MVC>>#
+
+A client application can catch `WebClientResponseException`, when using the `WebClient`,
+or `RestClientResponseException` when using the `RestTemplate`, and use their
+`getResponseBodyAs` methods to decode the error response body to any target type such as
+`ProblemDetail`, or a subclass of `ProblemDetail`.
+
+


 [[webflux-web-security]]
 == Web Security
 [.small]#<<web.adoc#mvc-web-security, Web MVC>>#

-The https://projects.spring.io/spring-security/[Spring Security] project provides support
+The https://spring.io/projects/spring-security[Spring Security] project provides support
 for protecting web applications from malicious exploits. See the Spring Security
 reference documentation, including:

-* {doc-spring-security}/html5/#jc-webflux[WebFlux Security]
-* {doc-spring-security}/html5/#test-webflux[WebFlux Testing Support]
-* {doc-spring-security}/html5/#csrf[CSRF Protection]
-* {doc-spring-security}/html5/#headers[Security Response Headers]
-
-include::webflux-view.adoc[leveloffset=+1]
+* {doc-spring-security}/reactive/configuration/webflux.html[WebFlux Security]
+* {doc-spring-security}/reactive/test/index.html[WebFlux Testing Support]
+* {doc-spring-security}/features/exploits/csrf.html#csrf-protection[CSRF protection]
+* {doc-spring-security}/features/exploits/headers.html[Security Response Headers]



@@ -3669,6 +3920,7 @@ You should serve static resources with a `Cache-Control` and conditional respons
 for optimal performance. See the section on configuring <<webflux-config-static-resources>>.


+include::webflux-view.adoc[leveloffset=+1]


 [[webflux-config]]
@@ -3845,7 +4097,7 @@ as the following example shows:
 	public class WebConfig implements WebFluxConfigurer {

 		@Override
-		public Validator getValidator(); {
+		public Validator getValidator() {
 			// ...
 		}

@@ -4170,8 +4422,8 @@ the example:
 		@Override
 		public void addResourceHandlers(ResourceHandlerRegistry registry) {
 			registry.addResourceHandler("/resources/**")
-				.addResourceLocations("/public", "classpath:/static/")
-				.setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS));
+					.addResourceLocations("/public", "classpath:/static/")
+					.setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS));
 		}

 	}
@@ -4252,12 +4504,21 @@ Note that, when using both `EncodedResourceResolver` (for example, Gzip, Brotli
 `VersionedResourceResolver`, they must be registered in that order, to ensure content-based
 versions are always computed reliably based on the unencoded file.

-https://www.webjars.org/documentation[WebJars] are also supported through the
+For https://www.webjars.org/documentation[WebJars], versioned URLs like
+`/webjars/jquery/1.2.0/jquery.min.js` are the recommended and most efficient way to use them.
+The related resource location is configured out of the box with Spring Boot (or can be configured
+manually via `ResourceHandlerRegistry`) and does not require to add the
+`org.webjars:webjars-locator-core` dependency.
+
+Version-less URLs like `/webjars/jquery/jquery.min.js` are supported through the
 `WebJarsResourceResolver` which is automatically registered when the
-`org.webjars:webjars-locator-core` library is present on the classpath. The resolver can
-re-write URLs to include the version of the jar and can also match against incoming URLs
-without versions -- for example, from `/jquery/jquery.min.js` to
-`/jquery/1.2.0/jquery.min.js`.
+`org.webjars:webjars-locator-core` library is present on the classpath, at the cost of a
+classpath scanning that could slow down application startup. The resolver can re-write URLs to
+include the version of the jar and can also match against incoming URLs without versions
+-- for example, from `/webjars/jquery/jquery.min.js` to `/webjars/jquery/1.2.0/jquery.min.js`.
+
+TIP: The Java configuration based on `ResourceHandlerRegistry` provides further options
+for fine-grained control, e.g. last-modified behavior and optimized resource resolution.



@@ -4280,9 +4541,7 @@ The following example shows how to use `PathMatchConfigurer`:
 		public void configurePathMatch(PathMatchConfigurer configurer) {
 			configurer
 				.setUseCaseSensitiveMatch(true)
-				.setUseTrailingSlashMatch(false)
-				.addPathPrefix("/api",
-						HandlerTypePredicate.forAnnotation(RestController.class));
+				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController.class));
 		}
 	}
 ----
@@ -4297,9 +4556,7 @@ The following example shows how to use `PathMatchConfigurer`:
 		fun configurePathMatch(configurer: PathMatchConfigurer) {
 			configurer
 				.setUseCaseSensitiveMatch(true)
-				.setUseTrailingSlashMatch(false)
-				.addPathPrefix("/api",
-						HandlerTypePredicate.forAnnotation(RestController::class.java))
+				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
 		}
 	}
 ----
@@ -13,8 +13,8 @@ This section describes options for client-side access to REST endpoints.
 Spring REST client and exposes a simple, template-method API over underlying HTTP client
 libraries.

-NOTE: As of 5.0 the `RestTemplate` is in maintenance mode, with only minor requests for
-changes and bugs to be accepted going forward. Please, consider using the
+NOTE: As of 5.0 the `RestTemplate` is in maintenance mode, with only requests for minor
+changes and bugs to be accepted. Please, consider using the
 <<web-reactive.adoc#webflux-client, WebClient>> which offers a more modern API and
 supports sync, async, and streaming scenarios.

@@ -40,3 +40,16 @@ In contrast to `RestTemplate`, `WebClient` supports the following:
 * Streaming up to or streaming down from a server.

 See <<web-reactive.adoc#webflux-client, WebClient>> for more details.
+
+
+
+
+[[webmvc-http-interface]]
+== HTTP Interface
+
+The Spring Frameworks lets you define an HTTP service as a Java interface with HTTP
+exchange methods. You can then generate a proxy that implements this interface and
+performs the exchanges. This helps to simplify HTTP remote access and provides additional
+flexibility for to choose an API style such as synchronous or reactive.
+
+See <<integration.adoc#rest-http-interface, REST Endpoints>> for details.
@@ -1,5 +1,6 @@
 [[mvc-cors]]
 = CORS
+:doc-spring-security: {doc-root}/spring-security/reference
 [.small]#<<web-reactive.adoc#webflux-cors, WebFlux>>#

 Spring MVC lets you handle CORS (Cross-Origin Resource Sharing). This section
@@ -50,7 +51,7 @@ Each `HandlerMapping` can be
 {api-spring-framework}/web/servlet/handler/AbstractHandlerMapping.html#setCorsConfigurations-java.util.Map-[configured]
 individually with URL pattern-based `CorsConfiguration` mappings. In most cases, applications
 use the MVC Java configuration or the XML namespace to declare such mappings, which results
-in a single global map being passed to all `HandlerMappping` instances.
+in a single global map being passed to all `HandlerMapping` instances.

 You can combine global CORS configuration at the `HandlerMapping` level with more
 fine-grained, handler-level CORS configuration. For example, annotated controllers can use
@@ -334,13 +335,12 @@ as the following example shows:
 You can apply CORS support through the built-in
 {api-spring-framework}/web/filter/CorsFilter.html[`CorsFilter`].

-NOTE: If you try to use the `CorsFilter` with Spring Security, keep in mind that
-Spring Security has
-https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#cors[built-in support]
-for CORS.
+NOTE: If you try to use the `CorsFilter` with Spring Security, keep in mind that Spring
+Security has {doc-spring-security}/servlet/integrations/cors.html[built-in support] for
+CORS.

-To configure the filter, pass a
-`CorsConfigurationSource` to its constructor, as the following example shows:
+To configure the filter, pass a `CorsConfigurationSource` to its constructor, as the
+following example shows:

 [source,java,indent=0,subs="verbatim",role="primary"]
 .Java
@@ -103,7 +103,7 @@ as the following example shows:


 If you register the `RouterFunction` as a bean, for instance by exposing it in a
-@Configuration class, it will be auto-detected by the servlet, as explained in <<webmvc-fn-running>>.
+`@Configuration` class, it will be auto-detected by the servlet, as explained in <<webmvc-fn-running>>.



@@ -475,7 +475,7 @@ For instance, the router function builder offers the method `GET(String, Handler
 Besides HTTP method-based mapping, the route builder offers a way to introduce additional
 predicates when mapping to requests.
 For each HTTP method there is an overloaded variant that takes a `RequestPredicate` as a
-parameter, though which additional constraints can be expressed.
+parameter, through which additional constraints can be expressed.


 [[webmvc-fn-predicates]]
@@ -612,7 +612,7 @@ RouterFunction<ServerResponse> route = route()
 	.path("/person", builder -> builder // <1>
 		.GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
 		.GET(accept(APPLICATION_JSON), handler::listPeople)
-		.POST("/person", handler::createPerson))
+		.POST(handler::createPerson))
 	.build();
 ----
 <1> Note that second parameter of `path` is a consumer that takes the router builder.
@@ -626,7 +626,7 @@ RouterFunction<ServerResponse> route = route()
 		"/person".nest {
 			GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
 			GET(accept(APPLICATION_JSON), handler::listPeople)
-			POST("/person", handler::createPerson)
+			POST(handler::createPerson)
 		}
 	}
 ----
@@ -644,7 +644,7 @@ We can further improve by using the `nest` method together with `accept`:
 			.nest(accept(APPLICATION_JSON), b2 -> b2
 				.GET("/{id}", handler::getPerson)
 				.GET(handler::listPeople))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.build();
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -657,7 +657,7 @@ We can further improve by using the `nest` method together with `accept`:
 			accept(APPLICATION_JSON).nest {
 				GET("/{id}", handler::getPerson)
 				GET("", handler::listPeople)
-				POST("/person", handler::createPerson)
+				POST(handler::createPerson)
 			}
 		}
 	}
@@ -779,7 +779,7 @@ For instance, consider the following example:
 				.before(request -> ServerRequest.from(request) // <1>
 					.header("X-RequestHeader", "Value")
 					.build()))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.after((request, response) -> logResponse(response)) // <2>
 		.build();
 ----
@@ -799,10 +799,10 @@ For instance, consider the following example:
 				ServerRequest.from(it)
 						.header("X-RequestHeader", "Value").build()
 			}
-			POST("/person", handler::createPerson)
-			after { _, response -> // <2>
-				logResponse(response)
-			}
+		}
+		POST(handler::createPerson)
+		after { _, response -> // <2>
+			logResponse(response)
 		}
 	}
 ----
@@ -830,7 +830,7 @@ The following example shows how to do so:
 			.nest(accept(APPLICATION_JSON), b2 -> b2
 				.GET("/{id}", handler::getPerson)
 				.GET(handler::listPeople))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.filter((request, next) -> {
 			if (securityManager.allowAccessTo(request.path())) {
 				return next.handle(request);
@@ -852,7 +852,7 @@ The following example shows how to do so:
 		("/person" and accept(APPLICATION_JSON)).nest {
 			GET("/{id}", handler::getPerson)
 			GET("", handler::listPeople)
-			POST("/person", handler::createPerson)
+			POST(handler::createPerson)
 			filter { request, next ->
 				if (securityManager.allowAccessTo(request.path())) {
 					next(request)
@@ -1,4 +1,4 @@
-[[testing]]
+[[webmvc.test]]
 = Testing
 [.small]#<<web-reactive.adoc#webflux-test, Same in Spring WebFlux>>#

@@ -479,7 +479,7 @@ In similar fashion, you can specify HTML escaping per field, as the following ex
 [[mvc-view-groovymarkup]]
 == Groovy Markup

-The http://groovy-lang.org/templating.html#_the_markuptemplateengine[Groovy Markup Template Engine]
+The https://groovy-lang.org/templating.html#_the_markuptemplateengine[Groovy Markup Template Engine]
 is primarily aimed at generating XML-like markup (XML, XHTML, HTML5, and others), but you can
 use it to generate any text-based content. The Spring Framework has a built-in
 integration for using Spring MVC with Groovy Markup.
@@ -615,14 +615,14 @@ Java 8+. Using the latest update release available is highly recommended.
 line should be added for Kotlin script support. See
 https://github.com/sdeleuze/kotlin-script-templating[this example] for more details.

-You need to have the script templating library. One way to do that for Javascript is
+You need to have the script templating library. One way to do that for JavaScript is
 through https://www.webjars.org/[WebJars].



 [[mvc-view-script-integrate]]
 === Script Templates
-[.small]#<<web-reactive.adoc#webflux-script-integrate, WebFlux>>#
+[.small]#<<web-reactive.adoc#webflux-view-script, WebFlux>>#

 You can declare a `ScriptTemplateConfigurer` bean to specify the script engine to use,
 the script files to load, what function to call to render templates, and so on.
@@ -1697,7 +1697,7 @@ located in the `WEB-INF/defs` directory. At initialization of the `WebApplicatio
 the files are loaded, and the definitions factory are initialized. After that has
 been done, the Tiles included in the definition files can be used as views within your
 Spring web application. To be able to use the views, you have to have a `ViewResolver`
-as with any other view technology in Spring : typically a convenient `TilesViewResolver`.
+as with any other view technology in Spring: typically a convenient `TilesViewResolver`.

 You can specify locale-specific Tiles definitions by adding an underscore and then
 the locale, as the following example shows:
@@ -1,4 +1,4 @@
-[[websocket-intro]]
+[[{chapter}.websocket-intro]]
 = Introduction to WebSocket

 The WebSocket protocol, https://tools.ietf.org/html/rfc6455[RFC 6455], provides a standardized
@@ -54,7 +54,7 @@ instructions of the cloud provider related to WebSocket support.



-[[websocket-intro-architecture]]
+[[{chapter}.websocket-intro-architecture]]
 == HTTP Versus WebSocket

 Even though WebSocket is designed to be HTTP-compatible and starts with an HTTP request,
@@ -80,7 +80,7 @@ In the absence of that, they need to come up with their own conventions.



-[[websocket-intro-when-to-use]]
+[[{chapter}.websocket-intro-when-to-use]]
 == When to Use WebSockets

 WebSockets can make a web page be dynamic and interactive. However, in many cases,
@@ -1,6 +1,6 @@
 [[websocket]]
 = WebSockets
-:doc-spring-security: {doc-root}/spring-security/site/docs/current/reference
+:doc-spring-security: {doc-root}/spring-security/reference
 [.small]#<<web-reactive.adoc#webflux-websocket, WebFlux>>#

 This part of the reference documentation covers support for Servlet stack, WebSocket
@@ -215,12 +215,12 @@ through the use of the `<absolute-ordering />` element in `web.xml`, as the foll

 [source,xml,indent=0,subs="verbatim,quotes,attributes"]
 ----
-	<web-app xmlns="http://java.sun.com/xml/ns/javaee"
+	<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
 		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		xsi:schemaLocation="
-			http://java.sun.com/xml/ns/javaee
-			https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
-		version="3.0">
+			https://jakarta.ee/xml/ns/jakartaee
+			https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
+		version="5.0">

 		<absolute-ordering/>

@@ -233,12 +233,12 @@ Java initialization API. The following example shows how to do so:

 [source,xml,indent=0,subs="verbatim,quotes,attributes"]
 ----
-	<web-app xmlns="http://java.sun.com/xml/ns/javaee"
+	<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
 		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		xsi:schemaLocation="
-			http://java.sun.com/xml/ns/javaee
-			https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
-		version="3.0">
+			https://jakarta.ee/xml/ns/jakartaee
+			https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
+		version="5.0">

 		<absolute-ordering>
 			<name>spring_web</name>
@@ -597,7 +597,7 @@ a key reason for having SockJS. This section covers important
 considerations about running in those browsers.

 The SockJS client supports Ajax/XHR streaming in IE 8 and 9 by using Microsoft's
-https://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx[`XDomainRequest`].
+https://web.archive.org/web/20160219230343/https://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx[`XDomainRequest`].
 That works across domains but does not support sending cookies.
 Cookies are often essential for Java applications.
 However, since the SockJS client can be used with many server
@@ -627,10 +627,11 @@ response. By default, the Spring Security Java configuration sets it to `DENY`.
 In 3.2, the Spring Security XML namespace does not set that header by default
 but can be configured to do so. In the future, it may set it by default.

-See {doc-spring-security}/htmlsingle/#headers[Default Security Headers]
+See {doc-spring-security}/features/exploits/headers.html#headers-default[Default Security Headers]
 of the Spring Security documentation for details on how to configure the
 setting of the `X-Frame-Options` header. You can also see
-https://jira.spring.io/browse/SEC-2501[SEC-2501] for additional background.
+https://github.com/spring-projects/spring-security/issues/2718[gh-2718]
+for additional background.
 ====

 If your application adds the `X-Frame-Options` response header (as it should!)
@@ -923,7 +924,7 @@ destination:/topic/price.stock.MMM

 A server cannot send unsolicited messages. All messages
 from a server must be in response to a specific client subscription, and the
-`subscription-id` header of the server message must match the `id` header of the
+`subscription` header of the server message must match the `id` header of the
 client subscription.

 The preceding overview is intended to provide the most basic understanding of the
@@ -1118,7 +1119,7 @@ Contract for sending a message that enables loose coupling between producers and
 `SubscribableChannel` that uses an `Executor` for delivering messages.

 Both the Java configuration (that is, `@EnableWebSocketMessageBroker`) and the XML namespace configuration
-(that is,`<websocket:message-broker>`) use the preceding components to assemble a message
+(that is, `<websocket:message-broker>`) use the preceding components to assemble a message
 workflow. The following diagram shows the components used when the simple built-in message
 broker is enabled:

@@ -1177,7 +1178,7 @@ We can trace the flow through a simple example. Consider the following example,
 	@Controller
 	public class GreetingController {

-		@MessageMapping("/greeting") {
+		@MessageMapping("/greeting")
 		public String handle(String greeting) {
 			return "[" + getTimestamp() + ": " + greeting;
 		}
@@ -1191,7 +1192,7 @@ is established, STOMP frames begin to flow on it.
 . The client sends a SUBSCRIBE frame with a destination header of `/topic/greeting`. Once received
 and decoded, the message is sent to the `clientInboundChannel` and is then routed to the
 message broker, which stores the client subscription.
-. The client sends a aSEND frame to `/app/greeting`. The `/app` prefix helps to route it to
+. The client sends a SEND frame to `/app/greeting`. The `/app` prefix helps to route it to
 annotated controllers. After the `/app` prefix is stripped, the remaining `/greeting`
 part of the destination is mapped to the `@MessageMapping` method in `GreetingController`.
 . The value returned from `GreetingController` is turned into a Spring `Message` with
@@ -1258,7 +1259,7 @@ The following table describes the method arguments:
 The presence of this annotation is not required since it is, by default, assumed if no
 other argument is matched.

-You can annotate payload arguments with `@javax.validation.Valid` or Spring's `@Validated`,
+You can annotate payload arguments with `@jakarta.validation.Valid` or Spring's `@Validated`,
 to have the payload arguments be automatically validated.

 | `@Header`
@@ -1346,7 +1347,7 @@ receipt if the server supports it (simple broker does not). For example, with th
 	headers.setDestination("/topic/...");
 	headers.setReceipt("r1");
 	FrameHandler handler = ...;
-	stompSession.subscribe(headers, handler).addReceiptTask(() -> {
+	stompSession.subscribe(headers, handler).addReceiptTask(receiptHeaders -> {
 		// Subscription ready...
 	});
 ----
@@ -1439,8 +1440,11 @@ See <<websocket-stomp-destination-separator>>.

 If configured with a task scheduler, the simple broker supports
 https://stomp.github.io/stomp-specification-1.2.html#Heart-beating[STOMP heartbeats].
-For that, you can declare your own scheduler or use the one that is automatically
-declared and used internally. The following example shows how to declare your own scheduler:
+To configure a scheduler, you can declare your own `TaskScheduler` bean and set it through
+the `MessageBrokerRegistry`. Alternatively, you can use the one that is automatically
+declared in the built-in WebSocket configuration, however, you'll' need `@Lazy` to avoid
+a cycle between the built-in WebSocket configuration and your
+`WebSocketMessageBrokerConfigurer`. For example:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
@@ -1451,13 +1455,12 @@ public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
 	private TaskScheduler messageBrokerTaskScheduler;

 	@Autowired
-	public void setMessageBrokerTaskScheduler(TaskScheduler taskScheduler) {
+	public void setMessageBrokerTaskScheduler(@Lazy TaskScheduler taskScheduler) {
 		this.messageBrokerTaskScheduler = taskScheduler;
 	}

 	@Override
 	public void configureMessageBroker(MessageBrokerRegistry registry) {
-
 		registry.enableSimpleBroker("/queue/", "/topic/")
 				.setHeartbeatValue(new long[] {10000, 20000})
 				.setTaskScheduler(this.messageBrokerTaskScheduler);
@@ -1722,19 +1725,11 @@ HTTP session (which is then associated with WebSocket or SockJS sessions created
 for that user) and results in a user header being stamped on every `Message` flowing
 through the application.

-Note that the STOMP protocol does have `login` and `passcode` headers
-on the `CONNECT` frame. Those were originally designed for and are still needed,
-for example, for STOMP over TCP. However, for STOMP over WebSocket, by default,
-Spring ignores authorization headers at the STOMP protocol level, assumes that
-the user is already authenticated at the HTTP transport level, and expects that
-the WebSocket or SockJS session contain the authenticated user.
-
-NOTE: Spring Security provides
-https://docs.spring.io/spring-security/site/docs/current/reference/htmlsingle/#websocket[WebSocket sub-protocol authorization]
-that uses a `ChannelInterceptor` to authorize messages based on the user header in them.
-Also, Spring Session provides a
-https://docs.spring.io/spring-session/docs/current/reference/html5/#websocket[WebSocket integration]
-that ensures the user HTTP session does not expire when the WebSocket session is still active.
+The STOMP protocol does have `login` and `passcode` headers on the `CONNECT` frame.
+Those were originally designed for and are needed for STOMP over TCP. However, for STOMP
+over WebSocket, by default, Spring ignores authentication headers at the STOMP protocol
+level, and assumes that the user is already authenticated at the HTTP transport level.
+The expectation is that the WebSocket or SockJS session contain the authenticated user.



@@ -1768,7 +1763,7 @@ WebSocket and SockJS requests.

 Therefore, applications that wish to avoid the use of cookies may not have any good
 alternatives for authentication at the HTTP protocol level. Instead of using cookies,
-they may prefer to authenticate with headers at the STOMP messaging protocol level
+they may prefer to authenticate with headers at the STOMP messaging protocol level.
 Doing so requires two simple steps:

 . Use the STOMP client to pass authentication headers at connect time.
@@ -1812,18 +1807,34 @@ its own implementation of `WebSocketMessageBrokerConfigurer` that is marked with



+[[websocket-stomp-authorization]]
+=== Authorization
+
+Spring Security provides
+{doc-spring-security}/servlet/integrations/websocket.html#websocket-authorization[WebSocket sub-protocol authorization]
+that uses a `ChannelInterceptor` to authorize messages based on the user header in them.
+Also, Spring Session provides
+https://docs.spring.io/spring-session/reference/web-socket.html[WebSocket integration]
+that ensures the user's HTTP session does not expire while the WebSocket session is still active.
+
+
+
 [[websocket-stomp-user-destination]]
 === User Destinations

 An application can send messages that target a specific user, and Spring's STOMP support
 recognizes destinations prefixed with `/user/` for this purpose.
 For example, a client might subscribe to the `/user/queue/position-updates` destination.
-This destination is handled by the `UserDestinationMessageHandler` and
-transformed into a destination unique to the user session
-(such as `/queue/position-updates-user123`). This provides the convenience of subscribing
-to a generically named destination while, at the same time, ensuring no collisions
-with other users who subscribe to the same destination so that each user can receive
-unique stock position updates.
+`UserDestinationMessageHandler` handles this destination and transforms it into a
+destination unique to the user session (such as `/queue/position-updates-user123`).
+This provides the convenience of subscribing to a generically named destination while,
+at the same time, ensuring no collisions with other users who subscribe to the same
+destination so that each user can receive unique stock position updates.
+
+TIP: When working with user destinations, it is important to configure broker and
+application destination prefixes as shown in <<websocket-stomp-enable>>, or otherwise the
+broker would handle "/user" prefixed messages that should only be handled by
+`UserDestinationMessageHandler`.

 On the sending side, messages can be sent to a destination such as
 pass:q[`/user/{username}/queue/position-updates`], which in turn is translated
@@ -1976,7 +1987,7 @@ Note that this incurs a small performance overhead, so you should enable it only



-[[websocket-stomp-appplication-context-events]]
+[[websocket-stomp-application-context-events]]
 === Events

 Several `ApplicationContext` events are published and can be
@@ -2019,7 +2030,7 @@ implement their own reconnecting logic.
 [[websocket-stomp-interceptors]]
 === Interception

-<<websocket-stomp-appplication-context-events>> provide notifications for the lifecycle
+<<websocket-stomp-application-context-events>> provide notifications for the lifecycle
 of a STOMP connection but not for every client message. Applications can also register a
 `ChannelInterceptor` to intercept any message and in any part of the processing chain.
 The following example shows how to intercept inbound messages from clients:
@@ -2413,7 +2424,7 @@ through any other application instances.
 === Monitoring

 When you use `@EnableWebSocketMessageBroker` or `<websocket:message-broker>`, key
-infrastructure components automatically gather statisticss and counters that provide
+infrastructure components automatically gather statistics and counters that provide
 important insight into the internal state of the application. The configuration
 also declares a bean of type `WebSocketMessageBrokerStats` that gathers all
 available information in one place and by default logs it at the `INFO` level once
@@ -255,10 +255,18 @@ CGLIB 3.3 is licensed under the Apache License, version 2.0, the text of which
 is included above.


->>> Objenesis 3.1 (org.objenesis:objenesis:3.1):
+>>> JavaPoet 1.13.0 (com.squareup:javapoet:1.13.0):
+
+Per the LICENSE file in the JavaPoet JAR distribution downloaded from
+https://github.com/square/javapoet/archive/refs/tags/javapoet-1.13.0.zip,
+JavaPoet 1.13.0 is licensed under the Apache License, version 2.0, the text of
+which is included above.
+
+
+>>> Objenesis 3.2 (org.objenesis:objenesis:3.2):

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

 Per the NOTICE file in the Objenesis ZIP distribution downloaded from
--- a/Show More
+++ b/Show More