Release v6.0.0-RC4

Stop generating generic type as Object for unresolved generics
Closes gh-29454
2026-06-08 17:33:33 +00:00 · 2022-11-09 12:32:33 +00:00 · 2022-11-09 12:00:34 +01:00 · 2022-11-09 11:24:50 +01:00 · 2022-11-08 20:35:17 +01:00 · 2022-11-08 20:22:12 +01:00
4447 changed files with 137866 additions and 94515 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
@@ -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

@@ -1,297 +1,32 @@
 plugins {
-	id 'io.spring.dependency-management' version '1.0.11.RELEASE' apply false
 	id 'io.spring.nohttp' version '0.0.10'
-	id "io.freefair.aspectj" version '6.2.0' apply false
-	id 'org.jetbrains.dokka' version '1.5.0' apply false
-	id 'org.jetbrains.kotlin.jvm' version '1.5.32' apply false
-	id "org.jetbrains.kotlin.plugin.serialization" version "1.5.32" apply false
-	id 'org.asciidoctor.jvm.convert' version '3.3.2'
-	id 'org.asciidoctor.jvm.pdf' version '3.3.2'
-	id "org.unbroken-dome.xjc" version '2.0.0' apply false
-	id "com.github.ben-manes.versions" version '0.39.0'
-	id "com.github.johnrengelman.shadow" version '7.0.0' apply false
-	id 'de.undercouch.download' version '4.1.2'
-	id "me.champeau.jmh" version "0.6.6" apply false
+	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.6"
-			mavenBom "io.netty:netty-bom:4.1.72.Final"
-			mavenBom "io.projectreactor:reactor-bom:2020.0.15"
-			mavenBom "io.r2dbc:r2dbc-bom:Arabba-SR11"
-			mavenBom "io.rsocket:rsocket-bom:1.1.1"
-			mavenBom "org.eclipse.jetty:jetty-bom:9.4.44.v20210927"
-			mavenBom "org.jetbrains.kotlin:kotlin-bom:1.5.32"
-			mavenBom "org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.5.2"
-			mavenBom "org.jetbrains.kotlinx:kotlinx-serialization-bom:1.2.2"
-			mavenBom "org.junit:junit-bom:5.8.2"
+	repositories {
+		mavenCentral()
+		maven { url "https://repo.spring.io/libs-spring-framework-build" }
+		if (version.contains('-')) {
+			maven { url "https://repo.spring.io/milestone" }
 		}
-		dependencies {
-			dependencySet(group: 'org.apache.logging.log4j', version: '2.17.1') {
-				entry 'log4j-api'
-				entry 'log4j-core'
-				entry 'log4j-jul'
-				entry 'log4j-slf4j-impl'
-			}
-			dependency "org.slf4j:slf4j-api:1.7.32"
-			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.7') {
-				entry 'aspectjrt'
-				entry 'aspectjtools'
-				entry 'aspectjweaver'
-			}
-			dependencySet(group: 'org.codehaus.groovy', version: '3.0.9') {
-				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.1.3"
-			dependency "io.smallrye.reactive:mutiny:1.2.0"
-			dependency "io.projectreactor.tools:blockhound:1.0.6.RELEASE"
-
-			dependency "com.caucho:hessian:4.0.63"
-			dependency "com.fasterxml:aalto-xml:1.3.0"
-			dependency("com.fasterxml.woodstox:woodstox-core:6.2.7") {
-				exclude group: "stax", name: "stax-api"
-			}
-			dependency "com.google.code.gson:gson:2.8.9"
-			dependency "com.google.protobuf:protobuf-java-util:3.19.1"
-			dependency "com.googlecode.protobuf-java-format:protobuf-java-format:1.4"
-			dependency("com.thoughtworks.xstream:xstream:1.4.18") {
-				exclude group: "xpp3", name: "xpp3_min"
-				exclude group: "xmlpull", name: "xmlpull"
-			}
-			dependency "org.apache.johnzon:johnzon-jsonb:1.2.15"
-			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.30"
-
-			dependency "com.h2database:h2:2.0.206"
-			dependency "com.github.ben-manes.caffeine:caffeine:2.9.3"
-			dependency "com.github.librepdf:openpdf:1.3.26"
-			dependency "com.rometools:rome:1.16.0"
-			dependency "commons-io:commons-io:2.5"
-			dependency "io.vavr:vavr:0.10.4"
-			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.33.Final"
-			dependency "org.hibernate:hibernate-validator:6.2.1.Final"
-			dependency "org.webjars:webjars-locator-core:0.48"
-			dependency "org.webjars:underscorejs:1.8.3"
-
-			dependencySet(group: 'org.apache.tomcat', version: '9.0.56') {
-				entry 'tomcat-util'
-				entry('tomcat-websocket') {
-					exclude group: "org.apache.tomcat", name: "tomcat-servlet-api"
-					exclude group: "org.apache.tomcat", name: "tomcat-websocket-api"
-				}
-			}
-			dependencySet(group: 'org.apache.tomcat.embed', version: '9.0.56') {
-				entry 'tomcat-embed-core'
-				entry 'tomcat-embed-websocket'
-			}
-			dependencySet(group: 'io.undertow', version: '2.2.14.Final') {
-				entry 'undertow-core'
-				entry('undertow-servlet') {
-					exclude group: "org.jboss.spec.javax.servlet", name: "jboss-servlet-api_4.0_spec"
-					exclude group: "org.jboss.spec.javax.annotation", name: "jboss-annotations-api_1.3_spec"
-				}
-				entry('undertow-websockets-jsr') {
-					exclude group: "org.jboss.spec.javax.websocket", name: "jboss-websocket-api_1.1_spec"
-				}
-			}
-
-			dependency "org.eclipse.jetty:jetty-reactive-httpclient:1.1.10"
-			dependency 'org.apache.httpcomponents.client5:httpclient5:5.1.2'
-			dependency 'org.apache.httpcomponents.core5:httpcore5-reactive:5.1.2'
-			dependency("org.apache.httpcomponents:httpclient:4.5.13") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.apache.httpcomponents:httpasyncclient:4.1.5") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependencySet(group: 'com.squareup.okhttp3', version: '3.14.9') {
-				entry 'okhttp'
-				entry 'mockwebserver'
-			}
-
-			dependency "org.jruby:jruby:9.2.20.1"
-			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.junit.support:testng-engine:1.0.1"
-			dependency "org.hamcrest:hamcrest:2.1"
-			dependency "org.awaitility:awaitility:3.1.6"
-			dependency "org.assertj:assertj-core:3.22.0"
-			dependencySet(group: 'org.xmlunit', version: '2.8.4') {
-				entry 'xmlunit-assertj'
-				entry('xmlunit-matchers') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-			}
-			dependencySet(group: 'org.mockito', version: '4.2.0') {
-				entry('mockito-core') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-				entry 'mockito-junit-jupiter'
-			}
-			dependency "io.mockk:mockk:1.12.1"
-
-			dependency("net.sourceforge.htmlunit:htmlunit:2.56.0") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.seleniumhq.selenium:htmlunit-driver:2.56.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.6.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.13"
-			dependency "org.eclipse.persistence:org.eclipse.persistence.jpa:2.7.9"
-			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"
-		}
-		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 {
@@ -308,27 +43,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"
-		apply from: "${rootDir}/gradle/docs-dokka.gradle"
-
-		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 {
@@ -337,14 +62,29 @@ 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 = "9.2"
+		toolVersion = "10.3.4"
 		configDirectory.set(rootProject.file("src/checkstyle"))
 	}

+	tasks.named("checkstyleMain").configure {
+		maxHeapSize = "1g"
+	}
+
+	tasks.named("checkstyleTest").configure {
+		maxHeapSize = "1g"
+	}
+
 	dependencies {
+		dependencyManagement(enforcedPlatform(dependencies.project(path: ":framework-platform")))
 		testImplementation("org.junit.jupiter:junit-jupiter-api")
 		testImplementation("org.junit.jupiter:junit-jupiter-params")
 		testImplementation("org.junit.platform:junit-platform-suite-api")
@@ -362,20 +102,17 @@ configure([rootProject] + javaProjects) { project ->
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
-		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.29")
+		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/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/",
@@ -383,12 +120,21 @@ configure([rootProject] + javaProjects) { project ->
 			"https://hc.apache.org/httpcomponents-client-5.1.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
-			// Disabling linking to JUnit 5.8.2, since the `package-list` file no longer exists due to
-			// https://github.com/junit-team/junit5/commit/67ad4e545518b0ce2b0e7c96df31a669866d5003.
-			// "https://junit.org/junit5/docs/5.8.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/0.8.5.RELEASE/api/"
+			"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[]
 }

@@ -399,12 +145,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/**"
@@ -421,13 +163,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,8 +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("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 {
@@ -17,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;

 /**
@@ -34,7 +33,7 @@ import org.gradle.api.tasks.compile.JavaCompile;
 * @author Sam Brannen
 * @author Sebastien Deleuze
 */
-public class CompilerConventionsPlugin implements Plugin<Project> {
+public class JavaConventions {

 	private static final List<String> COMPILER_ARGS;

@@ -59,9 +58,8 @@ public class CompilerConventionsPlugin implements Plugin<Project> {
 				"-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));
 	}

 	/**
@@ -70,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));
+		});
+	}
+}
@@ -19,12 +19,9 @@ package org.springframework.build.optional;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.attributes.Usage;
 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
@@ -47,7 +44,7 @@ public class OptionalDependenciesPlugin implements Plugin<Project> {
 		optional.setCanBeConsumed(false);
 		optional.setCanBeResolved(false);
 		project.getPlugins().withType(JavaPlugin.class, (javaPlugin) -> {
-			SourceSetContainer sourceSets = project.getConvention().getPlugin(JavaPluginConvention.class)
+			SourceSetContainer sourceSets = project.getExtensions().getByType(JavaPluginExtension.class)
 					.getSourceSets();
 			sourceSets.all((sourceSet) -> {
 				project.getConfigurations().getByName(sourceSet.getCompileClasspathConfigurationName()).extendsFrom(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.
@@ -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-20210827
+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 JDK16 /opt/openjdk/java16
+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/adoptium/temurin8-binaries/releases/download/jdk8u302-b08/OpenJDK8U-jdk_x64_linux_hotspot_8u302b08.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/adoptium/temurin11-binaries/releases/download/jdk-11.0.12%2B7/OpenJDK11U-jdk_x64_linux_hotspot_11.0.12_7.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"
 	;;
-  java16)
-		 echo "https://github.com/adoptium/temurin16-binaries/releases/download/jdk-16.0.2%2B7/OpenJDK16U-jdk_x64_linux_hotspot_16.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 java16
+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: "5.3.x"
-milestone: "5.3.x"
+branch: "main"
+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
@@ -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,6 +45,11 @@ 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:
@@ -72,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
@@ -87,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
@@ -116,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-jdk16-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: jdk16-build
+    context: jdk19-build
 - name: slack-alert
  type: slack-notification
  icon: slack
@@ -157,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
@@ -202,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: jdk16-build
+- name: jdk18-build
  serial: true
  public: true
  plan:
@@ -257,25 +245,53 @@ jobs:
    - get: git-repo
    - get: every-morning
      trigger: true
-    - put: repo-status-jdk16-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-jdk16-build
+          - put: repo-status-jdk18-build
            params: { state: "failure", commit: "git-repo" }
          - put: slack-alert
            params:
              <<: *slack-fail-params
-    - put: repo-status-jdk16-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
@@ -340,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
@@ -385,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
@@ -430,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
@@ -458,7 +471,7 @@ jobs:

 groups:
 - name: "builds"
-  jobs: ["build", "jdk11-build", "jdk16-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; }

@@ -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.7'
+    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,15 +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)
 		addBooleanOption('Xdoclint:syntax', true) // only check syntax with doclint
-		addBooleanOption('Xwerror', true) // fail build on Javadoc warnings
-		if (JavaVersion.current().isJava9Compatible()) {
-			addBooleanOption('html5', true)
-		}
+		addBooleanOption('Werror', true) // fail build on Javadoc warnings
 	}
 	source moduleProjects.collect { project ->
 		project.sourceSets.main.allJava
@@ -62,49 +71,27 @@ task api(type: Javadoc) {
 /**
 * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
 */
-pluginManager.withPlugin("kotlin") {
-	tasks.dokkaHtmlMultiModule.configure {
-		dependsOn {
-			tasks.getByName("api")
-		}
-		moduleName.set("spring-framework")
-		outputDirectory.set(project.file("$buildDir/docs/kdoc"))
+rootProject.tasks.dokkaHtmlMultiModule.configure {
+	dependsOn {
+		tasks.getByName("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 {
 	def docRoot = 'https://docs.spring.io'
 	def docsSpringFramework = "${docRoot}/spring-framework/docs/${project.version}"
-	version = '2.4.1'
+	version = '2.4.3'
 	fatalWarnings ".*"
 	options doctype: 'book', eruby: 'erubis'
 	attributes([
 			icons: 'font',
 			idprefix: '',
 			idseparator: '-',
-			docinfo: 'shared,private-header', // https://docs.asciidoctor.org/asciidoctor/latest/docinfo/
 			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',
 			'doc-root': docRoot,
@@ -114,22 +101,24 @@ asciidoctorj {
 }

 /**
- * 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
 	}
 }

@@ -139,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', 'dokkaHtmlMultiModule']) {
+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")
@@ -169,7 +161,7 @@ task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', 'dok
 	from ("$asciidoctorPdf.outputDir") {
 		into "reference/pdf"
 	}
-	from (dokkaHtmlMultiModule.outputDirectory) {
+	from (rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
 		into "kdoc-api"
 	}
 }
@@ -248,3 +240,14 @@ task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 }

 distZip.mustRunAfter moduleProjects.check
+
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifact docsZip
+			artifact schemaZip
+			artifact distZip
+		}
+	}
+}
@@ -19,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]
@@ -37,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]
@@ -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.


@@ -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
@@ -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
 -----------------------------------------
@@ -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,191 @@
+[[aot]]
+= Ahead of Time Optimizations
+
+This chapter covers Spring's Ahead of Time (AOT) optimizations.
+
+[[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 need 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 proxy.
+
+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 `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 generate 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 configuration files.
+
+`ApplicationContextAotGenerator#processAheadOfTime` returns the class name of the `ApplicationContextInitializer` entry point that permits to start the context 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 any `GenericApplicationContext` implementations.
+An application context is created with any number of entry points, usually in the form of `@Configuration`-annotated classes.
+
+Let's take 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 is only applying a subset of what is happening with a <<beans-introduction,regular `refresh`>>.
+It 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 step makes 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` 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 instantiations but allow 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 reproduce a particular behavior.
+It can also contribute `RuntimeHints` to indicate the need for reflection, resource loading, serialization, or JDK proxy.
+
+`BeanFactoryInitializationAotProcessor` implementation should be registered in `META-INF/aot/spring.factories` with a key matching the fully qualified name of the interface.
+
+It can also be implemented on a bean directly.
+In this mode, the bean provides an AOT contribution equivalent to the feature it provides with a regular runtime.
+As such, such a bean is automatically excluded from the AOT-optimized context.
+
+[NOTE]
+====
+Using this interface on bean will cause the bean and **all** of its dependencies to be initialized during AOT processing.
+We generally recommend that this interface is only used with 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 a factory `@Bean` method, make sure to make it `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 about collecting the necessary contributions for each candidate `BeanDefinition`.
+It does so using a dedicated `BeanRegistrationAotProcessor`.
+
+This interface is used as follows:
+
+* On a `BeanPostProcessor` bean, to replace its runtime behavior.
+For instance <<beans-factory-extension-bpp-examples-aabpp,`AutowiredAnnotationBeanPostProcessor`>> is implementing this interface to generate code that injects members annotated with `@Autowired`.
+* On a type registered in `META-INF/aot/spring.factories` with a key matching the fully qualified name of the interface.
+Typically used whe the bean definition needs to be tuned for specific features of the core framework.
+
+[NOTE]
+====
+Using this interface on bean will cause the bean and **all** of its dependencies to be initialized during AOT processing.
+We generally recommend that this interface is only used with infrastructure beans such as `BeanPostProcessor` which have limited dependencies and are already initialized early in the bean factory lifecycle.
+If such a bean is registered using a factory `@Bean` method, make sure to make it `static` so that its enclosing `@Configuration` class does not have to be initialized.
+====
+
+If no `BeanRegistrationAotProcessor` handles a particular registered bean, the default implementation processes it.
+This should be the default behavior, as 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]
+----
+	@Configuration(proxyBeanMethods = false)
+	public class DataSourceConfiguration {
+
+		@Bean
+		public SimpleDataSource dataSource() {
+			return new SimpleDataSource();
+		}
+
+	}
+----
+
+As there isn't any particular condition on this class, `dataSourceConfiguration` and `dataSource` are identified as candidates.
+The AOT engine would convert the configuration class above to code like this:
+
+[source,java,indent=0]
+----
+    /**
+     * 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 create equivalent bean definitions 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`" bean and one for "`dataSourceBean`".
+When a `datasource` instance is required, a `BeanInstanceSupplier` is called.
+This supplier invokes the `dataSource()` method on the `dataSourceConfiguration` bean.
@@ -1,16 +1,17 @@
+[[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
@@ -35,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:
@@ -68,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`]
@@ -125,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 {

@@ -136,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 {

@@ -180,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:
@@ -227,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
@@ -302,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:
@@ -328,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:
@@ -383,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:
@@ -438,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:
@@ -494,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
@@ -524,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
@@ -549,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
@@ -559,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:
@@ -582,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,
@@ -611,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
@@ -623,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
@@ -652,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
@@ -664,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
@@ -693,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
@@ -765,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
@@ -836,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
@@ -926,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
@@ -938,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
@@ -957,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
@@ -981,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
@@ -1015,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
@@ -1195,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:

@@ -1222,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"]
@@ -1373,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,
@@ -1610,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
 		}
 	}
@@ -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...
@@ -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
@@ -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.
@@ -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"]
 ----
@@ -3092,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
@@ -4598,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]
 ====
@@ -4660,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`

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

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

 		// ...
@@ -4951,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.
 ====
@@ -5023,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`
@@ -5054,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
@@ -5876,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
@@ -5934,7 +5880,7 @@ named `movieFinder` injected into its setter method:
 ----
 	class SimpleMovieLister {

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

 	}
@@ -6199,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
@@ -6251,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.
 ====


@@ -6611,7 +6558,7 @@ and using "`stub`" repositories instead:
 .Kotlin
 ----
 	@Configuration
-	@ComponentScan(basePackages = "org.example",
+	@ComponentScan(basePackages = ["org.example"],
 			includeFilters = [Filter(type = FilterType.REGEX, pattern = [".*Stub.*Repository"])],
 			excludeFilters = [Filter(Repository::class)])
 	class AppConfig {
@@ -7205,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>
 ----
@@ -7225,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 {

@@ -7250,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 {

@@ -7274,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 {

@@ -7295,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(...)
 			// ...
 		}
 	}
@@ -7316,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 {

@@ -7334,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 {

@@ -7392,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 {
@@ -7417,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 {
@@ -7436,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 {
@@ -7455,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 {
@@ -7490,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.

@@ -7505,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
@@ -7520,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.
 |===
@@ -7900,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]]
@@ -8157,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`:
@@ -9316,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.
@@ -9647,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
@@ -9975,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
@@ -10211,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:
@@ -10635,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...
@@ -11048,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.
@@ -11104,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
@@ -11126,7 +11073,7 @@ 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
@@ -11151,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
@@ -125,7 +125,7 @@ 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 of an error or cancellation signal.
 . If a `Decoder` holds on to one or more data buffers in any other way, it must
@@ -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
@@ -792,8 +792,8 @@ See also the `org.springframework.beans.support.ResourceEditorRegistrar` for an
 `PropertyEditorRegistrar` implementation. Notice how in its implementation of the
 `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.



@@ -1738,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:
@@ -1773,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 {
@@ -1796,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)
@@ -1833,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
@@ -1869,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 {

@@ -1882,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 {

@@ -58,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
@@ -131,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
@@ -189,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
@@ -295,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:

@@ -326,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
@@ -349,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
@@ -378,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:
@@ -502,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
@@ -1015,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
@@ -1027,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"]
 ----
@@ -1046,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`:

@@ -1061,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"]
 ----
@@ -1076,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
@@ -1297,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
@@ -1473,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]]
@@ -1661,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:
@@ -1675,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.
@@ -1687,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
@@ -2415,32 +2479,32 @@ 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() {
@@ -2750,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
@@ -2816,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.
@@ -3108,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>>.
@@ -4249,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,
@@ -4263,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,
@@ -4285,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
@@ -6165,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.
@@ -7809,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
@@ -7819,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
@@ -7831,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
@@ -7964,11 +8019,11 @@ 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"]
@@ -7978,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
@@ -8056,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.)
@@ -8349,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.
 ****

@@ -8422,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:
@@ -5,7 +5,7 @@
 <<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,
@@ -14,20 +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>> :: Spring properties.
-https://github.com/spring-projects/spring-framework/wiki[*Wiki*] :: What's New, Upgrade Notes, Supported Versions,
-and other cross-version information.
+https://github.com/spring-projects/spring-framework/wiki[*Wiki*] :: What's New,
+Upgrade Notes, Supported Versions, and other cross-version information.

-ifdef::backend-html5[]
-NOTE: This documentation is also available as {docs-spring-framework}/reference/pdf/index.pdf[PDF].
-endif::[]
-
-ifdef::backend-pdf[]
-NOTE: This documentation is also available as {docs-spring-framework}/reference/html/index.html[HTML].
-endif::[]
+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
@@ -36,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`,
@@ -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,7 +44,7 @@ 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 {docs-spring-framework}/kdoc-api/spring-framework/[Spring Framework KDoc API] lists
+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,
@@ -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 {docs-spring-framework}/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 {docs-spring-framework}/kdoc-api/spring-framework/org.springframework.web.servlet.function/router.html[router { }]
-* WebFlux.fn <<web-reactive#webflux-fn, Reactive>> DSL with {docs-spring-framework}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/router.html[router { }]
-* WebFlux.fn <<Coroutines>> DSL with {docs-spring-framework}/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 {docs-spring-framework}/kdoc-api/spring-framework/org.springframework.web.reactive.function.client/index.html[client] and {docs-spring-framework}/kdoc-api/spring-framework/org.springframework.web.reactive.function.server/index.html[server] functional API.
-* WebFlux.fn {docs-spring-framework}/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 {docs-spring-framework}/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 {docs-spring-framework}/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)`]
@@ -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.
@@ -32,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
@@ -78,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
@@ -92,7 +92,7 @@ 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
@@ -214,7 +214,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
@@ -498,7 +498,7 @@ 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...
 	}
@@ -508,7 +508,7 @@ The following example shows such a case:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	@ContextConfiguration(initializers = [CustomContextIntializer::class]) // <1>
+	@ContextConfiguration(initializers = [CustomContextInitializer::class]) // <1>
 	class ContextInitializerTests {
 		// class body...
 	}
@@ -1098,10 +1098,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:

@@ -1132,7 +1132,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`
@@ -1476,13 +1478,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>>_

@@ -1871,7 +1872,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.

@@ -1960,6 +1961,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`

@@ -2008,6 +2022,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

@@ -2434,12 +2461,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

@@ -2497,7 +2558,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
@@ -2672,8 +2733,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
@@ -2681,6 +2740,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
@@ -3088,7 +3173,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
@@ -4245,7 +4330,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);
 		}

@@ -4269,7 +4354,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)
 			}
 		}
@@ -5624,7 +5709,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
@@ -5746,6 +5830,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
@@ -6835,7 +6999,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.
@@ -6923,7 +7087,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();
 		}

 		// ...
@@ -7238,7 +7402,7 @@ no other expectations will be asserted.
 	import org.springframework.test.web.servlet.get

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

@@ -7286,7 +7450,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")
 		}
@@ -7314,7 +7478,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")
 			}
@@ -7344,7 +7508,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()
 	// ...
 ----

@@ -7424,10 +7588,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.
@@ -7464,7 +7628,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>
@@ -7473,7 +7637,7 @@ or reactive type such as Reactor `Mono`:

 		mockMvc.perform(asyncDispatch(mvcResult)) // <4>
 				.andExpect {
-					status().isOk() // <5>
+					status { isOk() } // <5>
 					content().string("body")
 				}
 	}
@@ -7600,13 +7764,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.
@@ -7933,11 +8097,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]]
@@ -8544,7 +8708,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?
@@ -8647,7 +8811,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:
@@ -8664,7 +8828,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]]
@@ -7,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,
@@ -17,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]


@@ -49,21 +61,15 @@ it helps to express cardinality -- for example, whether a single or multiple asy
 values are expected, and that can be essential for making decisions (for example, when
 encoding or decoding HTTP messages).

-For annotated controllers, WebFlux transparently adapts to the reactive library chosen
-by 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 3, Kotlin coroutines and SmallRye Mutiny,
-but you can register other third-party adapters as well.
+For annotated controllers, WebFlux transparently adapts to the reactive library chosen by
+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 3, Kotlin coroutines and SmallRye Mutiny, but you can
+register others, too.

-[NOTE]
-====
-As of Spring Framework 5.3.11, support for RxJava 1 and 2 is deprecated, following
-RxJava's own EOL advice and the upgrade recommendation towards RxJava 3.
-====
-
-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
+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
 `Publisher` as input. When a `Publisher`, whether custom or from another reactive library,
 is provided, it can be treated only as a stream with unknown semantics (0..N). If, however,
 the semantics are known, you can wrap it with `Flux` or `Mono.from(Publisher)` instead
@@ -36,7 +36,7 @@ context`"). This section details how you can configure a Spring container (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#

@@ -101,12 +101,11 @@ You can shorten it further still with a full URI template, as the following exam



-
-[[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#

@@ -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].



@@ -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`.
@@ -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();
@@ -555,7 +591,7 @@ depending on the response status:
 				}
 				else {
 					// Turn to error
-					return response.createException().flatMap(Mono::error);
+					return response.createError();
 				}
 			});
 ----
@@ -754,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()
 ----

@@ -823,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]]
@@ -1056,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>()
@@ -1111,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]]
@@ -1200,7 +1200,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 +1348,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>>#
@@ -1541,9 +1564,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 ca 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 +1693,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 +1875,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 +1968,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
@@ -2257,7 +2288,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 +2301,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 +2431,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 +2778,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 +2826,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 +2971,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 +3078,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 +3422,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 +3490,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 +3588,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 +3923,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]]
@@ -4252,12 +4507,18 @@ 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.
@@ -4283,9 +4544,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));
 		}
 	}
 ----
@@ -4300,9 +4559,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
@@ -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
@@ -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();
 ----
@@ -800,7 +800,7 @@ For instance, consider the following example:
 						.header("X-RequestHeader", "Value").build()
 			}
 		}
-		POST("/person", handler::createPerson)
+		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.
@@ -622,7 +622,7 @@ 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.
@@ -1,6 +1,7 @@
 [[mvc]]
+:chapter: mvc
 = Spring Web MVC
-:doc-spring-security: {doc-root}/spring-security/site/docs/current/reference
+:doc-spring-security: {doc-root}/spring-security/reference

 Spring Web MVC is the original web framework built on the Servlet API and has been included
 in the Spring Framework from the very beginning. The formal name, "`Spring Web MVC,`"
@@ -14,7 +15,7 @@ whose name, "`Spring WebFlux,`" is also based on its source module
 This section covers Spring Web MVC. The <<web-reactive.adoc#spring-web-reactive, next section>>
 covers Spring WebFlux.

-For baseline information and compatibility with Servlet container and Java EE version
+For baseline information and compatibility with Servlet container and Jakarta EE version
 ranges, see the Spring Framework
 https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Versions[Wiki].

@@ -84,6 +85,11 @@ NOTE: In addition to using the ServletContext API directly, you can also extend
 `AbstractAnnotationConfigDispatcherServletInitializer` and override specific methods
 (see the example under <<mvc-servlet-context-hierarchy>>).

+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.
+
 The following example of `web.xml` configuration registers and initializes the `DispatcherServlet`:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -315,9 +321,9 @@ provides many extra convenient options.
 [[mvc-container-config]]
 === Servlet Config

-In a Servlet 3.0+ environment, you have the option of configuring the Servlet container
-programmatically as an alternative or in combination with a `web.xml` file. The following
-example registers a `DispatcherServlet`:
+In a Servlet environment, you have the option of configuring the Servlet container
+programmatically as an alternative or in combination with a `web.xml` file.
+The following example registers a `DispatcherServlet`:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -528,7 +534,7 @@ resolve exceptions thrown during request processing. Those exception resolvers a
 customizing the logic to address exceptions. See <<mvc-exceptionhandlers>> for more details.

 For HTTP caching support, handlers can use the `checkNotModified` methods of `WebRequest`,
-along with further options for annoated controllers as described in
+along with further options for annotated controllers as described in
 <<mvc-caching-etag-lastmodified,HTTP Caching for Controllers>>.

 You can customize individual `DispatcherServlet` instances by adding Servlet
@@ -575,8 +581,8 @@ initialization parameters (`init-param` elements) to the Servlet declaration in
 The Servlet API exposes the full request path as `requestURI` and further sub-divides it
 into `contextPath`, `servletPath`, and `pathInfo` whose values vary depending on how a
 Servlet is mapped. From these inputs, Spring MVC needs to determine the lookup path to
-use for handler mapping, which is the path within the mapping of the `DispatcherServlet`
-itself, excluding the `contextPath` and any `servletMapping` prefix, if present.
+use for mapping handlers, which should exclude the `contextPath` and any `servletMapping`
+prefix, if applicable.

 The `servletPath` and `pathInfo` are decoded and that makes them impossible to compare
 directly to the full `requestURI` in order to derive the lookupPath and that makes it
@@ -606,15 +612,17 @@ encoded path which may not always work well. Furthermore, sometimes the
 `DispatcherServlet` needs to share the URL space with another Servlet and may need to
 be mapped by prefix.

-The above issues can be addressed more comprehensively by switching from `PathMatcher` to
-the parsed `PathPattern` available in 5.3 or higher, see
-<<mvc-ann-requestmapping-pattern-comparison>>. Unlike `AntPathMatcher` which needs
-either the lookup path decoded or the controller mapping encoded, a parsed `PathPattern`
-matches to a parsed representation of the path called `RequestPath`, one path segment
-at a time. This allows decoding and sanitizing path segment values individually without
-the risk of altering the structure of the path. Parsed `PathPattern` also supports
-the use of `servletPath` prefix mapping as long as the prefix is kept simple and does
-not have any characters that need to be encoded.
+The above issues are addressed when using `PathPatternParser` and parsed patterns, as
+an alternative to String path matching with `AntPathMatcher`. The `PathPatternParser` has
+been available for use in Spring MVC from version 5.3, and is enabled by default from
+version 6.0. Unlike `AntPathMatcher` which needs either the lookup path decoded or the
+controller mapping encoded, a parsed `PathPattern` matches to a parsed representation
+of the path called `RequestPath`, one path segment at a time. This allows decoding and
+sanitizing path segment values individually without the risk of altering the structure
+of the path. Parsed `PathPattern` also supports the use of `servletPath` prefix mapping
+as long as a Servlet path mapping is used and the prefix is kept simple, i.e. it has no
+encoded characters. For pattern syntax details and comparison, see
+<<mvc-ann-requestmapping-pattern-comparison>>.



@@ -643,7 +651,7 @@ See <<mvc-config-interceptors>> in the section on MVC configuration for examples
 configure interceptors. You can also register them directly by using setters on individual
 `HandlerMapping` implementations.

-Note that `postHandle` is less useful with `@ResponseBody` and `ResponseEntity` methods for
+`postHandle` method is less useful with `@ResponseBody` and `ResponseEntity` methods for
 which the response is written and committed within the `HandlerAdapter` and before
 `postHandle`. That means it is too late to make any changes to the response, such as adding
 an extra header. For such scenarios, you can implement `ResponseBodyAdvice` and either
@@ -652,6 +660,7 @@ declare it as an <<mvc-ann-controller-advice>> bean or configure it directly on



+
 [[mvc-exceptionhandlers]]
 === Exceptions
 [.small]#<<web-reactive.adoc#webflux-dispatcher-exceptions, WebFlux>>#
@@ -686,7 +695,7 @@ The following table lists the available `HandlerExceptionResolver` implementatio
 |===


-[[mvc-excetionhandlers-handling]]
+[[mvc-exceptionhandlers-handling]]
 ==== Chain of Resolvers

 You can form an exception resolver chain by declaring multiple `HandlerExceptionResolver`
@@ -736,8 +745,8 @@ or to render a JSON response, as the following example shows:
 		@RequestMapping(path = "/error")
 		public Map<String, Object> handle(HttpServletRequest request) {
 			Map<String, Object> map = new HashMap<String, Object>();
-			map.put("status", request.getAttribute("javax.servlet.error.status_code"));
-			map.put("reason", request.getAttribute("javax.servlet.error.message"));
+			map.put("status", request.getAttribute("jakarta.servlet.error.status_code"));
+			map.put("reason", request.getAttribute("jakarta.servlet.error.message"));
 			return map;
 		}
 	}
@@ -751,8 +760,8 @@ or to render a JSON response, as the following example shows:
 		@RequestMapping(path = ["/error"])
 		fun handle(request: HttpServletRequest): Map<String, Any> {
 			val map = HashMap<String, Any>()
-			map["status"] = request.getAttribute("javax.servlet.error.status_code")
-			map["reason"] = request.getAttribute("javax.servlet.error.message")
+			map["status"] = request.getAttribute("jakarta.servlet.error.status_code")
+			map["reason"] = request.getAttribute("jakarta.servlet.error.message")
 			return map
 		}
 	}
@@ -1044,6 +1053,9 @@ application, thereby enhancing user experience. A theme is a collection of stati
 resources, typically style sheets and images, that affect the visual style of the
 application.

+WARNING: as of 6.0 support for themes has been deprecated theme in favor of using CSS,
+and without any special support on the server side.
+

 [[mvc-themeresolver-defining]]
 ==== Defining a theme
@@ -1132,7 +1144,7 @@ request with a simple request parameter.
 `MultipartResolver` from the `org.springframework.web.multipart` package is a strategy
 for parsing multipart requests including file uploads. There is one implementation
 based on https://commons.apache.org/proper/commons-fileupload[Commons FileUpload] and
-another based on Servlet 3.0 multipart request parsing.
+another based on Servlet multipart request parsing.

 To enable multipart handling, you need to declare a `MultipartResolver` bean in your
 `DispatcherServlet` Spring configuration with a name of `multipartResolver`.
@@ -1163,9 +1175,9 @@ javadoc for details and configuration options.


 [[mvc-multipart-resolver-standard]]
-==== Servlet 3.0
+==== Servlet Multipart Parsing

-Servlet 3.0 multipart parsing needs to be enabled through Servlet container configuration.
+Servlet multipart parsing needs to be enabled through Servlet container configuration.
 To do so:

 * In Java, set a `MultipartConfigElement` on the Servlet registration.
@@ -1205,7 +1217,7 @@ The following example shows how to set a `MultipartConfigElement` on the Servlet
 	}
 ----

-Once the Servlet 3.0 configuration is in place, you can add a bean of type
+Once the Servlet multipart configuration is in place, you can add a bean of type
 `StandardServletMultipartResolver` with a name of `multipartResolver`.

 [NOTE]
@@ -1512,17 +1524,23 @@ directly to the response body versus view resolution and rendering with an HTML

 [[mvc-ann-requestmapping-proxying]]
 ==== AOP Proxies
+[.small]#<<web-reactive.adoc#webflux-ann-requestmapping-proxying, WebFlux>>#

 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 typically the default choice with controllers.
-However, if a controller must implement an interface that is not a Spring Context
-callback (such as `InitializingBean`, `*Aware`, and others), you may need to explicitly
-configure class-based proxying. For example, with `<tx:annotation-driven/>` you can
-change to `<tx:annotation-driven proxy-target-class="true"/>`, and with
-`@EnableTransactionManagement` you can change to
-`@EnableTransactionManagement(proxyTargetClass = true)`.
+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 MVC 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.



@@ -1606,11 +1624,11 @@ filesystem, and other locations. It is less efficient and the String path input
 challenge for dealing effectively with encoding and other issues with URLs.

 `PathPattern` is the recommended solution for web applications and it is the only choice in
-Spring WebFlux. Prior to version 5.3, `AntPathMatcher` was the only choice in Spring MVC
-and continues to be the default. However `PathPattern` can be enabled in the
-<<mvc-config-path-matching, MVC config>>.
+Spring WebFlux. It was enabled for use in Spring MVC from version 5.3 and is enabled by
+default from version 6.0. See <<mvc-config-path-matching, MVC config>> for
+customizations of path matching options.

-`PathPattern` supports the same pattern syntax as `AntPathMatcher`. In addition it also
+`PathPattern` supports the same pattern syntax as `AntPathMatcher`. In addition, it also
 supports the capturing pattern, e.g. `+{*spring}+`, for matching 0 or more path segments
 at the end of a path. `PathPattern` also restricts the use of `+**+` for matching multiple
 path segments such that it's only allowed at the end of a pattern. This eliminates many
@@ -1707,9 +1725,9 @@ extracts the name, version, and file extension:
 ----

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



@@ -1932,7 +1950,7 @@ instead.

 `@GetMapping` (and `@RequestMapping(method=HttpMethod.GET)`) support HTTP HEAD
 transparently for request mapping. Controller methods do not need to change.
-A response wrapper, applied in `javax.servlet.http.HttpServlet`, ensures a `Content-Length`
+A response wrapper, applied in `jakarta.servlet.http.HttpServlet`, ensures a `Content-Length`
 header is set to the number of bytes written (without actually writing to the response).

 `@GetMapping` (and `@RequestMapping(method=HttpMethod.GET)`) are implicitly mapped to
@@ -2053,17 +2071,17 @@ and others) and is equivalent to `required=false`.
 | Generic access to request parameters and request and session attributes, without direct
  use of the Servlet API.

-| `javax.servlet.ServletRequest`, `javax.servlet.ServletResponse`
+| `jakarta.servlet.ServletRequest`, `jakarta.servlet.ServletResponse`
 | Choose any specific request or response type -- for example, `ServletRequest`, `HttpServletRequest`,
  or Spring's `MultipartRequest`, `MultipartHttpServletRequest`.

-| `javax.servlet.http.HttpSession`
+| `jakarta.servlet.http.HttpSession`
 | Enforces the presence of a session. As a consequence, such an argument is never `null`.
  Note that session access is not thread-safe. Consider setting the
  `RequestMappingHandlerAdapter` instance's `synchronizeOnSession` flag to `true` if multiple
  requests are allowed to concurrently access a session.

-| `javax.servlet.http.PushBuilder`
+| `jakarta.servlet.http.PushBuilder`
 | Servlet 4.0 push builder API for programmatic HTTP/2 resource pushes.
  Note that, per the Servlet specification, the injected `PushBuilder` instance can be null if the client
  does not support that HTTP/2 feature.
@@ -2170,7 +2188,7 @@ and others) and is equivalent to `required=false`.
 | Any other argument
 | If a method argument is not matched to any of the earlier values in this table and it is
  a simple type (as determined by
-	{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
+	{api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty]),
  it is resolved as a `@RequestParam`. Otherwise, it is resolved as a `@ModelAttribute`.
 |===

@@ -2198,6 +2216,14 @@ 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 <<mvc-ann-rest-exceptions>>
+
+| `ProblemDetail`
+| To render an RFC 7807 error response with details in the body,
+  see <<mvc-ann-rest-exceptions>>
+
 | `String`
 | A view name to be resolved with `ViewResolver` implementations and used together with the implicit
  model -- determined through command objects and `@ModelAttribute` methods. The handler
@@ -2777,7 +2803,7 @@ alternatively, set `@ModelAttribute(binding=false)`, as the following example sh
 <1> Setting `@ModelAttribute(binding=false)`.

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

@@ -2927,7 +2953,7 @@ as the following example shows:

 For use cases that require adding or removing session attributes, consider injecting
 `org.springframework.web.context.request.WebRequest` or
-`javax.servlet.http.HttpSession` into the controller method.
+`jakarta.servlet.http.HttpSession` into the controller method.

 For temporary storage of model attributes in the session as part of a controller
 workflow, consider using `@SessionAttributes` as described in
@@ -3116,7 +3142,7 @@ When the `@RequestParam` annotation is declared as a `Map<String, MultipartFile>
 `MultiValueMap<String, MultipartFile>`, without a parameter name specified in the annotation,
 then the map is populated with the multipart files for each given parameter name.

-NOTE: With Servlet 3.0 multipart parsing, you may also declare `javax.servlet.http.Part`
+NOTE: With Servlet multipart parsing, you may also declare `jakarta.servlet.http.Part`
 instead of Spring's `MultipartFile`, as a method argument or collection value type.

 You can also use multipart content as part of data binding to a
@@ -3218,7 +3244,7 @@ probably want it deserialized from JSON (similar to `@RequestBody`). Use the
 	}
 ----

-You can use `@RequestPart` in combination with `javax.validation.Valid` or use Spring's
+You can use `@RequestPart` in combination with `jakarta.validation.Valid` or use Spring's
 `@Validated` annotation, both of which cause Standard Bean Validation to be applied.
 By default, validation errors cause a `MethodArgumentNotValidException`, which is turned
 into a 400 (BAD_REQUEST) response. Alternatively, you can handle validation errors locally
@@ -3275,7 +3301,7 @@ The following example uses a `@RequestBody` argument:
 You can use the <<mvc-config-message-converters>> option of the <<mvc-config>> to
 configure or customize message conversion.

-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, both of which cause Standard Bean Validation to be applied.
 By default, validation errors cause a `MethodArgumentNotValidException`, which is turned
 into a 400 (BAD_REQUEST) response. Alternatively, you can handle validation errors locally
@@ -3381,7 +3407,7 @@ See <<mvc-ann-jackson>> for details.
 	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"]
@@ -3746,6 +3772,13 @@ controller-specific `Formatter` implementations, as the following example shows:
 ----
 <1> Defining an `@InitBinder` method on a custom formatter.

+[[mvc-ann-initbinder-model-design]]
+==== Model Design
+[.small]#<<web-reactive.adoc#webflux-ann-initbinder-model-design, WebFlux>>#
+
+include::web-data-binding-model-design.adoc[]
+
+
 [[mvc-ann-exceptionhandler]]
 === Exceptions
 [.small]#<<web-reactive.adoc#webflux-ann-controller-exceptions, WebFlux>>#
@@ -3874,6 +3907,7 @@ level, <<mvc-exceptionhandlers, HandlerExceptionResolver>> mechanism.

 [[mvc-ann-exceptionhandler-args]]
 ==== Method Arguments
+[.small]#<<webflux.adoc#webflux-ann-exceptionhandler-args, WebFlux>>#

 `@ExceptionHandler` methods support the following arguments:

@@ -3891,11 +3925,11 @@ level, <<mvc-exceptionhandlers, HandlerExceptionResolver>> mechanism.
 | Generic access to request parameters and request and session attributes without direct
  use of the Servlet API.

-| `javax.servlet.ServletRequest`, `javax.servlet.ServletResponse`
+| `jakarta.servlet.ServletRequest`, `jakarta.servlet.ServletResponse`
 | Choose any specific request or response type (for example, `ServletRequest` or
  `HttpServletRequest` or Spring's `MultipartRequest` or `MultipartHttpServletRequest`).

-| `javax.servlet.http.HttpSession`
+| `jakarta.servlet.http.HttpSession`
 | Enforces the presence of a session. As a consequence, such an argument is never `null`. +
  Note that session access is not thread-safe. Consider setting the
  `RequestMappingHandlerAdapter` instance's `synchronizeOnSession` flag to `true` if multiple
@@ -3938,6 +3972,7 @@ level, <<mvc-exceptionhandlers, HandlerExceptionResolver>> mechanism.

 [[mvc-ann-exceptionhandler-return-values]]
 ==== Return Values
+[.small]#<<webflux.adoc#webflux-ann-exceptionhandler-return-values, WebFlux>>#

 `@ExceptionHandler` methods support the following return values:

@@ -3954,6 +3989,14 @@ level, <<mvc-exceptionhandlers, HandlerExceptionResolver>> mechanism.
  be converted through `HttpMessageConverter` instances and written to the response.
  See <<mvc-ann-responseentity>>.

+| `ErrorResponse`
+| To render an RFC 7807 error response with details in the body,
+see <<mvc-ann-rest-exceptions>>
+
+| `ProblemDetail`
+| To render an RFC 7807 error response with details in the body,
+see <<mvc-ann-rest-exceptions>>
+
 | `String`
 | A view name to be resolved with `ViewResolver` implementations and used together with the
  implicit model -- determined through command objects and `@ModelAttribute` methods.
@@ -3996,26 +4039,6 @@ level, <<mvc-exceptionhandlers, HandlerExceptionResolver>> mechanism.
 |===


-[[mvc-ann-rest-exceptions]]
-==== REST API exceptions
-[.small]#<<web-reactive.adoc#webflux-ann-rest-exceptions, WebFlux>>#
-
-A common requirement for REST services is to include error details in the body of the
-response. The Spring Framework does not automatically do this because the representation
-of error details in the response body is application-specific. However, a
-`@RestController` may 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.
-
-Applications that implement global exception handling with error details in the response
-body should consider extending
-{api-spring-framework}/web/servlet/mvc/method/annotation/ResponseEntityExceptionHandler.html[`ResponseEntityExceptionHandler`],
-which provides handling for exceptions that Spring MVC raises and provides hooks to
-customize the response body. To make use of this, create a subclass of
-`ResponseEntityExceptionHandler`, annotate it with `@ControllerAdvice`, override the
-necessary methods, and declare it as a Spring bean.
-
-

 [[mvc-ann-controller-advice]]
 === Controller Advice
@@ -4102,24 +4125,22 @@ as the following example shows:
 ----
 	HttpServletRequest request = ...

-	// Re-uses host, scheme, port, path and query string...
+	// Re-uses scheme, host, port, path, and query string...

-	ServletUriComponentsBuilder ucb = ServletUriComponentsBuilder.fromRequest(request)
-			.replaceQueryParam("accountId", "{id}").build()
-			.expand("123")
-			.encode();
+	URI uri = ServletUriComponentsBuilder.fromRequest(request)
+			.replaceQueryParam("accountId", "{id}")
+			.build("123");
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	val request: HttpServletRequest = ...

-	// Re-uses host, scheme, port, path and query string...
+	// Re-uses scheme, host, port, path, and query string...

-	val ucb = ServletUriComponentsBuilder.fromRequest(request)
-			.replaceQueryParam("accountId", "{id}").build()
-			.expand("123")
-			.encode()
+	val uri = ServletUriComponentsBuilder.fromRequest(request)
+			.replaceQueryParam("accountId", "{id}")
+			.build("123")
 ----

 You can create URIs relative to the context path, as the following example shows:
@@ -4127,18 +4148,26 @@ You can create URIs relative to the context path, as the following example shows
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	// Re-uses host, port and context path...
+	HttpServletRequest request = ...

-	ServletUriComponentsBuilder ucb = ServletUriComponentsBuilder.fromContextPath(request)
-			.path("/accounts").build()
+	// Re-uses scheme, host, port, and context path...
+
+	URI uri = ServletUriComponentsBuilder.fromContextPath(request)
+			.path("/accounts")
+			.build()
+			.toUri();
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	// Re-uses host, port and context path...
+	val request: HttpServletRequest = ...

-	val ucb = ServletUriComponentsBuilder.fromContextPath(request)
-			.path("/accounts").build()
+	// Re-uses scheme, host, port, and context path...
+
+	val uri = ServletUriComponentsBuilder.fromContextPath(request)
+			.path("/accounts")
+			.build()
+			.toUri()
 ----

 You can create URIs relative to a Servlet (for example, `/main/{asterisk}`),
@@ -4147,18 +4176,26 @@ as the following example shows:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	// Re-uses host, port, context path, and Servlet prefix...
+	HttpServletRequest request = ...

-	ServletUriComponentsBuilder ucb = ServletUriComponentsBuilder.fromServletMapping(request)
-			.path("/accounts").build()
+	// Re-uses scheme, host, port, context path, and Servlet mapping prefix...
+
+	URI uri = ServletUriComponentsBuilder.fromServletMapping(request)
+			.path("/accounts")
+			.build()
+			.toUri();
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	// Re-uses host, port, context path, and Servlet prefix...
+	val request: HttpServletRequest = ...

-	val ucb = ServletUriComponentsBuilder.fromServletMapping(request)
-			.path("/accounts").build()
+	// Re-uses scheme, host, port, context path, and Servlet mapping prefix...
+
+	val uri = ServletUriComponentsBuilder.fromServletMapping(request)
+			.path("/accounts")
+			.build()
+			.toUri()
 ----

 NOTE: As of 5.1, `ServletUriComponentsBuilder` ignores information from the `Forwarded` and
@@ -4350,7 +4387,7 @@ capital letters of the class and the method name (for example, the `getThing` me
 == Asynchronous Requests
 [.small]#<<mvc-ann-async-vs-webflux, Compared to WebFlux>>#

-Spring MVC has an extensive integration with Servlet 3.0 asynchronous request
+Spring MVC has an extensive integration with Servlet asynchronous request
 <<mvc-ann-async-processing,processing>>:

 * <<mvc-ann-async-deferredresult, `DeferredResult`>> and <<mvc-ann-async-callable, `Callable`>>
@@ -4524,10 +4561,10 @@ methods for timeout and completion callbacks.
 ==== Compared to WebFlux

 The Servlet API was originally built for making a single pass through the Filter-Servlet
-chain. Asynchronous request processing, added in Servlet 3.0, lets applications exit
-the Filter-Servlet chain but leave the response open for further processing. The Spring MVC
-asynchronous support is built around that mechanism. When a controller returns a `DeferredResult`,
-the Filter-Servlet chain is exited, and the Servlet container thread is released. Later, when
+chain. Asynchronous request processing lets applications exit the Filter-Servlet chain
+but leave the response open for further processing. The Spring MVC asynchronous support
+is built around that mechanism. When a controller returns a `DeferredResult`, the
+Filter-Servlet chain is exited, and the Servlet container thread is released. Later, when
 the `DeferredResult` is set, an `ASYNC` dispatch (to the same URL) is made, during which the
 controller is mapped again but, rather than invoking it, the `DeferredResult` value is used
 (as if the controller returned it) to resume processing.
@@ -4738,6 +4775,46 @@ suitable under load. If you plan to stream with a reactive type, you should use



+[[mvc-ann-async-context-propagation]]
+=== Context Propagation
+
+It is common to propagate context via `java.lang.ThreadLocal`. This works transparently
+for handling on the same thread, but requires additional work for asynchronous handling
+across multiple threads. The Micrometer
+https://github.com/micrometer-metrics/context-propagation#context-propagation-library[Context Propagation]
+library simplifies context propagation across threads, and across context mechanisms such
+as `ThreadLocal` values,
+Reactor https://projectreactor.io/docs/core/release/reference/#context[context],
+GraphQL Java https://www.graphql-java.com/documentation/concerns/#context-objects[context],
+and others.
+
+If Micrometer Context Propagation is present on the classpath, when a controller method
+returns a <<mvc-ann-async-reactive-types,reactive type>> such as `Flux` or `Mono`, all
+`ThreadLocal` values, for which there is a registered `io.micrometer.ThreadLocalAccessor`,
+are written to the Reactor `Context` as key-value pairs, using the key assigned by the
+`ThreadLocalAccessor`.
+
+For other asynchronous handling scenarios, you can use the Context Propagation library
+directly. For example:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	// Capture ThreadLocal values from the main thread ...
+	ContextSnapshot snapshot = ContextSnapshot.captureAll();
+
+	// On a different thread: restore ThreadLocal values
+	try (ContextSnapshot.Scope scoped = snapshot.setThreadLocals()) {
+		// ...
+	}
+----
+
+For more details, see the
+https://micrometer.io/docs/contextPropagation[documentation] of the Micrometer Context
+Propagation library.
+
+
+
 [[mvc-ann-async-disconnects]]
 === Disconnects
 [.small]#<<web-reactive.adoc#webflux-codecs-streaming, WebFlux>>#
@@ -4768,7 +4845,7 @@ The MVC configuration also exposes several options for asynchronous requests.

 Filter and Servlet declarations have an `asyncSupported` flag that needs to be set to `true`
 to enable asynchronous request processing. In addition, Filter mappings should be
-declared to handle the `ASYNC` `javax.servlet.DispatchType`.
+declared to handle the `ASYNC` `jakarta.servlet.DispatchType`.

 In Java configuration, when you use `AbstractAnnotationConfigDispatcherServletInitializer`
 to initialize the Servlet container, this is done automatically.
@@ -4801,23 +4878,210 @@ Note that you can also set the default timeout value on a `DeferredResult`,
 a `ResponseBodyEmitter`, and an `SseEmitter`. For a `Callable`, you can use
 `WebAsyncTask` to provide a timeout value.

+
 include::webmvc-cors.adoc[leveloffset=+1]


+[[mvc-ann-rest-exceptions]]
+== Error Responses
+[.small]#<<web-reactive.adoc#webflux-ann-rest-exceptions, WebFlux>>#
+
+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 MVC
+exceptions implement this.
+- `ErrorResponseException` -- basic `ErrorResponse` implementation that others
+can use as a convenient base class.
+- `ResponseEntityExceptionHandler` -- convenient base class for an
+<<mvc-ann-controller-advice,@ControllerAdvice>> that handles all Spring MVC exceptions,
+and any `ErrorResponseException`, and renders an error response with a body.
+
+
+
+[[mvc-ann-rest-exceptions-render]]
+=== Render
+[.small]#<<web-reactive.adoc#webflux-ann-rest-exceptions-render, WebFlux>>#
+
+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
+<<mvc-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`.
+
+
+
+[[mvc-ann-rest-exceptions-non-standard]]
+=== Non-Standard Fields
+[.small]#<<web-reactive.adoc#webflux-ann-rest-exceptions-non-standard, WebFlux>>#
+
+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.
+
+
+
+[[mvc-ann-rest-exceptions-i18n]]
+=== Internationalization
+[.small]#<<web-reactive.adoc#webflux-ann-rest-exceptions-i18n, WebFlux>>#
+
+It is a common requirement to internationalize error response details, and good practice
+to customize the problem details for Spring MVC 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 MVC exceptions:
+
+[[mvc-ann-rest-exceptions-codes]]
+[cols="1,1,2", options="header"]
+|===
+| Exception | Message Code | Message Code Arguments
+
+| `AsyncRequestTimeoutException`
+| (default)
+|
+
+| `ConversionNotSupportedException`
+| (default)
+| `{0}` property name, `{1}` property value
+
+| `HttpMediaTypeNotAcceptableException`
+| (default)
+| `{0}` list of supported media types
+
+| `HttpMediaTypeNotAcceptableException`
+| (default) + ".parseError"
+|
+
+| `HttpMediaTypeNotSupportedException`
+| (default)
+| `{0}` the media type that is not supported, `{1}` list of supported media types
+
+| `HttpMediaTypeNotSupportedException`
+| (default) + ".parseError"
+|
+
+| `HttpMessageNotReadableException`
+| (default)
+|
+
+| `HttpMessageNotWritableException`
+| (default)
+|
+
+| `HttpRequestMethodNotSupportedException`
+| (default)
+| `{0}` the current HTTP method, `{1}` the list of supported HTTP methods
+
+| `MethodArgumentNotValidException`
+| (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`.
+
+| `MissingRequestHeaderException`
+| (default)
+| `{0}` the header name
+
+| `MissingServletRequestParameterException`
+| (default)
+| `{0}` the request parameter name
+
+| `MissingMatrixVariableException`
+| (default)
+| `{0}` the matrix variable name
+
+| `MissingPathVariableException`
+| (default)
+| `{0}` the path variable name
+
+| `MissingRequestCookieException`
+| (default)
+| `{0}` the cookie name
+
+| `MissingServletRequestPartException`
+| (default)
+| `{0}` the part name
+
+| `NoHandlerFoundException`
+| (default)
+|
+
+| `TypeMismatchException`
+| (default)
+| `{0}` property name, `{1}` property value
+
+| `UnsatisfiedServletRequestParameterException`
+| (default)
+| `{0}` the list of parameter conditions
+
+|===
+
+By default, the message code for the "title" field is "problemDetail.title." + the fully
+qualified exception class name.
+
+
+
+[[mvc-ann-rest-exceptions-client]]
+=== Client Handling
+[.small]#<<web-reactive.adoc#webflux-ann-rest-exceptions-client, WebFlux>>#
+
+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`.
+


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

-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/#mvc[Spring MVC Security]
-* {doc-spring-security}/html5/#test-mockmvc[Spring MVC Test Support]
-* {doc-spring-security}/html5/#csrf[CSRF protection]
-* {doc-spring-security}/html5/#headers[Security Response Headers]
+* {doc-spring-security}/servlet/integrations/mvc.html[Spring MVC Security]
+* {doc-spring-security}/servlet/test/mockmvc/setup.html[Spring MVC Test Support]
+* {doc-spring-security}/features/exploits/csrf.html#csrf-protection[CSRF protection]
+* {doc-spring-security}/features/exploits/headers.html[Security Response Headers]

 https://hdiv.org/[HDIV] is another web security framework that integrates with Spring MVC.

@@ -5336,7 +5600,6 @@ the following example shows:
 		public void addInterceptors(InterceptorRegistry registry) {
 			registry.addInterceptor(new LocaleChangeInterceptor());
 			registry.addInterceptor(new ThemeChangeInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**");
-			registry.addInterceptor(new SecurityInterceptor()).addPathPatterns("/secure/*");
 		}
 	}
 ----
@@ -5350,7 +5613,6 @@ the following example shows:
 		override fun addInterceptors(registry: InterceptorRegistry) {
 			registry.addInterceptor(LocaleChangeInterceptor())
 			registry.addInterceptor(ThemeChangeInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**")
-			registry.addInterceptor(SecurityInterceptor()).addPathPatterns("/secure/*")
 		}
 	}
 ----
@@ -5366,13 +5628,19 @@ The following example shows how to achieve the same configuration in XML:
 			<mvc:exclude-mapping path="/admin/**"/>
 			<bean class="org.springframework.web.servlet.theme.ThemeChangeInterceptor"/>
 		</mvc:interceptor>
-		<mvc:interceptor>
-			<mvc:mapping path="/secure/*"/>
-			<bean class="org.example.SecurityInterceptor"/>
-		</mvc:interceptor>
 	</mvc:interceptors>
 ----

+NOTE: Mapped interceptors are not ideally suited as a security layer due to the potential
+for a mismatch with annotated controller path matching, which can also match trailing
+slashes and path extensions transparently, along with other path matching options. Many
+of these options have been deprecated but the potential for a mismatch remains.
+Generally, we recommend using Spring Security which includes a dedicated
+https://docs.spring.io/spring-security/reference/servlet/integrations/mvc.html#mvc-requestmatcher[MvcRequestMatcher]
+to align with Spring MVC path matching and also has a security firewall that blocks many
+unwanted characters in URL paths.
+
+


 [[mvc-config-content-negotiation]]
@@ -5839,12 +6107,18 @@ Note that, when using both `EncodedResourceResolver` (for example, for serving g
 brotli-encoded resources) and `VersionResourceResolver`, you must register them in this order.
 That ensures 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.
@@ -5965,9 +6239,7 @@ The following example shows how to customize path matching in Java configuration

 		@Override
 		public void configurePathMatch(PathMatchConfigurer configurer) {
-			configurer
-				.setPatternParser(new PathPatternParser())
-				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController.class));
+			configurer.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController.class));
 		}

 		private PathPatternParser patternParser() {
@@ -5983,9 +6255,7 @@ The following example shows how to customize path matching in Java configuration
 	class WebConfig : WebMvcConfigurer {

 		override fun configurePathMatch(configurer: PathMatchConfigurer) {
-			configurer
-				.setPatternParser(patternParser)
-				.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
+			configurer.addPathPrefix("/api", HandlerTypePredicate.forAnnotation(RestController::class.java))
 		}

 		fun patternParser(): PathPatternParser {
@@ -5994,13 +6264,12 @@ The following example shows how to customize path matching in Java configuration
 	}
 ----

-The following example shows how to achieve the same configuration in XML:
+The following example shows how to customize path matching in XML configuration:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<mvc:annotation-driven>
 		<mvc:path-matching
-			trailing-slash="false"
 			path-helper="pathHelper"
 			path-matcher="pathMatcher"/>
 	</mvc:annotation-driven>
@@ -6097,5 +6366,5 @@ For more details, see the
 https://github.com/spring-projects/spring-framework/wiki/HTTP-2-support[HTTP/2 wiki page].

 The Servlet API does expose one construct related to HTTP/2. You can use the
-`javax.servlet.http.PushBuilder` to proactively push resources to clients, and it
+`jakarta.servlet.http.PushBuilder` to proactively push resources to clients, and it
 is supported as a <<mvc-ann-arguments, method argument>> to `@RequestMapping` methods.
@@ -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
@@ -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...
 	});
 ----
@@ -1810,7 +1811,7 @@ its own implementation of `WebSocketMessageBrokerConfigurer` that is marked with
 === Authorization

 Spring Security provides
-https://docs.spring.io/spring-security/reference/servlet/integrations/websocket.html#websocket-authorization[WebSocket sub-protocol authorization]
+{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]
@@ -1986,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
@@ -2029,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:
@@ -2423,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