Release v6.0.2

Additional documentation notes on Java/Kotlin parameter name retention
See gh-29563
2026-06-08 17:33:33 +00:00 · 2022-11-24 13:35:34 +00:00 · 2022-11-24 14:08:53 +01:00 · 2022-11-24 12:40:25 +00:00 · 2022-11-24 12:01:51 +01:00 · 2022-11-24 12:01:03 +01:00
4116 changed files with 131012 additions and 92581 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,36 +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/graalvm/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
@@ -41,7 +47,6 @@ spring-*/src/main/java/META-INF/MANIFEST.MF
 out
 test-output
 atlassian-ide-plugin.xml
-.gradletasknamecache

 # VS Code
-.vscode/
+.vscode/
@@ -10,10 +10,11 @@ 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 <apoutsma@vmware.com>
-Arjen Poutsma <apoutsma@vmware.com> <apoutsma@pivotal.io>
-Arjen Poutsma <apoutsma@vmware.com> <apoutsma@gopivotal.com>
-Arjen Poutsma <apoutsma@vmware.com> <poutsma@mac.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>
@@ -1,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=8.0.333-librca
+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,7 +14,7 @@ For access to artifacts or a distribution zip, see the [Spring Framework Artifac

 ## Documentation

-The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/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
@@ -1,297 +1,39 @@
 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.6.10' 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.7"
-			mavenBom "io.netty:netty-bom:4.1.79.Final"
-			mavenBom "io.projectreactor:reactor-bom:2020.0.21"
-			mavenBom "io.r2dbc:r2dbc-bom:Arabba-SR13"
-			mavenBom "io.rsocket:rsocket-bom:1.1.2"
-			mavenBom "org.eclipse.jetty:jetty-bom:9.4.48.v20220622"
-			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/milestone"
+			content {
+				// Netty 5 optional support
+				includeGroup 'io.projectreactor.netty'
+			}
 		}
-		dependencies {
-			dependencySet(group: 'org.apache.logging.log4j', version: '2.18.0') {
-				entry 'log4j-api'
-				entry 'log4j-core'
-				entry 'log4j-jul'
-				entry 'log4j-slf4j-impl'
-			}
-			dependency "org.slf4j:slf4j-api:1.7.36"
-			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.4"
-			dependency "io.smallrye.reactive:mutiny:1.4.0"
-			dependency "io.projectreactor.tools:blockhound:1.0.6.RELEASE"
-
-			dependency "com.caucho:hessian:4.0.63"
-			dependency "com.fasterxml:aalto-xml:1.3.1"
-			dependency("com.fasterxml.woodstox:woodstox-core:6.2.8") {
-				exclude group: "stax", name: "stax-api"
-			}
-			dependency "com.google.code.gson:gson:2.8.9"
-			dependency "com.google.protobuf:protobuf-java-util:3.19.3"
-			dependency "com.googlecode.protobuf-java-format:protobuf-java-format:1.4"
-			dependency("com.thoughtworks.xstream:xstream:1.4.19") {
-				exclude group: "xpp3", name: "xpp3_min"
-				exclude group: "xmlpull", name: "xmlpull"
-			}
-			dependency "org.apache.johnzon:johnzon-jsonb:1.2.18"
-			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.1.214"
-			dependency "com.github.ben-manes.caffeine:caffeine:2.9.3"
-			dependency "com.github.librepdf:openpdf:1.3.29"
-			dependency "com.rometools:rome:1.18.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.3.Final"
-			dependency "org.webjars:webjars-locator-core:0.48"
-			dependency "org.webjars:underscorejs:1.8.3"
-
-			dependencySet(group: 'org.apache.tomcat', version: '9.0.64') {
-				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.64') {
-				entry 'tomcat-embed-core'
-				entry 'tomcat-embed-websocket'
-			}
-			dependencySet(group: 'io.undertow', version: '2.2.18.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.12"
-			dependency 'org.apache.httpcomponents.client5:httpclient5:5.1.3'
-			dependency 'org.apache.httpcomponents.core5:httpcore5-reactive:5.1.3'
-			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.4"
-			dependency "org.hamcrest:hamcrest:2.2"
-			dependency "org.awaitility:awaitility:3.1.6"
-			dependency "org.assertj:assertj-core:3.23.0"
-			dependencySet(group: 'org.xmlunit', version: '2.9.0') {
-				entry 'xmlunit-assertj'
-				entry('xmlunit-matchers') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-			}
-			dependencySet(group: 'org.mockito', version: '4.6.1') {
-				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.63.0") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.seleniumhq.selenium:htmlunit-driver:2.63.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-jdk18on:1.71"
-
-			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.10"
-			dependency "org.javamoney:moneta:1.3"
-
-			dependency "com.sun.activation:javax.activation:1.2.0"
-			dependency "com.sun.mail:javax.mail:1.6.2"
-			dependencySet(group: 'com.sun.xml.bind', version: '2.3.0.1') {
-				entry 'jaxb-core'
-				entry 'jaxb-impl'
-				entry 'jaxb-xjc'
-			}
-
-			dependency "javax.activation:javax.activation-api:1.2.0"
-			dependency "javax.annotation:javax.annotation-api:1.3.2"
-			dependency "javax.cache:cache-api:1.1.0"
-			dependency "javax.ejb:javax.ejb-api:3.2"
-			dependency "javax.el:javax.el-api:3.0.1-b04"
-			dependency "javax.enterprise.concurrent:javax.enterprise.concurrent-api:1.0"
-			dependency "javax.faces:javax.faces-api:2.2"
-			dependency "javax.inject:javax.inject:1"
-			dependency "javax.inject:javax.inject-tck:1"
-			dependency "javax.interceptor:javax.interceptor-api:1.2.2"
-			dependency "javax.jms:javax.jms-api:2.0.1"
-			dependency "javax.json:javax.json-api:1.1.4"
-			dependency "javax.json.bind:javax.json.bind-api:1.0"
-			dependency "javax.mail:javax.mail-api:1.6.2"
-			dependency "javax.money:money-api:1.0.3"
-			dependency "javax.resource:javax.resource-api:1.7.1"
-			dependency "javax.servlet:javax.servlet-api:4.0.1"
-			dependency "javax.servlet.jsp:javax.servlet.jsp-api:2.3.2-b02"
-			dependency "javax.servlet.jsp.jstl:javax.servlet.jsp.jstl-api:1.2.1"
-			dependency "javax.transaction:javax.transaction-api:1.3"
-			dependency "javax.validation:validation-api:2.0.1.Final"
-			dependency "javax.websocket:javax.websocket-api:1.1"
-			dependency "javax.xml.bind:jaxb-api:2.3.1"
-			dependency "javax.xml.ws:jaxws-api:2.3.1"
-
-			dependency "org.eclipse.persistence:javax.persistence:2.2.0"
-
-			// Substitute for "javax.management:jmxremote_optional:1.0.1_04" which
-			// is not available on Maven Central
-			dependency "org.glassfish.external:opendmk_jmxremote_optional_jar:1.0-b01-ea"
-			dependency "org.glassfish:javax.el:3.0.1-b08"
-			dependency "org.glassfish.main:javax.jws:4.0-b33"
-			dependency "org.glassfish.tyrus:tyrus-container-servlet:1.13.1"
+		maven { url "https://repo.spring.io/libs-spring-framework-build" }
+		if (version.contains('-')) {
+			maven { url "https://repo.spring.io/milestone" }
 		}
-		generatedPomCustomization {
-			enabled = false
-		}
-		resolutionStrategy {
-			cacheChangingModulesFor 0, "seconds"
-		}
-		repositories {
-			mavenCentral()
-			maven { url "https://repo.spring.io/libs-spring-framework-build" }
+		if (version.endsWith('-SNAPSHOT')) {
+			maven { url "https://repo.spring.io/snapshot" }
 		}
 	}
 	configurations.all {
@@ -308,27 +50,17 @@ configure([rootProject] + javaProjects) { project ->
 	apply plugin: "java"
 	apply plugin: "java-test-fixtures"
 	apply plugin: "checkstyle"
-	apply plugin: 'org.springframework.build.compile'
+	apply plugin: 'org.springframework.build.conventions'
 	apply from: "${rootDir}/gradle/toolchains.gradle"
 	apply from: "${rootDir}/gradle/ide.gradle"

-	pluginManager.withPlugin("kotlin") {
-		apply plugin: "org.jetbrains.dokka"
-		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 +69,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 = "10.3.1"
+		toolVersion = "10.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")
@@ -366,30 +113,29 @@ configure([rootProject] + javaProjects) { project ->
 	}

 	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/",
 			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.10/",
-			// TODO Uncomment once httpclient5 API docs are again online.
-			// "https://hc.apache.org/httpcomponents-client-5.1.x/current/httpclient5/apidocs/",
+			"https://hc.apache.org/httpcomponents-client-5.2.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
-			// 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
@@ -406,16 +152,11 @@ configure(moduleProjects) { project ->
 configure(rootProject) {
 	description = "Spring Framework"

-	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/**"
-		source.exclude "spring-core/graalvm/build/**" // only available on `main`
-		source.exclude "spring-core-test/build/**" // only available on `main`
 		allowlistFile = project.file("src/nohttp/allowlist.lines")
 		def rootPath = file(rootDir).toPath()
 		def projectDirs = allprojects.collect { it.projectDir } + "${rootDir}/buildSrc"
@@ -429,13 +170,8 @@ configure(rootProject) {
 		}
 	}

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

 ## Build Conventions

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

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

 ## Build Plugins

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

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

 case "$1" in
-	java8)
-		 echo "https://github.com/bell-sw/Liberica/releases/download/8u333+2/bellsoft-jdk8u333+2-linux-amd64.tar.gz"
-	;;
-	java11)
-		 echo "https://github.com/bell-sw/Liberica/releases/download/11.0.15.1+2/bellsoft-jdk11.0.15.1+2-linux-amd64.tar.gz"
-	;;
 	java17)
-		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.3.1+2/bellsoft-jdk17.0.3.1+2-linux-amd64.tar.gz"
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.5+8/bellsoft-jdk17.0.5+8-linux-amd64.tar.gz"
 	;;
 	java18)
-		echo "https://github.com/bell-sw/Liberica/releases/download/18.0.1.1+2/bellsoft-jdk18.0.1.1+2-linux-amd64.tar.gz"
+		echo "https://github.com/bell-sw/Liberica/releases/download/18.0.2.1%2B1/bellsoft-jdk18.0.2.1+1-linux-amd64.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"
@@ -20,7 +20,7 @@ curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/c

 mkdir -p /opt/openjdk
 pushd /opt/openjdk > /dev/null
-for jdk in java8 java11 java17
+for jdk in java17 java18 java19
 do
  JDK_URL=$( /get-jdk-url.sh $jdk )
  mkdir $jdk
@@ -3,8 +3,8 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "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"
@@ -81,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
@@ -101,6 +94,13 @@ resources:
  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
@@ -125,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-jdk17-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: jdk17-build
+    context: jdk19-build
 - name: slack-alert
  type: slack-notification
  icon: slack
@@ -218,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: jdk17-build
+- name: jdk18-build
  serial: true
  public: true
  plan:
@@ -273,25 +245,53 @@ jobs:
    - get: git-repo
    - get: every-morning
      trigger: true
-    - put: repo-status-jdk17-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-jdk17-build
+          - put: repo-status-jdk18-build
            params: { state: "failure", commit: "git-repo" }
          - put: slack-alert
            params:
              <<: *slack-fail-params
-    - put: repo-status-jdk17-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
@@ -471,7 +471,7 @@ jobs:

 groups:
 - name: "builds"
-  jobs: ["build", "jdk11-build", "jdk17-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,6 +1,5 @@
 #!/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/' )
@@ -4,7 +4,7 @@ image_resource:
  type: registry-image
  source:
    repository: concourse/oci-build-task
-    tag: 0.9.1
+    tag: 0.10.0
    registry_mirror:
      host: ((registry-mirror-host))
      username: ((registry-mirror-username))
@@ -28,4 +28,5 @@ run:
      cat > /root/.docker/config.json <<EOF
      { "auths": { "https://index.docker.io/v1/": { "auth": "$DOCKER_HUB_AUTH" }}}
      EOF
-      build
+      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,17 +1,42 @@
+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
 }

 dependencies {
-	asciidoctorExt("io.spring.asciidoctor:spring-asciidoctor-extensions-block-switch:0.5.0")
+	api(project(":spring-context"))
+	api(project(":spring-web"))
+
+	implementation(project(":spring-core-test"))
+	implementation("org.assertj:assertj-core")
+}
+
+checkstyle {
+	sourceSets = []
+}
+
+jar {
+	enabled = false
+}
+
+javadoc {
+	enabled = false
+}
+
+dependencies {
+	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 +67,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,74 +83,48 @@ 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,
-			'docs-spring-framework': docsSpringFramework,
-			'api-spring-framework': "${docsSpringFramework}/javadoc-api/org/springframework"
+			'spring-version': project.version
 	])
 }

 /**
- * 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 +134,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 +167,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 +246,14 @@ task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 }

 distZip.mustRunAfter moduleProjects.check
+
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifact docsZip
+			artifact schemaZip
+			artifact distZip
+		}
+	}
+}
@@ -1,9 +1,7 @@
 [[appendix]]
 = Appendix
-:toc: left
-:toclevels: 4
-:tabsize: 4
-:docinfo1:
+include::attributes.adoc[]
+include::page-layout.adoc[]

 This part of the reference documentation covers topics that apply to multiple modules
 within the core Spring Framework.
@@ -0,0 +1,18 @@
+:chomp:                         default headers packages
+:docs-site:                     https://docs.spring.io
+// Spring Framework
+:docs-spring-framework:         {docs-site}/spring-framework/docs/{spring-version}
+:api-spring-framework:          {docs-spring-framework}/javadoc-api/org/springframework
+:docs-java:                     {docdir}/../../main/java/org/springframework/docs
+:docs-kotlin:                   {docdir}/../../main/kotlin/org/springframework/docs
+:docs-resources:                {docdir}/../../main/resources
+:spring-framework-main-code:    https://github.com/spring-projects/spring-framework/tree/main
+// Spring portfolio Links
+:docs-spring-boot:              {docs-site}/spring-boot/docs/current/reference
+:docs-spring-gemfire:           {docs-site}/spring-gemfire/docs/current/reference
+:docs-spring-security:          {docs-site}/spring-security/reference
+// Third-party Links
+:docs-graalvm:                  https://www.graalvm.org/22.3/reference-manual
+:gh-rsocket:                    https://github.com/rsocket
+:gh-rsocket-extensions:         {gh-rsocket}/rsocket/blob/master/Extensions
+:gh-rsocket-java:               {gh-rsocket}/rsocket-java
@@ -1,9 +1,7 @@
 [[spring-core]]
 = Core Technologies
-:toc: left
-:toclevels: 4
-:tabsize: 4
-:docinfo1:
+include::attributes.adoc[]
+include::page-layout.adoc[]

 This part of the reference documentation covers all the technologies that are
 absolutely integral to the Spring Framework.
@@ -19,6 +17,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 +38,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]
@@ -1755,5 +1755,5 @@ support for new custom advice types be added without changing the core framework
 The only constraint on a custom `Advice` type is that it must implement the
 `org.aopalliance.aop.Advice` marker interface.

-See the {api-spring-framework}/aop/framework/adapter/package-frame.html[`org.springframework.aop.framework.adapter`]
+See the {api-spring-framework}/aop/framework/adapter/package-summary.html[`org.springframework.aop.framework.adapter`]
 javadoc for further information.
@@ -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.


@@ -1991,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
@@ -3502,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"]
@@ -3601,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,307 @@
+[[core.aot]]
+= Ahead of Time Optimizations
+
+This chapter covers Spring's Ahead of Time (AOT) optimizations.
+
+For AOT support specific to integration tests, see <<testing.adoc#testcontext-aot, Ahead of Time Support for Tests>>.
+
+[[core.aot.introduction]]
+== Introduction to Ahead of Time Optimizations
+
+Spring's support for AOT optimizations is meant to inspect an `ApplicationContext` at build time and apply decisions and discovery logic that usually happens at runtime.
+Doing so allows building an application startup arrangement that is more straightforward and focused on a fixed set of features based mainly on the classpath and the `Environment`.
+
+Applying such optimizations early implies the following restrictions:
+
+* The classpath is fixed and fully defined at build time.
+* The beans defined in your application cannot change at runtime, meaning:
+** `@Profile`, in particular profile-specific configuration needs to be chosen at build time.
+** Environment properties that impact the presence of a bean (`@Conditional`) are only considered at build time.
+
+When these restrictions are in place, it becomes possible to perform ahead-of-time processing at build time and generate additional assets.
+A Spring AOT processed application typically generates:
+
+* Java source code
+* Bytecode (usually for dynamic proxies)
+* {api-spring-framework}/aot/hint/RuntimeHints.html[`RuntimeHints`] for the use of reflection, resource loading, serialization, and JDK proxies.
+
+NOTE: At the moment, AOT is focused on allowing Spring applications to be deployed as native images using GraalVM.
+We intend to support more JVM-based use cases in future generations.
+
+[[core.aot.basics]]
+== AOT engine overview
+
+The entry point of the AOT engine for processing an `ApplicationContext` arrangement is `ApplicationContextAotGenerator`. It takes care of the following steps, based on a `GenericApplicationContext` that represents the application to optimize and a {api-spring-framework}/aot/generate/GenerationContext.html[`GenerationContext`]:
+
+* Refresh an `ApplicationContext` for AOT processing. Contrary to a traditional refresh, this version only creates bean definitions, not bean instances.
+* Invoke the available `BeanFactoryInitializationAotProcessor` implementations and apply their contributions against the `GenerationContext`.
+For instance, a core implementation iterates over all candidate bean definitions and generates the necessary code to restore the state of the `BeanFactory`.
+
+Once this process completes, the `GenerationContext` will have been updated with the generated code, resources, and classes that are necessary for the application to run.
+The `RuntimeHints` instance can also be used to generate the relevant GraalVM native image configuration files.
+
+`ApplicationContextAotGenerator#processAheadOfTime` returns the class name of the `ApplicationContextInitializer` entry point that allows the context to be started with AOT optimizations.
+
+Those steps are covered in greater detail in the sections below.
+
+[[core.aot.refresh]]
+== Refresh for AOT Processing
+
+Refresh for AOT processing is supported on all `GenericApplicationContext` implementations.
+An application context is created with any number of entry points, usually in the form of `@Configuration`-annotated classes.
+
+Let's look at a basic example:
+
+include::code:AotProcessingSample[tag=myapplication]
+
+Starting this application with the regular runtime involves a number of steps including classpath scanning, configuration class parsing, bean instantiation, and lifecycle callback handling.
+Refresh for AOT processing only applies a subset of what happens with a <<beans-introduction,regular `refresh`>>.
+AOT processing can be triggered as follows:
+
+include::code:AotProcessingSample[tag=aotcontext]
+
+In this mode, <<beans-factory-extension-factory-postprocessors,`BeanFactoryPostProcessor` implementations>> are invoked as usual.
+This includes configuration class parsing, import selectors, classpath scanning, etc.
+Such steps make sure that the `BeanRegistry` contains the relevant bean definitions for the application.
+If bean definitions are guarded by conditions (such as `@Profile`), these are discarded at this stage.
+
+Because this mode does not actually create bean instances, `BeanPostProcessor` implementations are not invoked, except for specific variants that are relevant for AOT processing.
+These are:
+
+* `MergedBeanDefinitionPostProcessor` implementations post-process bean definitions to extract additional settings, such as `init` and `destroy` methods.
+* `SmartInstantiationAwareBeanPostProcessor` implementations determine a more precise bean type if necessary.
+This makes sure to create any proxy that will be required at runtime.
+
+One this part completes, the `BeanFactory` contains the bean definitions that are necessary for the application to run. It does not trigger bean instantiation but allows the AOT engine to inspect the beans that will be created at runtime.
+
+[[core.aot.bean-factory-initialization-contributions]]
+== Bean Factory Initialization AOT Contributions
+
+Components that want to participate in this step can implement the {api-spring-framework}/beans/factory/aot/BeanFactoryInitializationAotProcessor.html[`BeanFactoryInitializationAotProcessor`] interface.
+Each implementation can return an AOT contribution, based on the state of the bean factory.
+
+An AOT contribution is a component that contributes generated code that reproduces a particular behavior.
+It can also contribute `RuntimeHints` to indicate the need for reflection, resource loading, serialization, or JDK proxies.
+
+A `BeanFactoryInitializationAotProcessor` implementation can be registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.
+
+A `BeanFactoryInitializationAotProcessor` can also be implemented directly by a bean.
+In this mode, the bean provides an AOT contribution equivalent to the feature it provides with a regular runtime.
+Consequently, such a bean is automatically excluded from the AOT-optimized context.
+
+[NOTE]
+====
+If a bean implements the `BeanFactoryInitializationAotProcessor` interface, the bean and **all** of its dependencies will be initialized during AOT processing.
+We generally recommend that this interface is only implemented by infrastructure beans such as `BeanFactoryPostProcessor` which have limited dependencies and are already initialized early in the bean factory lifecycle.
+If such a bean is registered using an `@Bean` factory method, ensure the method is `static` so that its enclosing `@Configuration` class does not have to be initialized.
+====
+
+
+[[core.aot.bean-registration-contributions]]
+=== Bean Registration AOT Contributions
+
+A core `BeanFactoryInitializationAotProcessor` implementation is responsible for collecting the necessary contributions for each candidate `BeanDefinition`.
+It does so using a dedicated `BeanRegistrationAotProcessor`.
+
+This interface is used as follows:
+
+* Implemented by a `BeanPostProcessor` bean, to replace its runtime behavior.
+For instance <<beans-factory-extension-bpp-examples-aabpp,`AutowiredAnnotationBeanPostProcessor`>> implements this interface to generate code that injects members annotated with `@Autowired`.
+* Implemented by a type registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.
+Typically used when the bean definition needs to be tuned for specific features of the core framework.
+
+[NOTE]
+====
+If a bean implements the `BeanRegistrationAotProcessor` interface, the bean and **all** of its dependencies will be initialized during AOT processing.
+We generally recommend that this interface is only implemented by infrastructure beans such as `BeanFactoryPostProcessor` which have limited dependencies and are already initialized early in the bean factory lifecycle.
+If such a bean is registered using an `@Bean` factory method, ensure the method is `static` so that its enclosing `@Configuration` class does not have to be initialized.
+====
+
+If no `BeanRegistrationAotProcessor` handles a particular registered bean, a default implementation processes it.
+This is the default behavior, since tuning the generated code for a bean definition should be restricted to corner cases.
+
+Taking our previous example, let's assume that `DataSourceConfiguration` is as follows:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	@Configuration(proxyBeanMethods = false)
+	public class DataSourceConfiguration {
+
+		@Bean
+		public SimpleDataSource dataSource() {
+			return new SimpleDataSource();
+		}
+
+	}
+----
+
+Since there isn't any particular condition on this class, `dataSourceConfiguration` and `dataSource` are identified as candidates.
+The AOT engine will convert the configuration class above to code similar to the following:
+
+[source,java,indent=0,role="primary"]
+.Java
+----
+	/**
+	 * Bean definitions for {@link DataSourceConfiguration}
+	 */
+	public class DataSourceConfiguration__BeanDefinitions {
+		/**
+		 * Get the bean definition for 'dataSourceConfiguration'
+		 */
+		public static BeanDefinition getDataSourceConfigurationBeanDefinition() {
+			Class<?> beanType = DataSourceConfiguration.class;
+			RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
+			beanDefinition.setInstanceSupplier(DataSourceConfiguration::new);
+			return beanDefinition;
+		}
+
+		/**
+		 * Get the bean instance supplier for 'dataSource'.
+		 */
+		private static BeanInstanceSupplier<SimpleDataSource> getDataSourceInstanceSupplier() {
+			return BeanInstanceSupplier.<SimpleDataSource>forFactoryMethod(DataSourceConfiguration.class, "dataSource")
+					.withGenerator((registeredBean) -> registeredBean.getBeanFactory().getBean(DataSourceConfiguration.class).dataSource());
+		}
+
+		/**
+		 * Get the bean definition for 'dataSource'
+		 */
+		public static BeanDefinition getDataSourceBeanDefinition() {
+			Class<?> beanType = SimpleDataSource.class;
+			RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
+			beanDefinition.setInstanceSupplier(getDataSourceInstanceSupplier());
+			return beanDefinition;
+		}
+	}
+----
+
+NOTE: The exact code generated may differ depending on the exact nature of your bean definitions.
+
+The generated code above creates bean definitions equivalent to the `@Configuration` class, but in a direct way and without the use of reflection if at all possible.
+There is a bean definition for `dataSourceConfiguration` and one for `dataSourceBean`.
+When a `datasource` instance is required, a `BeanInstanceSupplier` is called.
+This supplier invokes the `dataSource()` method on the `dataSourceConfiguration` bean.
+
+
+[[core.aot.hints]]
+== Runtime Hints
+
+Running an application as a native image requires additional information compared to a regular JVM runtime.
+For instance, GraalVM needs to know ahead of time if a component uses reflection.
+Similarly, classpath resources are not shipped in a native image unless specified explicitly.
+Consequently, if the application needs to load a resource, it must be referenced from the corresponding GraalVM native image configuration file.
+
+The {api-spring-framework}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxies at runtime.
+The following example makes sure that `config/app.properties` can be loaded from the classpath at runtime within a native image:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	runtimeHints.resources().registerPattern("config/app.properties");
+----
+
+A number of contracts are handled automatically during AOT processing.
+For instance, the return type of a `@Controller` method is inspected, and relevant reflection hints are added if Spring detects that the type should be serialized (typically to JSON).
+
+For cases that the core container cannot infer, you can register such hints programmatically.
+A number of convenient annotations are also provided for common use cases.
+
+
+[[core.aot.hints.import-runtime-hints]]
+=== `@ImportRuntimeHints`
+
+`RuntimeHintsRegistrar` implementations allow you to get a callback to the `RuntimeHints` instance managed by the AOT engine.
+Implementations of this interface can be registered using `@ImportRuntimeHints` on any Spring bean or `@Bean` factory method.
+`RuntimeHintsRegistrar` implementations are detected and invoked at build time.
+
+include::code:SpellCheckService[]
+
+If at all possible, `@ImportRuntimeHints` should be used as close as possible to the component that requires the hints.
+This way, if the component is not contributed to the `BeanFactory`, the hints won't be contributed either.
+
+It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the `RuntimeHintsRegistrar` interface.
+
+
+[[core.aot.hints.reflective]]
+=== `@Reflective`
+
+{api-spring-framework}/aot/hint/annotation/Reflective.html[`@Reflective`] provides an idiomatic way to flag the need for reflection on an annotated element.
+For instance, `@EventListener` is meta-annotated with `@Reflective` since the underlying implementation invokes the annotated method using reflection.
+
+By default, only Spring beans are considered and an invocation hint is registered for the annotated element.
+This can be tuned by specifying a custom `ReflectiveProcessor` implementation via the
+`@Reflective` annotation.
+
+Library authors can reuse this annotation for their own purposes.
+If components other than Spring beans need to be processed, a `BeanFactoryInitializationAotProcessor` can detect the relevant types and use `ReflectiveRuntimeHintsRegistrar` to process them.
+
+
+[[core.aot.hints.register-reflection-for-binding]]
+=== `@RegisterReflectionForBinding`
+
+{api-spring-framework}/aot/hint/annotation/RegisterReflectionForBinding.html[`@RegisterReflectionForBinding`] is a specialization of `@Reflective` that registers the need for serializing arbitrary types.
+A typical use case is the use of DTOs that the container cannot infer, such as using a web client within a method body.
+
+`@RegisterReflectionForBinding` can be applied to any Spring bean at the class level, but it can also be applied directly to a method, field, or constructor to better indicate where the hints are actually required.
+The following example registers `Account` for serialization.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	@Component
+	public class OrderService {
+
+		@RegisterReflectionForBinding(Account.class)
+		public void process(Order order) {
+			// ...
+		}
+
+	}
+----
+
+[[core.aot.hints.testing]]
+=== Testing Runtime Hints
+
+Spring Core also ships `RuntimeHintsPredicates`, a utility for checking that existing hints match a particular use case.
+This can be used in your own tests to validate that a `RuntimeHintsRegistrar` contains the expected results.
+We can write a test for our `SpellCheckService` and ensure that we will be able to load a dictionary at runtime:
+
+include::code:SpellCheckServiceTests[tag=hintspredicates]
+
+With `RuntimeHintsPredicates`, we can check for reflection, resource, serialization, or proxy generation hints.
+This approach works well for unit tests but implies that the runtime behavior of a component is well known.
+
+You can learn more about the global runtime behavior of an application by running its test suite (or the app itself) with the {docs-graalvm}/native-image/metadata/AutomaticMetadataCollection/[GraalVM tracing agent].
+This agent will record all relevant calls requiring GraalVM hints at runtime and write them out as JSON configuration files.
+
+For more targeted discovery and testing, Spring Framework ships a dedicated module with core AOT testing utilities, `"org.springframework:spring-core-test"`.
+This module contains the RuntimeHints Agent, a Java agent that records all method invocations that are related to runtime hints and helps you to assert that a given `RuntimeHints` instance covers all recorded invocations.
+Let's consider a piece of infrastructure for which we'd like to test the hints we're contributing during the AOT processing phase.
+
+include::code:SampleReflection[]
+
+We can then write a unit test (no native compilation required) that checks our contributed hints:
+
+include::code:SampleReflectionRuntimeHintsTests[]
+
+If you forgot to contribute a hint, the test will fail and provide some details about the invocation:
+
+[source,txt,indent=0,subs="verbatim,quotes"]
+----
+org.springframework.docs.core.aot.hints.testing.SampleReflection performReflection
+INFO: Spring version:6.0.0-SNAPSHOT
+
+Missing <"ReflectionHints"> for invocation <java.lang.Class#forName>
+with arguments ["org.springframework.core.SpringVersion",
+    false,
+    jdk.internal.loader.ClassLoaders$AppClassLoader@251a69d7].
+Stacktrace:
+<"org.springframework.util.ClassUtils#forName, Line 284
+io.spring.runtimehintstesting.SampleReflection#performReflection, Line 19
+io.spring.runtimehintstesting.SampleReflectionRuntimeHintsTests#lambda$shouldRegisterReflectionHints$0, Line 25
+----
+
+There are various ways to configure this Java agent in your build, so please refer to the documentation of your build tool and test execution plugin.
+The agent itself can be configured to instrument specific packages (by default, only `org.springframework` is instrumented).
+You'll find more details in the {spring-framework-main-code}/buildSrc/README.md[Spring Framework `buildSrc` README] file.
@@ -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.
@@ -107,16 +107,14 @@ configuration metadata is actually written. These days, many developers choose

 For information about using other forms of metadata with the Spring container, see:

-* <<beans-annotation-config,Annotation-based configuration>>: Spring 2.5 introduced
-  support for annotation-based configuration metadata.
-* <<beans-java, Java-based configuration>>: Starting with Spring 3.0, many features
-  provided by the Spring JavaConfig project became part of the core Spring Framework.
-  Thus, you can define beans external to your application classes by using Java rather
-  than XML files. To use these new features, see the
-  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Configuration.html[`@Configuration`],
-  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Bean.html[`@Bean`],
-  https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Import.html[`@Import`],
-  and https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/DependsOn.html[`@DependsOn`] annotations.
+* <<beans-annotation-config,Annotation-based configuration>>: define beans using
+  annotation-based configuration metadata.
+* <<beans-java, Java-based configuration>>: define beans external to your application
+  classes by using Java rather than XML files. To use these features, see the
+  {api-spring-framework}/context/annotation/Configuration.html[`@Configuration`],
+  {api-spring-framework}/context/annotation/Bean.html[`@Bean`],
+  {api-spring-framework}/context/annotation/Import.html[`@Import`],
+  and {api-spring-framework}/context/annotation/DependsOn.html[`@DependsOn`] annotations.

 Spring configuration consists of at least one and typically more than one bean
 definition that the container must manage. XML-based configuration metadata configures these
@@ -124,14 +122,12 @@ beans as `<bean/>` elements inside a top-level `<beans/>` element. Java
 configuration typically uses `@Bean`-annotated methods within a `@Configuration` class.

 These bean definitions correspond to the actual objects that make up your application.
-Typically, you define service layer objects, data access objects (DAOs), presentation
-objects such as Struts `Action` instances, infrastructure objects such as Hibernate
-`SessionFactories`, JMS `Queues`, and so forth. Typically, one does not configure
-fine-grained domain objects in the container, because it is usually the responsibility
-of DAOs and business logic to create and load domain objects. However, you can use
-Spring's integration with AspectJ to configure objects that have been created outside
-the control of an IoC container. See <<aop-atconfigurable,Using AspectJ to
-dependency-inject domain objects with Spring>>.
+Typically, you define service layer objects, persistence layer objects such as
+repositories or data access objects (DAOs), presentation objects such as Web controllers,
+infrastructure objects such as a JPA `EntityManagerFactory`, JMS queues, and so forth.
+Typically, one does not configure fine-grained domain objects in the container, because
+it is usually the responsibility of repositories and business logic to create and load
+domain objects.

 The following example shows the basic structure of XML-based configuration metadata:

@@ -157,12 +153,11 @@ The following example shows the basic structure of XML-based configuration metad
 ----

 <1> The `id` attribute is a string that identifies the individual bean definition.
-
 <2> The `class` attribute defines the type of the bean and uses the fully qualified
-classname.
+class name.

-The value of the `id` attribute refers to collaborating objects. The XML for
-referring to collaborating objects is not shown in this example. See
+The value of the `id` attribute can be used to refer to collaborating objects. The XML
+for referring to collaborating objects is not shown in this example. See
 <<beans-dependencies,Dependencies>> for more information.


@@ -1168,7 +1163,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.

@@ -1900,7 +1895,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.
@@ -2838,12 +2833,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
-`DispatcherServlet` (for example, when using JSF or Struts), you need to register the
+If you use a Servlet web container, with requests processed outside of Spring's
+`DispatcherServlet` (for example, when using JSF), 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"]
 ----
@@ -3095,7 +3089,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
@@ -4601,22 +4595,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]
 ====
@@ -4663,63 +4656,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 {
-
-		@set: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`

@@ -4954,7 +4890,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.
 ====
@@ -5026,10 +4962,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`
@@ -5057,13 +5002,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
@@ -5262,6 +5200,7 @@ with specific arguments, narrowing the set of type matches so that a specific be
 chosen for each argument. In the simplest case, this can be a plain descriptive value, as
 shown in the following example:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5286,18 +5225,20 @@ shown in the following example:
 		// ...
 	}
 ----
+--

 You can also specify the `@Qualifier` annotation on individual constructor arguments or
 method parameters, as shown in the following example:

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

-		private MovieCatalog movieCatalog;
+		private final MovieCatalog movieCatalog;

-		private CustomerPreferenceDao customerPreferenceDao;
+		private final CustomerPreferenceDao customerPreferenceDao;

 		@Autowired
 		public void prepare(@Qualifier("main") MovieCatalog movieCatalog,
@@ -5328,9 +5269,11 @@ method parameters, as shown in the following example:
 		// ...
 	}
 ----
+--

 The following example shows corresponding bean definitions.

+--
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<?xml version="1.0" encoding="UTF-8"?>
@@ -5364,6 +5307,7 @@ The following example shows corresponding bean definitions.
 is qualified with the same value.
 <2> The bean with the `action` qualifier value is wired with the constructor argument that
 is qualified with the same value.
+--

 For a fallback match, the bean name is considered a default qualifier value. Thus, you
 can define the bean with an `id` of `main` instead of the nested qualifier element, leading
@@ -5441,6 +5385,7 @@ constructor or a multi-argument method.
 You can create your own custom qualifier annotations. To do so, define an annotation and
 provide the `@Qualifier` annotation within your definition, as the following example shows:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5460,10 +5405,12 @@ provide the `@Qualifier` annotation within your definition, as the following exa
 	@Qualifier
 	annotation class Genre(val value: String)
 ----
+--

 Then you can provide the custom qualifier on autowired fields and parameters, as the
 following example shows:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5502,6 +5449,7 @@ following example shows:
 		// ...
 	}
 ----
+--

 Next, you can provide the information for the candidate bean definitions. You can add
 `<qualifier/>` tags as sub-elements of the `<bean/>` tag and then specify the `type` and
@@ -5510,6 +5458,7 @@ fully-qualified class name of the annotation. Alternately, as a convenience if n
 conflicting names exists, you can use the short class name. The following example
 demonstrates both approaches:

+--
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<?xml version="1.0" encoding="UTF-8"?>
@@ -5537,6 +5486,7 @@ demonstrates both approaches:

 	</beans>
 ----
+--

 In <<beans-classpath-scanning>>, you can see an annotation-based alternative to
 providing the qualifier metadata in XML. Specifically, see <<beans-scanning-qualifiers>>.
@@ -5547,6 +5497,7 @@ several different types of dependencies. For example, you may provide an offline
 catalog that can be searched when no Internet connection is available. First, define
 the simple annotation, as the following example shows:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5554,7 +5505,6 @@ the simple annotation, as the following example shows:
 	@Retention(RetentionPolicy.RUNTIME)
 	@Qualifier
 	public @interface Offline {
-
 	}
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -5565,10 +5515,12 @@ the simple annotation, as the following example shows:
 	@Qualifier
 	annotation class Offline
 ----
+--

 Then add the annotation to the field or property to be autowired, as shown in the
 following example:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5596,9 +5548,11 @@ class MovieRecommender {
 }
 ----
 <1> This line adds the `@Offline` annotation.
+--

 Now the bean definition only needs a qualifier `type`, as shown in the following example:

+--
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<bean class="example.SimpleMovieCatalog">
@@ -5607,6 +5561,7 @@ Now the bean definition only needs a qualifier `type`, as shown in the following
 	</bean>
 ----
 <1> This element specifies the qualifier.
+--


 You can also define custom qualifier annotations that accept named attributes in
@@ -5615,6 +5570,7 @@ then specified on a field or parameter to be autowired, a bean definition must m
 all such attribute values to be considered an autowire candidate. As an example,
 consider the following annotation definition:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5636,9 +5592,11 @@ consider the following annotation definition:
 	@Qualifier
 	annotation class MovieQualifier(val genre: String, val format: Format)
 ----
+--

 In this case `Format` is an enum, defined as follows:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5653,10 +5611,12 @@ In this case `Format` is an enum, defined as follows:
 		VHS, DVD, BLURAY
 	}
 ----
+--

 The fields to be autowired are annotated with the custom qualifier and include values
 for both attributes: `genre` and `format`, as the following example shows:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5705,6 +5665,7 @@ for both attributes: `genre` and `format`, as the following example shows:
 		// ...
 	}
 ----
+--

 Finally, the bean definitions should contain matching qualifier values. This example
 also demonstrates that you can use bean meta attributes instead of the
@@ -5713,6 +5674,7 @@ precedence, but the autowiring mechanism falls back on the values provided withi
 `<meta/>` tags if no such qualifier is present, as in the last two bean definitions in
 the following example:

+--
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<?xml version="1.0" encoding="UTF-8"?>
@@ -5756,6 +5718,7 @@ the following example:

 	</beans>
 ----
+--



@@ -5879,14 +5842,15 @@ 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
 the bean name to be injected. In other words, it follows by-name semantics,
 as demonstrated in the following example:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5912,6 +5876,7 @@ class SimpleMovieLister {
 }
 ----
 <1> This line injects a `@Resource`.
+--


 If no name is explicitly specified, the default name is derived from the field name or
@@ -5919,6 +5884,7 @@ setter method. In case of a field, it takes the field name. In case of a setter
 it takes the bean property name. The following example is going to have the bean
 named `movieFinder` injected into its setter method:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5942,6 +5908,7 @@ named `movieFinder` injected into its setter method:

 	}
 ----
+--

 NOTE: The name provided with the annotation is resolved as a bean name by the
 `ApplicationContext` of which the `CommonAnnotationBeanPostProcessor` is aware.
@@ -5960,6 +5927,7 @@ Thus, in the following example, the `customerPreferenceDao` field first looks fo
 named "customerPreferenceDao" and then falls back to a primary type match for the type
 `CustomerPreferenceDao`:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -5997,6 +5965,7 @@ named "customerPreferenceDao" and then falls back to a primary type match for th
 ----
 <1> The `context` field is injected based on the known resolvable dependency type:
 `ApplicationContext`.
+--

 [[beans-value-annotations]]
 === Using `@Value`
@@ -6202,8 +6171,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
@@ -6254,8 +6223,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.
 ====


@@ -7208,16 +7178,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>
 ----
@@ -7228,12 +7198,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 {

@@ -7253,7 +7223,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 {

@@ -7277,8 +7247,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 {

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

 	class SimpleMovieLister {

@@ -7319,8 +7289,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 {

@@ -7337,8 +7307,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 {

@@ -7395,14 +7365,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 {
@@ -7420,8 +7390,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 {
@@ -7439,8 +7409,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 {
@@ -7458,8 +7428,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 {
@@ -7508,7 +7478,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
@@ -7523,31 +7493,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.
 |===
@@ -7575,7 +7541,7 @@ container. It includes the following topics:
 [[beans-java-basic-concepts]]
 === Basic Concepts: `@Bean` and `@Configuration`

-The central artifacts in Spring's new Java-configuration support are
+The central artifacts in Spring's Java configuration support are
 `@Configuration`-annotated classes and `@Bean`-annotated methods.

 The `@Bean` annotation is used to indicate that a method instantiates, configures, and
@@ -8159,12 +8125,12 @@ class AppConfig {
 By default, beans defined with Java configuration that have a public `close` or `shutdown`
 method are automatically enlisted with a destruction callback. If you have a public
 `close` or `shutdown` method and you do not wish for it to be called when the container
-shuts down, you can add `@Bean(destroyMethod="")` to your bean definition to disable the
+shuts down, you can add `@Bean(destroyMethod = "")` to your bean definition to disable the
 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`:
@@ -8172,7 +8138,7 @@ The following example shows how to prevent an automatic destruction callback for
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	@Bean(destroyMethod="")
+	@Bean(destroyMethod = "")
 	public DataSource dataSource() throws NamingException {
 		return (DataSource) jndiTemplate.lookup("MyDS");
 	}
@@ -9323,7 +9289,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.
@@ -9516,7 +9482,7 @@ now looks like the following listing:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	@Bean(destroyMethod="")
+	@Bean(destroyMethod = "")
 	public DataSource dataSource() throws Exception {
 		Context ctx = new InitialContext();
 		return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
@@ -9555,6 +9521,7 @@ annotation lets you indicate that a component is eligible for registration
 when one or more specified profiles are active. Using our preceding example, we
 can rewrite the `dataSource` configuration as follows:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -9589,7 +9556,9 @@ can rewrite the `dataSource` configuration as follows:
 		}
 	}
 ----
+--

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -9597,13 +9566,15 @@ can rewrite the `dataSource` configuration as follows:
 	@Profile("production")
 	public class JndiDataConfig {

-		@Bean(destroyMethod="")
+		@Bean(destroyMethod = "") // <1>
 		public DataSource dataSource() throws Exception {
 			Context ctx = new InitialContext();
 			return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
 		}
 	}
 ----
+<1> `@Bean(destroyMethod = "")` disables default destroy method inference.
+
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
@@ -9611,13 +9582,15 @@ can rewrite the `dataSource` configuration as follows:
 	@Profile("production")
 	class JndiDataConfig {

-		@Bean(destroyMethod = "")
+		@Bean(destroyMethod = "") // <1>
 		fun dataSource(): DataSource {
 			val ctx = InitialContext()
 			return ctx.lookup("java:comp/env/jdbc/datasource") as DataSource
 		}
 	}
 ----
+<1> `@Bean(destroyMethod = "")` disables default destroy method inference.
+--

 NOTE: As mentioned earlier, with `@Bean` methods, you typically choose to use programmatic
 JNDI lookups, by using either Spring's `JndiTemplate`/`JndiLocatorDelegate` helpers or the
@@ -9629,9 +9602,9 @@ profile expression. A profile expression allows for more complicated profile log
 expressed (for example, `production & us-east`). The following operators are supported in
 profile expressions:

-* `!`: A logical "`not`" of the profile
-* `&`: A logical "`and`" of the profiles
-* `|`: A logical "`or`" of the profiles
+* `!`: A logical `NOT` of the profile
+* `&`: A logical `AND` of the profiles
+* `|`: A logical `OR` of the profiles

 NOTE: You cannot mix the `&` and `|` operators without using parentheses. For example,
 `production & us-east | eu-central` is not a valid expression. It must be expressed as
@@ -9642,6 +9615,7 @@ of creating a custom composed annotation. The following example defines a custom
 `@Production` annotation that you can use as a drop-in replacement for
 `@Profile("production")`:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -9659,6 +9633,7 @@ of creating a custom composed annotation. The following example defines a custom
 	@Profile("production")
 	annotation class Production
 ----
+--

 TIP: If a `@Configuration` class is marked with `@Profile`, all of the `@Bean` methods and
 `@Import` annotations associated with that class are bypassed unless one or more of
@@ -9673,6 +9648,7 @@ active. For example, given `@Profile({"p1", "!p2"})`, registration will occur if
 of a configuration class (for example, for alternative variants of a particular bean), as
 the following example shows:

+--
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
@@ -9724,6 +9700,7 @@ the following example shows:
 ----
 <1> The `standaloneDataSource` method is available only in the `development` profile.
 <2> The `jndiDataSource` method is available only in the `production` profile.
+--

 [NOTE]
 ====
@@ -9894,7 +9871,7 @@ activates multiple profiles:
 Declaratively, `spring.profiles.active` may accept a comma-separated list of profile names,
 as the following example shows:

-[literal,subs="verbatim,quotes"]
+[literal,indent=0,subs="verbatim,quotes"]
 ----
 	-Dspring.profiles.active="profile1,profile2"
 ----
@@ -9982,9 +9959,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
@@ -10218,7 +10195,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:
@@ -10290,13 +10267,13 @@ handled in the JDK-standard way of resolving messages through `ResourceBundle` o
 purposes of the example, assume the contents of two of the above resource bundle files
 are as follows:

-[literal,subs="verbatim,quotes"]
+[source,properties,indent=0,subs="verbatim,quotes"]
 ----
 	# in format.properties
 	message=Alligators rock!
 ----

-[literal,subs="verbatim,quotes"]
+[source,properties,indent=0,subs="verbatim,quotes"]
 ----
 	# in exceptions.properties
 	argument.required=The {0} argument is required.
@@ -11055,7 +11032,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.
@@ -11111,15 +11088,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
@@ -11133,7 +11110,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
@@ -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
@@ -1634,7 +1634,7 @@ If you prefer XML-based configuration, you can use a
 		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		xsi:schemaLocation="
 			http://www.springframework.org/schema/beans
-			https://www.springframework.org/schema/beans/spring-beans.xsd>
+			https://www.springframework.org/schema/beans/spring-beans.xsd">

 		<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
 			<property name="registerDefaultFormatters" value="false" />
@@ -1739,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:
@@ -1774,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 {
@@ -1797,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)
@@ -1834,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
@@ -1870,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 {

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

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

@@ -1,9 +1,7 @@
 [[spring-data-tier]]
 = Data Access
-:toc: left
-:toclevels: 4
-:tabsize: 4
-:docinfo1:
+include::attributes.adoc[]
+include::page-layout.adoc[]

 This part of the reference documentation is concerned with data access and the
 interaction between the data access layer and the business or service layer.
@@ -58,7 +56,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 +129,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 +187,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 +293,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 +324,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 +347,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 +376,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 +500,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
@@ -1042,40 +1040,45 @@ including checked exceptions by specifying _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 patterns. A 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
-`"javax.servlet.ServletException"` or `"ServletException"` will match
-`javax.servlet.ServletException` and its subclasses.
+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 patterns to be specified as strings. When using
+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 patterns to be
-specified as `Class` references or strings, respectively. When an exception type is
-specified as a class reference its fully qualified name will be used as the pattern.
-Consequently, `@Transactional(rollbackFor = example.CustomException.class)` is equivalent
-to `@Transactional(rollbackForClassName = "example.CustomException")`.
+`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 the pattern is and whether to include package
+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, 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 rollback rule if the name of 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 would 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`).
+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`).
 =====
 ====

@@ -1344,8 +1347,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
@@ -1520,7 +1523,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]]
@@ -1770,7 +1773,7 @@ properties of the `@Transactional` annotation:

 TIP: See <<transaction-declarative-rollback-rules, Rollback rules>> for further details
 on rollback rule semantics, patterns, and warnings regarding possible unintentional
-matches.
+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
@@ -2474,32 +2477,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() {
@@ -2809,7 +2812,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
@@ -2875,7 +2878,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.
@@ -3167,7 +3170,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>>.
@@ -4308,7 +4311,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,
@@ -4322,7 +4325,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,
@@ -4344,7 +4347,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
@@ -6224,7 +6227,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.
@@ -7868,7 +7871,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
@@ -7878,11 +7881,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
@@ -7890,12 +7889,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
@@ -8023,11 +8017,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"]
@@ -8037,13 +8031,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
@@ -8115,12 +8109,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.)
@@ -8408,7 +8402,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.
 ****

@@ -8481,13 +8475,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:
@@ -1,11 +1,12 @@
 :noheader:
 = Spring Framework Documentation
+include::attributes.adoc[]

 [horizontal]
 <<overview.adoc#overview, Overview>> :: history, design philosophy, feedback,
 getting started.
 <<core.adoc#spring-core, Core>> :: IoC Container, Events, Resources, i18n,
-Validation, Data Binding, Type Conversion, SpEL, AOP.
+Validation, Data Binding, Type Conversion, SpEL, AOP, AOT.
 <<testing.adoc#testing, Testing>> :: Mock Objects, TestContext Framework,
 Spring MVC Test, WebTestClient.
 <<data-access.adoc#spring-data-tier, Data Access>> :: Transactions, DAO Support,
@@ -14,20 +15,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 +31,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 - 2022 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-environment-multiple]]
+[[integration.appendix.xsd-schemas-jee-jndi-lookup-environment-multiple]]
 ==== `<jee:jndi-lookup/>` (with Multiple JNDI Environment Settings)

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


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

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



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

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



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

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


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

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



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

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



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

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



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

 You can use the `cache` elements to enable support for Spring's `@CacheEvict`, `@CachePut`,
@@ -1,9 +1,7 @@
 [[languages]]
 = Language Support
-:toc: left
-:toclevels: 4
-:tabsize: 4
-:docinfo1:
+include::attributes.adoc[]
+include::page-layout.adoc[]

 include::languages/kotlin.adoc[leveloffset=+1]

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

@@ -20,6 +20,9 @@ Feel free to join the #spring channel of https://slack.kotlinlang.org/[Kotlin Sl
 or ask a question with `spring` and `kotlin` as tags on
 https://stackoverflow.com/questions/tagged/spring+kotlin[Stackoverflow] if you need support.

+
+
+
 [[kotlin-requirements]]
 == Requirements

@@ -37,6 +40,9 @@ for serializing or deserializing JSON data for Kotlin classes with Jackson, so m
 `com.fasterxml.jackson.module:jackson-module-kotlin` dependency to your project if you have such need.
 It is automatically registered when found in the classpath.

+
+
+
 [[kotlin-extensions]]
 == Extensions

@@ -44,7 +50,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,
@@ -80,6 +86,9 @@ With Kotlin and the Spring Framework extensions, you can instead write the follo
 As in Java, `users` in Kotlin is strongly typed, but Kotlin's clever type inference allows
 for shorter syntax.

+
+
+
 [[kotlin-null-safety]]
 == Null-safety

@@ -115,6 +124,9 @@ NOTE: Generic type arguments, varargs, and array elements nullability are not su
 but should be in an upcoming release. See https://github.com/Kotlin/KEEP/issues/79[this discussion]
 for up-to-date information.

+
+
+
 [[kotlin-classes-interfaces]]
 == Classes and Interfaces

@@ -124,12 +136,16 @@ with default values.

 Kotlin parameter names are recognized through a dedicated `KotlinReflectionParameterNameDiscoverer`,
 which allows finding interface method parameter names without requiring the Java 8 `-parameters`
-compiler flag to be enabled during compilation.
+compiler flag to be enabled during compilation. (For completeness, we nevertheless recommend
+running the Kotlin compiler with its `-java-parameters` flag for standard Java parameter exposure.)

 You can declare configuration classes as
 https://kotlinlang.org/docs/reference/nested-classes.html[top level or nested but not inner],
 since the later requires a reference to the outer class.

+
+
+
 [[kotlin-annotations]]
 == Annotations

@@ -156,6 +172,9 @@ https://kotlinlang.org/docs/reference/annotations.html#annotation-use-site-targe
 such as `@field:NotNull` or `@get:Size(min=5, max=15)`, as described in
 https://stackoverflow.com/a/35853200/1092077[this Stack Overflow response].

+
+
+
 [[kotlin-bean-definition-dsl]]
 == Bean Definition DSL

@@ -211,7 +230,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.
@@ -263,23 +282,27 @@ as the following example shows:
 	}
 ----

-
 NOTE: Spring Boot is based on JavaConfig and
 https://github.com/spring-projects/spring-boot/issues/8115[does not yet provide specific support for functional bean definition],
 but you can experimentally use functional bean definitions through Spring Boot's `ApplicationContextInitializer` support.
 See https://stackoverflow.com/questions/45935931/how-to-use-functional-bean-definition-kotlin-dsl-with-spring-boot-and-spring-w/46033685#46033685[this Stack Overflow answer]
 for more details and up-to-date information. See also the experimental Kofu DSL developed in https://github.com/spring-projects/spring-fu[Spring Fu incubator].

+
+
+
 [[kotlin-web]]
 == Web

+
+
 === Router 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:

@@ -314,6 +337,8 @@ when you need to register routes depending on dynamic data (for example, from a

 See https://github.com/mixitconf/mixit/[MiXiT project] for a concrete example.

+
+
 === MockMvc DSL

 A Kotlin DSL is provided via `MockMvc` Kotlin extensions in order to provide a more
@@ -339,6 +364,8 @@ mockMvc.get("/person/{name}", "Lee") {
 }
 ----

+
+
 === Kotlin Script Templates

 Spring Framework provides a
@@ -357,9 +384,7 @@ dependencies {
 }
 ----

-Configuration is usually done with `ScriptTemplateConfigurer` and `ScriptTemplateViewResolver`
-beans.
-
+Configuration is usually done with `ScriptTemplateConfigurer` and `ScriptTemplateViewResolver` beans.

 `KotlinScriptConfiguration.kt`
 [source,kotlin,indent=0]
@@ -386,10 +411,12 @@ class KotlinScriptConfiguration {
 See the https://github.com/sdeleuze/kotlin-script-templating[kotlin-script-templating] example
 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
@@ -397,6 +424,9 @@ Kotlin serialization is designed to serialize only Kotlin classes annotated with
 With Spring Messaging (RSocket), make sure that neither Jackson, GSON or JSONB are in the classpath if you want automatic configuration,
 if Jackson is needed configure `KotlinSerializationJsonMessageConverter` manually.

+
+
+
 == Coroutines

 Kotlin https://kotlinlang.org/docs/reference/coroutines-overview.html[Coroutines] are Kotlin
@@ -410,10 +440,12 @@ 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

@@ -432,6 +464,8 @@ dependencies {

 Version `1.4.0` and above are supported.

+
+
 === How Reactive translates to Coroutines?

 For return values, the translation from Reactive to Coroutines APIs is the following:
@@ -458,6 +492,8 @@ https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coro
 Read this blog post about https://spring.io/blog/2019/04/12/going-reactive-with-spring-coroutines-and-kotlin-flow[Going Reactive with Spring, Coroutines and Kotlin Flow]
 for more details, including how to run code concurrently with Coroutines.

+
+
 === Controllers

 Here is an example of a Coroutines `@RestController`.
@@ -554,9 +590,11 @@ 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]
 ----
@@ -587,6 +625,8 @@ class UserHandler(builder: WebClient.Builder) {
 }
 ----

+
+
 === Transactions

 Transactions on Coroutines are supported via the programmatic variant of the Reactive
@@ -636,6 +676,8 @@ For Kotlin `Flow`, a  `Flow<T>.transactional` extension is provided.
 ----


+
+
 [[kotlin-spring-projects-in-kotlin]]
 == Spring Projects in Kotlin

@@ -683,6 +725,8 @@ NOTE: The Kotlin code samples in Spring Framework documentation do not explicitl
 `open` on the classes and their member functions. The samples are written for projects
 using the `kotlin-allopen` plugin, since this is the most commonly used setup.

+
+
 === Using Immutable Class Instances for Persistence

 In Kotlin, it is convenient and considered to be a best practice to declare read-only properties
@@ -726,6 +770,8 @@ NOTE: As of the Kay release train, Spring Data supports Kotlin immutable class i
 does not require the `kotlin-noarg` plugin if the module uses Spring Data object mappings
 (such as MongoDB, Redis, Cassandra, and others).

+
+
 === Injecting Dependencies

 Our recommendation is to try to favor constructor injection with `val` read-only (and
@@ -761,6 +807,8 @@ as the following example shows:
 	}
 ----

+
+
 === Injecting Configuration Properties

 In Java, you can inject configuration properties by using annotations (such as pass:q[`@Value("${property}")`)].
@@ -801,6 +849,7 @@ that uses the `${...}` syntax, with configuration beans, as the following exampl
 ----


+
 === Checked Exceptions

 Java and https://kotlinlang.org/docs/reference/exceptions.html[Kotlin exception handling]
@@ -813,6 +862,8 @@ To get the original exception thrown like in Java, methods should be annotated w
 https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.jvm/-throws/index.html[`@Throws`]
 to specify explicitly the checked exceptions thrown (for example `@Throws(IOException::class)`).

+
+
 === Annotation Array Attributes

 Kotlin annotations are mostly similar to Java annotations, but array attributes (which are
@@ -857,6 +908,8 @@ use a shortcut annotation, such as `@GetMapping`, `@PostMapping`, and others.
 NOTE: If the `@RequestMapping` `method` attribute is not specified, all HTTP methods will
 be matched, not only the `GET` method.

+
+
 === Testing

 This section addresses testing with the combination of Kotlin and Spring Framework.
@@ -866,9 +919,10 @@ https://mockk.io/[Mockk] for mocking.
 NOTE: If you are using Spring Boot, see
 https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-kotlin-testing[this related documentation].

+
 ==== 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)`]
@@ -887,6 +941,7 @@ class OrderServiceIntegrationTests(val orderService: OrderService,
 ----
 ====

+
 ==== `PER_CLASS` Lifecycle

 Kotlin lets you specify meaningful test function names between backticks (```).
@@ -930,6 +985,7 @@ class IntegrationTests {
 }
 ----

+
 ==== Specification-like Tests

 You can create specification-like tests with JUnit 5 and Kotlin.
@@ -959,6 +1015,7 @@ class SpecificationLikeTests {
 }
 ----

+
 [[kotlin-webtestclient-issue]]
 ==== `WebTestClient` Type Inference Issue in Kotlin

@@ -968,17 +1025,24 @@ since it provides a workaround for the Kotlin issue with the Java API.

 See also the related https://jira.spring.io/browse/SPR-16057[SPR-16057] issue.

+
+
+
 [[kotlin-getting-started]]
 == Getting Started

 The easiest way to learn how to build a Spring application with Kotlin is to follow
 https://spring.io/guides/tutorials/spring-boot-kotlin/[the dedicated tutorial].

+
+
 === `start.spring.io`

 The easiest way to start a new Spring Framework project in Kotlin is to create a new Spring
 Boot 2 project on https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].

+
+
 === Choosing the Web Flavor

 Spring Framework now comes with two different web stacks: <<web#mvc, Spring MVC>> and
@@ -991,6 +1055,9 @@ Kotlin DSL.
 For other use cases, especially if you are using blocking technologies such as JPA, Spring
 MVC and its annotation-based programming model is the recommended choice.

+
+
+
 [[kotlin-resources]]
 == Resources

@@ -1004,6 +1071,8 @@ Kotlin and the Spring Framework:
 * https://blog.jetbrains.com/kotlin/[Kotlin blog]
 * https://kotlin.link/[Awesome Kotlin]

+
+
 === Examples

 The following Github projects offer examples that you can learn from and possibly even extend:
@@ -1016,6 +1085,8 @@ The following Github projects offer examples that you can learn from and possibl
 * https://github.com/sdeleuze/spring-kotlin-deepdive[spring-kotlin-deepdive]: A step-by-step migration guide for Boot 1.0 and Java to Boot 2.0 and Kotlin
 * https://github.com/spring-cloud/spring-cloud-gcp/tree/master/spring-cloud-gcp-kotlin-samples/spring-cloud-gcp-kotlin-app-sample[spring-cloud-gcp-kotlin-app-sample]: Spring Boot with Google Cloud Platform Integrations

+
+
 === Issues

 The following list categorizes the pending issues related to Spring and Kotlin support:
@@ -1,5 +1,6 @@
 [[overview]]
 = Spring Framework Overview
+include::attributes.adoc[]
 :toc: left
 :toclevels: 1
 :docinfo1:
@@ -7,10 +8,8 @@
 Spring makes it easy to create Java enterprise applications. It provides everything you
 need to embrace the Java language in an enterprise environment, with support for Groovy
 and Kotlin as alternative languages on the JVM, and with the flexibility to create many
-kinds of architectures depending on an application's needs. As of Spring Framework 5.1,
-Spring requires JDK 8+ (Java SE 8+) and provides out-of-the-box support for JDK 11 LTS.
-Java SE 8 update 60 is suggested as the minimum patch release for Java 8, but it is
-generally recommended to use a recent patch release.
+kinds of architectures depending on an application's needs. As of Spring Framework 6.0,
+Spring requires Java 17+.

 Spring supports a wide range of application scenarios. In a large enterprise, applications
 often exist for a long time and have to run on a JDK and application server whose upgrade
@@ -56,9 +55,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 +71,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 +128,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].
@@ -0,0 +1,4 @@
+:toc: left
+:toclevels: 4
+:tabsize: 4
+:docinfo1:
@@ -1,8 +1,7 @@
 [[rsocket]]
 = RSocket
-:gh-rsocket: https://github.com/rsocket
-:gh-rsocket-java: {gh-rsocket}/rsocket-java
-:gh-rsocket-extensions: {gh-rsocket}/rsocket/blob/master/Extensions
+include::attributes.adoc[]
+include::page-layout.adoc[]

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

@@ -53,7 +52,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.
@@ -904,3 +903,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,26 @@
+:noheader:
+= Spring Framework Documentation
+include::attributes.adoc[]
+
+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.
@@ -0,0 +1,30 @@
+[[testing]]
+= Testing
+include::attributes.adoc[]
+include::page-layout.adoc[]
+
+This chapter covers Spring's support for integration testing and best practices for unit
+testing. The Spring team advocates test-driven development (TDD). The Spring team has
+found that the correct use of inversion of control (IoC) certainly does make both unit
+and integration testing easier (in that the presence of setter methods and appropriate
+constructors on classes makes them easier to wire together in a test without having to
+set up service locator registries and similar structures).
+
+
+include::testing/testing-introduction.adoc[leveloffset=+1]
+
+include::testing/unit-testing.adoc[leveloffset=+1]
+
+include::testing/integration-testing.adoc[leveloffset=+1]
+
+include::testing/testing-support-jdbc.adoc[leveloffset=+1]
+
+include::testing/testcontext-framework.adoc[leveloffset=+1]
+
+include::testing/testing-webtestclient.adoc[leveloffset=+1]
+
+include::testing/spring-mvc-test-framework.adoc[leveloffset=+1]
+
+include::testing/spring-mvc-test-client.adoc[leveloffset=+1]
+
+include::testing/testing-appendix.adoc[leveloffset=+1]
@@ -0,0 +1,155 @@
+[[integration-testing]]
+= Integration Testing
+
+It is important to be able to perform some integration testing without requiring
+deployment to your application server or connecting to other enterprise infrastructure.
+Doing so lets you test things such as:
+
+* The correct wiring of your Spring IoC container contexts.
+* Data access using JDBC or an ORM tool. This can include such things as the correctness
+  of SQL statements, Hibernate queries, JPA entity mappings, and so forth.
+
+The Spring Framework provides first-class support for integration testing in the
+`spring-test` module. The name of the actual JAR file might include the release version
+and might also be in the long `org.springframework.test` form, depending on where you get
+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
+slower to run than unit tests but much faster than the equivalent Selenium tests or
+remote tests that rely on deployment to an application server.
+
+Unit and integration testing support is provided in the form of the annotation-driven
+<<testcontext-framework, Spring TestContext Framework>>. The TestContext framework is
+agnostic of the actual testing framework in use, which allows instrumentation of tests
+in various environments, including JUnit, TestNG, and others.
+
+The following section provides an overview of the high-level goals of Spring's
+integration support, and the rest of this chapter then focuses on dedicated topics:
+
+* <<integration-testing-support-jdbc>>
+* <<testcontext-framework>>
+* <<webtestclient>>
+* <<spring-mvc-test-framework>>
+* <<spring-mvc-test-client>>
+* <<integration-testing-annotations>>
+
+
+
+[[integration-testing-goals]]
+== Goals of Integration Testing
+
+Spring's integration testing support has the following primary goals:
+
+* To manage <<testing-ctx-management, Spring IoC container caching>> between tests.
+* To provide <<testing-fixture-di, Dependency Injection of test fixture instances>>.
+* To provide <<testing-tx, transaction management>> appropriate to integration testing.
+* To supply <<testing-support-classes, Spring-specific base classes>> that assist
+  developers in writing integration tests.
+
+The next few sections describe each goal and provide links to implementation and
+configuration details.
+
+
+[[testing-ctx-management]]
+=== Context Management and Caching
+
+The Spring TestContext Framework provides consistent loading of Spring
+`ApplicationContext` instances and `WebApplicationContext` instances as well as caching
+of those contexts. Support for the caching of loaded contexts is important, because
+startup time can become an issue -- not because of the overhead of Spring itself, but
+because the objects instantiated by the Spring container take time to instantiate. For
+example, a project with 50 to 100 Hibernate mapping files might take 10 to 20 seconds to
+load the mapping files, and incurring that cost before running every test in every test
+fixture leads to slower overall test runs that reduce developer productivity.
+
+Test classes typically declare either an array of resource locations for XML or Groovy
+configuration metadata -- often in the classpath -- or an array of component classes that
+is used to configure the application. These locations or classes are the same as or
+similar to those specified in `web.xml` or other configuration files for production
+deployments.
+
+By default, once loaded, the configured `ApplicationContext` is reused for each test.
+Thus, the setup cost is incurred only once per test suite, and subsequent test execution
+is much faster. In this context, the term "`test suite`" means all tests run in the same
+JVM -- for example, all tests run from an Ant, Maven, or Gradle build for a given project
+or module. In the unlikely case that a test corrupts the application context and requires
+reloading (for example, by modifying a bean definition or the state of an application
+object) the TestContext framework can be configured to reload the configuration and
+rebuild the application context before executing the next test.
+
+See <<testcontext-ctx-management>> and <<testcontext-ctx-management-caching>> with the
+TestContext framework.
+
+
+[[testing-fixture-di]]
+=== Dependency Injection of Test Fixtures
+
+When the TestContext framework loads your application context, it can optionally
+configure instances of your test classes by using Dependency Injection. This provides a
+convenient mechanism for setting up test fixtures by using preconfigured beans from your
+application context. A strong benefit here is that you can reuse application contexts
+across various testing scenarios (for example, for configuring Spring-managed object
+graphs, transactional proxies, `DataSource` instances, and others), thus avoiding the
+need to duplicate complex test fixture setup for individual test cases.
+
+As an example, consider a scenario where we have a class (`HibernateTitleRepository`)
+that implements data access logic for a `Title` domain entity. We want to write
+integration tests that test the following areas:
+
+* The Spring configuration: Basically, is everything related to the configuration of the
+  `HibernateTitleRepository` bean correct and present?
+* The Hibernate mapping file configuration: Is everything mapped correctly and are the
+  correct lazy-loading settings in place?
+* The logic of the `HibernateTitleRepository`: Does the configured instance of this class
+  perform as anticipated?
+
+See dependency injection of test fixtures with the
+<<testcontext-fixture-di, TestContext framework>>.
+
+
+[[testing-tx]]
+=== Transaction Management
+
+One common issue in tests that access a real database is their effect on the state of the
+persistence store. Even when you use a development database, changes to the state may
+affect future tests. Also, many operations -- such as inserting or modifying persistent
+data -- cannot be performed (or verified) outside of a transaction.
+
+The TestContext framework addresses this issue. By default, the framework creates and
+rolls back a transaction for each test. You can write code that can assume the existence
+of a transaction. If you call transactionally proxied objects in your tests, they behave
+correctly, according to their configured transactional semantics. In addition, if a test
+method deletes the contents of selected tables while running within the transaction
+managed for the test, the transaction rolls back by default, and the database returns to
+its state prior to execution of the test. Transactional support is provided to a test by
+using a `PlatformTransactionManager` bean defined in the test's application context.
+
+If you want a transaction to commit (unusual, but occasionally useful when you want a
+particular test to populate or modify the database), you can tell the TestContext
+framework to cause the transaction to commit instead of roll back by using the
+<<integration-testing-annotations, `@Commit`>> annotation.
+
+See transaction management with the <<testcontext-tx, TestContext framework>>.
+
+
+[[testing-support-classes]]
+=== Support Classes for Integration Testing
+
+The Spring TestContext Framework provides several `abstract` support classes that
+simplify the writing of integration tests. These base test classes provide well-defined
+hooks into the testing framework as well as convenient instance variables and methods,
+which let you access:
+
+* The `ApplicationContext`, for performing explicit bean lookups or testing the state of
+  the context as a whole.
+* A `JdbcTemplate`, for executing SQL statements to query the database. You can use such
+  queries to confirm database state both before and after execution of database-related
+  application code, and Spring ensures that such queries run in the scope of the same
+  transaction as the application code. When used in conjunction with an ORM tool, be sure
+  to avoid <<testcontext-tx-false-positives, false positives>>.
+
+In addition, you may want to create your own custom, application-wide superclass with
+instance variables and methods specific to your project.
+
+See support classes for the <<testcontext-support-classes, TestContext framework>>.
@@ -0,0 +1,136 @@
+[[spring-mvc-test-client]]
+= Testing Client Applications
+
+You can use client-side tests to test code that internally uses the `RestTemplate`. The
+idea is to declare expected requests and to provide "`stub`" responses so that you can
+focus on testing the code in isolation (that is, without running a server). The following
+example shows how to do so:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	RestTemplate restTemplate = new RestTemplate();
+
+	MockRestServiceServer mockServer = MockRestServiceServer.bindTo(restTemplate).build();
+	mockServer.expect(requestTo("/greeting")).andRespond(withSuccess());
+
+	// Test code that uses the above RestTemplate ...
+
+	mockServer.verify();
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	val restTemplate = RestTemplate()
+
+	val mockServer = MockRestServiceServer.bindTo(restTemplate).build()
+	mockServer.expect(requestTo("/greeting")).andRespond(withSuccess())
+
+	// Test code that uses the above RestTemplate ...
+
+	mockServer.verify()
+----
+
+In the preceding example, `MockRestServiceServer` (the central class for client-side REST
+tests) configures the `RestTemplate` with a custom `ClientHttpRequestFactory` that
+asserts actual requests against expectations and returns "`stub`" responses. In this
+case, we expect a request to `/greeting` and want to return a 200 response with
+`text/plain` content. We can define additional expected requests and stub responses as
+needed. When we define expected requests and stub responses, the `RestTemplate` can be
+used in client-side code as usual. At the end of testing, `mockServer.verify()` can be
+used to verify that all expectations have been satisfied.
+
+By default, requests are expected in the order in which expectations were declared. You
+can set the `ignoreExpectOrder` option when building the server, in which case all
+expectations are checked (in order) to find a match for a given request. That means
+requests are allowed to come in any order. The following example uses `ignoreExpectOrder`:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	server = MockRestServiceServer.bindTo(restTemplate).ignoreExpectOrder(true).build();
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	server = MockRestServiceServer.bindTo(restTemplate).ignoreExpectOrder(true).build()
+----
+
+Even with unordered requests by default, each request is allowed to run once only.
+The `expect` method provides an overloaded variant that accepts an `ExpectedCount`
+argument that specifies a count range (for example, `once`, `manyTimes`, `max`, `min`,
+`between`, and so on). The following example uses `times`:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	RestTemplate restTemplate = new RestTemplate();
+
+	MockRestServiceServer mockServer = MockRestServiceServer.bindTo(restTemplate).build();
+	mockServer.expect(times(2), requestTo("/something")).andRespond(withSuccess());
+	mockServer.expect(times(3), requestTo("/somewhere")).andRespond(withSuccess());
+
+	// ...
+
+	mockServer.verify();
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	val restTemplate = RestTemplate()
+
+	val mockServer = MockRestServiceServer.bindTo(restTemplate).build()
+	mockServer.expect(times(2), requestTo("/something")).andRespond(withSuccess())
+	mockServer.expect(times(3), requestTo("/somewhere")).andRespond(withSuccess())
+
+	// ...
+
+	mockServer.verify()
+----
+
+Note that, when `ignoreExpectOrder` is not set (the default), and, therefore, requests
+are expected in order of declaration, then that order applies only to the first of any
+expected request. For example if "/something" is expected two times followed by
+"/somewhere" three times, then there should be a request to "/something" before there is
+a request to "/somewhere", but, aside from that subsequent "/something" and "/somewhere",
+requests can come at any time.
+
+As an alternative to all of the above, the client-side test support also provides a
+`ClientHttpRequestFactory` implementation that you can configure into a `RestTemplate` to
+bind it to a `MockMvc` instance. That allows processing requests using actual server-side
+logic but without running a server. The following example shows how to do so:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
+	this.restTemplate = new RestTemplate(new MockMvcClientHttpRequestFactory(mockMvc));
+
+	// Test code that uses the above RestTemplate ...
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	val mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build()
+	restTemplate = RestTemplate(MockMvcClientHttpRequestFactory(mockMvc))
+
+	// Test code that uses the above RestTemplate ...
+----
+
+[[spring-mvc-test-client-static-imports]]
+== Static Imports
+
+As with server-side tests, the fluent API for client-side tests requires a few static
+imports. Those are easy to find by searching for `MockRest*`. Eclipse users should add
+`MockRestRequestMatchers.{asterisk}` and `MockRestResponseCreators.{asterisk}` as
+"`favorite static members`" in the Eclipse preferences under Java -> Editor -> Content
+Assist -> Favorites. That allows using content assist after typing the first character of
+the static method name. Other IDEs (such IntelliJ) may not require any additional
+configuration. Check for the support for code completion on static members.
+
+[[spring-mvc-test-client-resources]]
+== Further Examples of Client-side REST Tests
+
+Spring MVC Test's own tests include
+{spring-framework-main-code}/spring-test/src/test/java/org/springframework/test/web/client/samples[example
+tests] of client-side REST tests.
@@ -0,0 +1,6 @@
+[[testing.appendix]]
+= Appendix
+
+include::testing-annotations.adoc[leveloffset=+1]
+
+include::testing-resources.adoc[leveloffset=+1]
@@ -0,0 +1,8 @@
+[[testing-introduction]]
+= Introduction to Spring Testing
+
+Testing is an integral part of enterprise software development. This chapter focuses on
+the value added by the IoC principle to <<unit-testing, unit testing>> and on the benefits
+of the Spring Framework's support for <<integration-testing, integration testing>>. (A
+thorough treatment of testing in the enterprise is beyond the scope of this reference
+manual.)
@@ -0,0 +1,32 @@
+[[testing-resources]]
+= Further Resources
+See the following resources for more information about testing:
+
+* https://www.junit.org/[JUnit]: "A programmer-friendly testing framework for Java and the JVM".
+  Used by the Spring Framework in its test suite and supported in the
+  <<testcontext-framework, Spring TestContext Framework>>.
+* https://testng.org/[TestNG]: A testing framework inspired by JUnit with added support
+  for test groups, data-driven testing, distributed testing, and other features. Supported
+  in the <<testcontext-framework, Spring TestContext Framework>>
+* https://assertj.github.io/doc/[AssertJ]: "Fluent assertions for Java",
+  including support for Java 8 lambdas, streams, and numerous other features.
+* https://en.wikipedia.org/wiki/Mock_Object[Mock Objects]: Article in Wikipedia.
+* http://www.mockobjects.com/[MockObjects.com]: Web site dedicated to mock objects, a
+  technique for improving the design of code within test-driven development.
+* https://mockito.github.io[Mockito]: Java mock library based on the
+  http://xunitpatterns.com/Test%20Spy.html[Test Spy] pattern. Used by the Spring Framework
+  in its test suite.
+* https://easymock.org/[EasyMock]: Java library "that provides Mock Objects for
+  interfaces (and objects through the class extension) by generating them on the fly using
+  Java's proxy mechanism."
+* https://jmock.org/[JMock]: Library that supports test-driven development of Java code
+  with mock objects.
+* https://www.dbunit.org/[DbUnit]: JUnit extension (also usable with Ant and Maven) that
+  is targeted at database-driven projects and, among other things, puts your database into
+  a known state between test runs.
+* https://www.testcontainers.org/[Testcontainers]: Java library that supports JUnit
+  tests, providing lightweight, throwaway instances of common databases, Selenium web
+  browsers, or anything else that can run in a Docker container.
+* https://sourceforge.net/projects/grinder/[The Grinder]: Java load testing framework.
+* https://github.com/Ninja-Squad/springmockk[SpringMockK]: Support for Spring Boot
+  integration tests written in Kotlin using https://mockk.io/[MockK] instead of Mockito.
@@ -0,0 +1,35 @@
+[[integration-testing-support-jdbc]]
+= JDBC Testing Support
+
+[[integration-testing-support-jdbc-test-utils]]
+== JdbcTestUtils
+
+The `org.springframework.test.jdbc` package contains `JdbcTestUtils`, which is a
+collection of JDBC-related utility functions intended to simplify standard database
+testing scenarios. Specifically, `JdbcTestUtils` provides the following static utility
+methods.
+
+* `countRowsInTable(..)`: Counts the number of rows in the given table.
+* `countRowsInTableWhere(..)`: Counts the number of rows in the given table by using the
+  provided `WHERE` clause.
+* `deleteFromTables(..)`: Deletes all rows from the specified tables.
+* `deleteFromTableWhere(..)`: Deletes rows from the given table by using the provided
+  `WHERE` clause.
+* `dropTables(..)`: Drops the specified tables.
+
+[TIP]
+====
+<<testcontext-support-classes-junit4, `AbstractTransactionalJUnit4SpringContextTests`>>
+and <<testcontext-support-classes-testng, `AbstractTransactionalTestNGSpringContextTests`>>
+provide convenience methods that delegate to the aforementioned methods in
+`JdbcTestUtils`.
+====
+
+[[integration-testing-support-jdbc-embedded-database]]
+== Embedded Databases
+
+The `spring-jdbc` module provides support for configuring and launching an embedded
+database, which you can use in integration tests that interact with a database.
+For details, see <<data-access.adoc#jdbc-embedded-database-support, Embedded Database
+Support>> and <<data-access.adoc#jdbc-embedded-database-dao-testing, Testing Data Access
+Logic with an Embedded Database>>.
@@ -0,0 +1,168 @@
+[[unit-testing]]
+= Unit Testing
+
+Dependency injection should make your code less dependent on the container than it would
+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
+and componentization of your codebase facilitate easier unit testing. For example,
+you can test service layer objects by stubbing or mocking DAO or repository interfaces,
+without needing to access persistent data while running unit tests.
+
+True unit tests typically run extremely quickly, as there is no runtime infrastructure to
+set up. Emphasizing true unit tests as part of your development methodology can boost
+your productivity. You may not need this section of the testing chapter to help you write
+effective unit tests for your IoC-based applications. For certain unit testing scenarios,
+however, the Spring Framework provides mock objects and testing support classes, which
+are described in this chapter.
+
+
+
+[[mock-objects]]
+== Mock Objects
+
+Spring includes a number of packages dedicated to mocking:
+
+* <<mock-objects-env>>
+* <<mock-objects-jndi>>
+* <<mock-objects-servlet>>
+* <<mock-objects-web-reactive>>
+
+
+[[mock-objects-env]]
+=== Environment
+
+The `org.springframework.mock.env` package contains mock implementations of the
+`Environment` and `PropertySource` abstractions (see
+<<core.adoc#beans-definition-profiles, Bean Definition Profiles>>
+and <<core.adoc#beans-property-source-abstraction, `PropertySource` Abstraction>>).
+`MockEnvironment` and `MockPropertySource` are useful for developing
+out-of-container tests for code that depends on environment-specific properties.
+
+
+[[mock-objects-jndi]]
+=== JNDI
+
+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 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
+officially deprecated as of Spring Framework 5.2 in favor of complete solutions from third
+parties such as https://github.com/h-thurow/Simple-JNDI[Simple-JNDI].
+
+
+[[mock-objects-servlet]]
+=== Servlet API
+
+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 https://easymock.org/[EasyMock])
+or alternative Servlet API mock objects (such as http://www.mockobjects.com[MockObjects]).
+
+TIP: Since Spring Framework 6.0, the mock objects in `org.springframework.mock.web` are
+based on the Servlet 6.0 API.
+
+The Spring MVC Test framework builds on the mock Servlet API objects to provide an
+integration testing framework for Spring MVC. See <<spring-mvc-test-framework>>.
+
+
+[[mock-objects-web-reactive]]
+=== Spring Web Reactive
+
+The `org.springframework.mock.http.server.reactive` package contains mock implementations
+of `ServerHttpRequest` and `ServerHttpResponse` for use in WebFlux applications. The
+`org.springframework.mock.web.server` package contains a mock `ServerWebExchange` that
+depends on those mock request and response objects.
+
+Both `MockServerHttpRequest` and `MockServerHttpResponse` extend from the same abstract
+base classes as server-specific implementations and share behavior with them. For
+example, a mock request is immutable once created, but you can use the `mutate()` method
+from `ServerHttpRequest` to create a modified instance.
+
+In order for the mock response to properly implement the write contract and return a
+write completion handle (that is, `Mono<Void>`), it by default uses a `Flux` with
+`cache().then()`, which buffers the data and makes it available for assertions in tests.
+Applications can set a custom write function (for example, to test an infinite stream).
+
+The <<webtestclient>> builds on the mock request and response to provide support for
+testing WebFlux applications without an HTTP server. The client can also be used for
+end-to-end tests with a running server.
+
+
+
+[[unit-testing-support-classes]]
+== Unit Testing Support Classes
+
+Spring includes a number of classes that can help with unit testing. They fall into two
+categories:
+
+* <<unit-testing-utilities>>
+* <<unit-testing-spring-mvc>>
+
+
+[[unit-testing-utilities]]
+=== General Testing Utilities
+
+The `org.springframework.test.util` package contains several general purpose utilities
+for use in unit and integration testing.
+
+{api-spring-framework}/test/util/AopTestUtils.html[`AopTestUtils`] is a collection of
+AOP-related utility methods. You can use these methods to obtain a reference to the
+underlying target object hidden behind one or more Spring proxies. For example, if you
+have configured a bean as a dynamic mock by using a library such as EasyMock or Mockito,
+and the mock is wrapped in a Spring proxy, you may need direct access to the underlying
+mock to configure expectations on it and perform verifications. For Spring's core AOP
+utilities, see {api-spring-framework}/aop/support/AopUtils.html[`AopUtils`] and
+{api-spring-framework}/aop/framework/AopProxyUtils.html[`AopProxyUtils`].
+
+{api-spring-framework}/test/util/ReflectionTestUtils.html[`ReflectionTestUtils`] is a
+collection of reflection-based utility methods. You can use these methods in testing
+scenarios where you need to change the value of a constant, set a non-`public` field,
+invoke a non-`public` setter method, or invoke a non-`public` configuration or lifecycle
+callback method when testing application code for use cases such as the following:
+
+* ORM frameworks (such as JPA and Hibernate) that condone `private` or `protected` field
+  access as opposed to `public` setter methods for properties in a domain entity.
+* Spring's support for annotations (such as `@Autowired`, `@Inject`, and `@Resource`),
+  that provide dependency injection for `private` or `protected` fields, setter methods,
+  and configuration methods.
+* Use of annotations such as `@PostConstruct` and `@PreDestroy` for lifecycle callback
+  methods.
+
+{api-spring-framework}/test/util/TestSocketUtils.html[`TestSocketUtils`] is a simple
+utility for finding available TCP ports on `localhost` for use in integration testing
+scenarios.
+
+[NOTE]
+====
+`TestSocketUtils` can be used in integration tests which start an external server on an
+available random port. However, these utilities make no guarantee about the subsequent
+availability of a given port and are therefore unreliable. Instead of using
+`TestSocketUtils` to find an available local port for a server, it is recommended that
+you rely on a server's ability to start on a random ephemeral port that it selects or is
+assigned by the operating system. To interact with that server, you should query the
+server for the port it is currently using.
+====
+
+
+[[unit-testing-spring-mvc]]
+=== Spring MVC Testing Utilities
+
+The `org.springframework.test.web` package contains
+{api-spring-framework}/test/web/ModelAndViewAssert.html[`ModelAndViewAssert`], which you
+can use in combination with JUnit, TestNG, or any other testing framework for unit tests
+that deal with Spring MVC `ModelAndView` objects.
+
+.Unit testing Spring MVC Controllers
+TIP: To unit test your Spring MVC `Controller` classes as POJOs, use `ModelAndViewAssert`
+combined with `MockHttpServletRequest`, `MockHttpSession`, and so on from Spring's
+<<mock-objects-servlet, Servlet API mocks>>. For thorough integration testing of your
+Spring MVC and REST `Controller` classes in conjunction with your `WebApplicationContext`
+configuration for Spring MVC, use the
+<<spring-mvc-test-framework, Spring MVC Test Framework>> instead.
@@ -1,14 +1,12 @@
 [[spring-web-reactive]]
 = Web on Reactive Stack
-:toc: left
-:toclevels: 4
-:tabsize: 4
-:docinfo1:
+include::attributes.adoc[]
+include::page-layout.adoc[]

 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
-the <<webflux.adoc#webflux, Spring WebFlux>> framework,
+servers, such as Netty, Undertow, and Servlet containers. Individual chapters cover
+the <<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,
 see <<web.adoc#spring-web, Web on Servlet Stack>>.
@@ -17,13 +15,25 @@ 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]



 [[webflux-test]]
 == Testing
-[.small]#<<web.adoc#testing, Same in Spring MVC>>#
+[.small]#<<web.adoc#webmvc.test, Same in Spring MVC>>#

 The `spring-test` module provides mock implementations of `ServerHttpRequest`,
 `ServerHttpResponse`, and `ServerWebExchange`.
@@ -49,21 +59,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
@@ -1,9 +1,7 @@
 [[spring-web]]
 = Web on Servlet Stack
-:toc: left
-:toclevels: 4
-:tabsize: 4
-:docinfo1:
+include::attributes.adoc[]
+include::page-layout.adoc[]

 This part of the documentation covers support for Servlet-stack web applications built on the
 Servlet API and deployed to Servlet containers. Individual chapters include <<mvc, Spring MVC>>,
@@ -9,7 +9,7 @@ particular architecture, technology, or methodology (although it certainly recom
 some over others). This freedom to pick and choose the architecture, technology, or
 methodology that is most relevant to a developer and their development team is
 arguably most evident in the web area, where Spring provides its own web frameworks
-(<<mvc, Spring MVC>> and <<webflux.adoc#webflux, Spring WebFlux>>) while, at the same time,
+(<<mvc, Spring MVC>> and <<web-reactive.adoc#webflux, Spring WebFlux>>) while, at the same time,
 supporting integration with a number of popular third-party web frameworks.


@@ -23,21 +23,21 @@ first take a look at common Spring configuration that is not specific to any one
 framework. (This section is equally applicable to Spring's own web framework variants.)

 One of the concepts (for want of a better word) espoused by Spring's lightweight
-application model is that of a layered architecture. Remember that in a "`classic`"
+application model is that of a layered architecture. Remember that in a "classic"
 layered architecture, the web layer is but one of many layers. It serves as one of the
 entry points into a server-side application, and it delegates to service objects
 (facades) that are defined in a service layer to satisfy business-specific (and
 presentation-technology agnostic) use cases. In Spring, these service objects, any other
-business-specific objects, data-access objects, and others exist in a distinct "`business
-context`", which contains no web or presentation layer objects (presentation objects,
-such as Spring MVC controllers, are typically configured in a distinct "`presentation
-context`"). This section details how you can configure a Spring container (a
+business-specific objects, data-access objects, and others exist in a distinct "business
+context", which contains no web or presentation layer objects (presentation objects,
+such as Spring MVC controllers, are typically configured in a distinct "presentation
+context"). This section details how you can configure a Spring container (a
 `WebApplicationContext`) that contains all of the 'business beans' in your application.

 Moving on to specifics, all you 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
-`contextConfigLocation`<context-param/> section (in the same file) that defines which
+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.

 Consider the following `<listener/>` configuration:
@@ -67,7 +67,7 @@ object based on the bean definitions and stores it in the `ServletContext` of th
 application.

 All Java web frameworks are built on top of the Servlet API, so you can use the
-following code snippet to get access to this "`business context`" `ApplicationContext`
+following code snippet to get access to this "business context" `ApplicationContext`
 created by the `ContextLoaderListener`.

 The following example shows how to get the `WebApplicationContext`:
@@ -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
@@ -119,7 +119,7 @@ The key element in Spring's JSF integration is the JSF `ELResolver` mechanism.

 `SpringBeanFacesELResolver` is a JSF compliant `ELResolver` implementation,
 integrating with the standard Unified EL as used by JSF and JSP. It delegates to
-Spring's "`business context`" `WebApplicationContext` first and then to the
+Spring's "business context" `WebApplicationContext` first and then to the
 default resolver of the underlying JSF implementation.

 Configuration-wise, you can define `SpringBeanFacesELResolver` in your JSF
@@ -157,27 +157,26 @@ The following example shows how to use `FacesContextUtils`:


 [[struts]]
-== Apache Struts 2.x
+== Apache Struts

 Invented by Craig McClanahan, https://struts.apache.org[Struts] is an open-source project
-hosted by the Apache Software Foundation. At the time, it greatly simplified the
+hosted by the Apache Software Foundation. Struts 1.x greatly simplified the
 JSP/Servlet programming paradigm and won over many developers who were using proprietary
-frameworks. It simplified the programming model, it was open source (and thus free as in
-beer), and it had a large community, which let the project grow and become popular among
-Java web developers.
+frameworks. It simplified the programming model; it was open source; and it had a large
+community, which let the project grow and become popular among Java web developers.

-As a successor to the original Struts 1.x, check out Struts 2.x and the Struts-provided
-https://struts.apache.org/release/2.3.x/docs/spring-plugin.html[Spring Plugin] for the
-built-in Spring integration.
+As a successor to the original Struts 1.x, check out Struts 2.x or more recent versions
+as well as the Struts-provided
+https://struts.apache.org/plugins/spring/[Spring Plugin] for built-in Spring integration.




 [[tapestry]]
-== Apache Tapestry 5.x
+== Apache Tapestry

-https://tapestry.apache.org/[Tapestry] is a ""Component oriented framework for creating
-dynamic, robust, highly scalable web applications in Java.""
+https://tapestry.apache.org/[Tapestry] is a "Component oriented framework for creating
+dynamic, robust, highly scalable web applications in Java."

 While Spring has its own <<mvc, powerful web layer>>, there are a number of unique
 advantages to building an enterprise Java application by using a combination of Tapestry
@@ -195,6 +194,6 @@ https://tapestry.apache.org/integrating-with-spring-framework.html[integration m
 The following links go to further resources about the various web frameworks described in
 this chapter.

-* The https://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html[JSF] homepage
+* The https://www.oracle.com/java/technologies/javaserverfaces.html[JSF] homepage
 * The https://struts.apache.org/[Struts] homepage
 * The https://tapestry.apache.org/[Tapestry] homepage
@@ -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,6 +1,5 @@
 [[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
@@ -310,7 +309,7 @@ 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 {doc-spring-security}/servlet/integrations/cors.html[built-in support] for
+Security has {docs-spring-security}/servlet/integrations/cors.html[built-in support] for
 CORS.

 To configure the filter, you can declare a `CorsWebFilter` bean and pass a
@@ -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
@@ -97,7 +98,7 @@ as the following example shows:
 		}
 	}
 ----
-<1> Create router using Coroutines router DSL, a Reactive alternative is also available via `router { }`.
+<1> Create router using Coroutines router DSL; a Reactive alternative is also available via `router { }`.

 One way to run a `RouterFunction` is to turn it into an `HttpHandler` and install it
 through one of the built-in <<web-reactive.adoc#webflux-httphandler, server adapters>>:
@@ -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
@@ -256,7 +300,6 @@ ServerResponse.created(location).build()
 Depending on the codec used, it is possible to pass hint parameters to customize how the
 body is serialized or deserialized. For example, to specify a https://www.baeldung.com/jackson-json-view-annotation[Jackson JSON view]:

-====
 [source,java,role="primary"]
 .Java
 ----
@@ -267,7 +310,6 @@ ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView.clas
 ----
 ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView::class.java).body(...)
 ----
-====


 [[webflux-fn-handler-classes]]
@@ -481,8 +523,8 @@ header:
 ----
 	val route = coRouter {
 		GET("/hello-world", accept(TEXT_PLAIN)) {
-            ServerResponse.ok().bodyValueAndAwait("Hello World")
-        }
+			ServerResponse.ok().bodyValueAndAwait("Hello World")
+		}
 	}
 ----

@@ -598,7 +640,7 @@ RouterFunction<ServerResponse> route = route()
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	val route = coRouter {
+	val route = coRouter { // <1>
 		"/person".nest {
 			GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
 			GET(accept(APPLICATION_JSON), handler::listPeople)
@@ -606,6 +648,7 @@ RouterFunction<ServerResponse> route = route()
 		}
 	}
 ----
+<1> Create router using Coroutines router DSL; a Reactive alternative is also available via `router { }`.

 Though path-based nesting is the most common, you can nest on any kind of predicate by using
 the `nest` method on the builder.
@@ -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`.
@@ -252,7 +253,7 @@ To configure a connection timeout:
 			.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000);

 	val webClient = WebClient.builder()
-			.clientConnector(new ReactorClientHttpConnector(httpClient))
+			.clientConnector(ReactorClientHttpConnector(httpClient))
 			.build();
 ----

@@ -280,8 +281,8 @@ To configure a read or write timeout:

 	val httpClient = HttpClient.create()
 			.doOnConnected { conn -> conn
-					.addHandlerLast(new ReadTimeoutHandler(10))
-					.addHandlerLast(new WriteTimeoutHandler(10))
+					.addHandlerLast(ReadTimeoutHandler(10))
+					.addHandlerLast(WriteTimeoutHandler(10))
 			}

 	// Create WebClient...
@@ -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

@@ -357,7 +392,7 @@ The following example shows how to customize Jetty `HttpClient` settings:
 	httpClient.cookieStore = ...

 	val webClient = WebClient.builder()
-			.clientConnector(new JettyClientHttpConnector(httpClient))
+			.clientConnector(JettyClientHttpConnector(httpClient))
 			.build();
 ----

@@ -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();
 				}
 			});
 ----
@@ -752,11 +788,11 @@ multipart request. The following example shows how to create a `MultiValueMap<St
 ----
 	val builder = MultipartBodyBuilder().apply {
 		part("fieldPart", "fieldValue")
-		part("filePart1", new FileSystemResource("...logo.png"))
-		part("jsonPart", new Person("Jason"))
-		part("myPart", part) // Part from a server request	
+		part("filePart1", FileSystemResource("...logo.png"))
+		part("jsonPart", Person("Jason"))
+		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 .
 ====


@@ -1,12 +1,12 @@
 [[webflux]]
+:chapter: webflux
 = Spring WebFlux
-: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 +23,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 +87,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 +149,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 +187,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 +205,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 +305,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 +344,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 +484,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 +619,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]]
@@ -1167,19 +1167,17 @@ as a `HandlerResult`, along with some additional context, and passed to the firs
 === Exceptions
 [.small]#<<web.adoc#mvc-exceptionhandlers, Web MVC>>#

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

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

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

 See also <<webflux-ann-controller-exceptions>> in the "`Annotated Controller`" section or
 <<webflux-exception-handler>> in the WebHandler API section.
@@ -1199,7 +1197,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
@@ -1347,6 +1345,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>>#
@@ -1511,8 +1532,8 @@ register support for any other data type.
 See <<webflux-ann-typeconversion>> and <<webflux-ann-initbinder>>.

 URI variables can be named explicitly (for example, `@PathVariable("customId")`), but you can
-leave that detail out if the names are the same and you compile your code with debugging
-information or with the `-parameters` compiler flag on Java 8.
+leave that detail out if the names are the same and you compile your code with the `-parameters`
+compiler flag.

 The syntax `{*varName}` declares a URI variable that matches zero or more remaining path
 segments. For example `/resources/{*path}` matches all files under `/resources/`, and the
@@ -1541,7 +1562,7 @@ extracts the name, version, and file extension:

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

 NOTE: Spring WebFlux uses `PathPattern` and the `PathPatternParser` for URI path matching support.
@@ -1851,8 +1872,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.
@@ -1944,6 +1965,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
@@ -1975,7 +2004,7 @@ generally supported for all return values.
  value) is considered to have fully handled the response if it also has a `ServerHttpResponse`,
  a `ServerWebExchange` argument, or an `@ResponseStatus` annotation. The same is also true
  if the controller has made a positive ETag or `lastModified` timestamp check.
-  // TODO: See <<webflux-caching-etag-lastmodified>> for details.
+  See <<webflux-caching-etag-lastmodified>> for details.

  If none of the above is true, a `void` return type can also indicate "`no response body`" for
  REST controllers or default view name selection for HTML controllers.
@@ -1985,10 +2014,9 @@ generally supported for all return values.
  to be written (however, `text/event-stream` must be requested or declared in the mapping
  through the `produces` attribute).

-| Any other return value
-| If a return value is not matched to any of the above, it is, by default, treated as a view
-  name, if it is `String` or `void` (default view name selection applies), or as a model
-  attribute to be added to the model, unless it is a simple type, as determined by
+| Other return values
+| If a return value remains unresolved in any other way, it is treated as a model
+  attribute, unless it is a simple type as determined by
  {api-spring-framework}/beans/BeanUtils.html#isSimpleProperty-java.lang.Class-[BeanUtils#isSimpleProperty],
  in which case it remains unresolved.
 |===
@@ -2399,7 +2427,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:

@@ -2746,7 +2774,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
@@ -2794,29 +2822,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]]
@@ -2868,7 +2967,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
@@ -3327,7 +3426,7 @@ 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
@@ -3387,21 +3486,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.



@@ -3484,6 +3584,154 @@ 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]]
@@ -3494,12 +3742,10 @@ The https://spring.io/projects/spring-security[Spring Security] project provides
 for protecting web applications from malicious exploits. See the Spring Security
 reference documentation, including:

-* {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]
-
-include::webflux-view.adoc[leveloffset=+1]
+* {docs-spring-security}/reactive/configuration/webflux.html[WebFlux Security]
+* {docs-spring-security}/reactive/test/index.html[WebFlux Testing Support]
+* {docs-spring-security}/features/exploits/csrf.html#csrf-protection[CSRF protection]
+* {docs-spring-security}/features/exploits/headers.html[Security Response Headers]



@@ -3673,6 +3919,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]]
@@ -4161,7 +4408,7 @@ In the next example, given a request that starts with `/resources`, the relative
 used to find and serve static resources relative to `/static` on the classpath. Resources
 are served with a one-year future expiration to ensure maximum use of the browser cache
 and a reduction in HTTP requests made by the browser. The `Last-Modified` header is also
-evaluated and, if present, a `304` status code is returned. The following list shows
+evaluated and, if present, a `304` status code is returned. The following listing shows
 the example:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
@@ -4195,7 +4442,7 @@ the example:
 	}
 ----

-// TODO: See also <<webflux-caching-static-resources, HTTP caching support for static resources>>.
+See also <<webflux-caching-static-resources, HTTP caching support for static resources>>.

 The resource handler also supports a chain of
 {api-spring-framework}/web/reactive/resource/ResourceResolver.html[`ResourceResolver`] implementations and
@@ -4256,12 +4503,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.
@@ -4287,9 +4540,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));
 		}
 	}
 ----
@@ -4304,9 +4555,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.
--- a/Show More
+++ b/Show More