Release v6.0.0

Add milestone repo for optional Netty 5 support
Closes gh-29498
2026-06-08 17:33:33 +00:00 · 2022-11-16 10:07:46 +00:00 · 2022-11-16 11:03:14 +01:00 · 2022-11-16 09:58:04 +01:00 · 2022-11-16 08:16:57 +01:00 · 2022-11-15 20:10:03 +01:00
4992 changed files with 163753 additions and 104533 deletions
@@ -1,5 +1,5 @@
 <!--
-!!! For Security Vulnerabilities, please go to https://pivotal.io/security !!!
+!!! For Security Vulnerabilities, please go to https://spring.io/security-policy !!!
 -->
 **Affects:** \<Spring Framework version>

@@ -14,4 +14,4 @@ Thanks for taking the time to create an issue. Please read the following:
 Issue or Pull Request? Create only one, not both. GitHub treats them as the same.
 If unsure, start with an issue, and if you submit a pull request later, the
 issue will be closed as superseded.
-->
+-->
@@ -0,0 +1,29 @@
+name: Backport Bot
+
+on:
+  issues:
+    types: [labeled]
+  push:
+    branches:
+      - '*.x'
+permissions:
+  contents: read
+jobs:
+  build:
+    permissions:
+      contents: read
+      issues: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+      - name: Download BackportBot
+        run: wget https://github.com/spring-io/backport-bot/releases/download/latest/backport-bot-0.0.1-SNAPSHOT.jar
+      - name: Backport
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_EVENT: ${{ toJSON(github.event) }}
+        run: java -jar backport-bot-0.0.1-SNAPSHOT.jar --github.accessToken="$GITHUB_TOKEN" --github.event_name "$GITHUB_EVENT_NAME" --github.event "$GITHUB_EVENT"
@@ -1,10 +1,13 @@
 name: "Validate Gradle Wrapper"
 on: [push, pull_request]

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

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

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

 # IDEA artifacts and output dirs
@@ -40,4 +47,6 @@ spring-*/src/main/java/META-INF/MANIFEST.MF
 out
 test-output
 atlassian-ide-plugin.xml
-.gradletasknamecache
+
+# VS Code
+.vscode/
@@ -1,23 +1,34 @@
-Juergen Hoeller <jhoeller@pivotal.io> jhoeller <jhoeller@vmware.com>
-<jhoeller@pivotal.io> <jhoeller@vmware.com>
-<jhoeller@pivotal.io> <jhoeller@gopivotal.com>
-<rstoyanchev@pivotal.io> <rstoyanchev@vmware.com>
-<rstoyanchev@pivotal.io> <rstoyanchev@gopivotal.com>
-<pwebb@pivotal.io> <pwebb@vmware.com>
-<pwebb@pivotal.io> <pwebb@gopivotal.com>
-<cbeams@pivotal.io> <cbeams@vmware.com>
-<cbeams@pivotal.io> <cbeams@gopivotal.com>
-<cbeams@pivotal.io> <cbeams@gmail.com>
-<apoutsma@pivotal.io> <apoutsma@vmware.com>
-<apoutsma@pivotal.io> <apoutsma@gopivotal.com>
-<apoutsma@pivotal.io> <poutsma@mac.com>
-<ogierke@pivotal.io> <ogierke@vmware.com>
-<ogierke@pivotal.io> <ogierke@gopivotal.com>
-<dsyer@pivotal.io> <dsyer@vmware.com>
-<dsyer@pivotal.io> <dsyer@gopivotal.com>
-<dsyer@pivotal.io> <david_syer@hotmail.com>
-<aclement@pivotal.io> <aclement@vmware.com>
-<aclement@pivotal.io> <aclement@gopivotal.com>
-<aclement@pivotal.io> <andrew.clement@gmail.com>
+Juergen Hoeller <jhoeller@vmware.com>
+Juergen Hoeller <jhoeller@vmware.com> <jhoeller@pivotal.io>
+Juergen Hoeller <jhoeller@vmware.com> <jhoeller@gopivotal.com>
+Rossen Stoyanchev <rstoyanchev@vmware.com>
+Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@pivotal.io>
+Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@gopivotal.com>
+Phillip Webb <pwebb@vmware.com>
+Phillip Webb <pwebb@vmware.com> <pwebb@pivotal.io>
+Phillip Webb <pwebb@vmware.com> <pwebb@gopivotal.com>
+Chris Beams <cbeams@vmware.com>
+Chris Beams <cbeams@vmware.com> <cbeams@pivotal.io>
+Chris Beams <cbeams@vmware.com> <cbeams@gopivotal.com>
+Arjen Poutsma <poutsmaa@vmware.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@pivotal.io>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@gopivotal.com>
+Arjen Poutsma <poutsmaa@vmware.com> <poutsma@mac.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@vmware.com>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@pivotal.io>
+Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@gopivotal.com>
+Dave Syer <dsyer@vmware.com>
+Dave Syer <dsyer@vmware.com> <dsyer@pivotal.io>
+Dave Syer <dsyer@vmware.com> <dsyer@gopivotal.com>
+Dave Syer <dsyer@vmware.com> <david_syer@hotmail.com>
+Andy Clement <aclement@vmware.com>
+Andy Clement <aclement@vmware.com> <aclement@pivotal.io>
+Andy Clement <aclement@vmware.com> <aclement@gopivotal.com>
+Andy Clement <aclement@vmware.com> <andrew.clement@gmail.com>
+Sam Brannen <sbrannen@vmware.com>
+Sam Brannen <sbrannen@vmware.com> <sbrannen@pivotal.io>
+Sam Brannen <sbrannen@vmware.com> <sam@sambrannen.com>
 <dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
-Nick Williams <nicholas@nicholaswilliams.net> Nicholas Williams <nicholas@nicholaswilliams.net>
+Nick Williams <nicholas@nicholaswilliams.net>
@@ -0,0 +1,3 @@
+# Enable auto-env through the sdkman_auto_env config
+# Add key=value pairs of SDKs to use below
+java=17.0.5-librca
@@ -6,7 +6,7 @@ First off, thank you for taking the time to contribute! :+1: :tada:

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

 ### How to Contribute

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

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

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

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

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

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

 #### Issue Lifecycle

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

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

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

-1. Always check out the `master` branch and submit pull requests against it
+1. Always check out the `main` branch and submit pull requests against it
 (for target version see [settings.gradle](settings.gradle)).
 Backports to prior versions will be considered on a case-by-case basis and reflected as
 the fix version in the issue tracker.
@@ -120,15 +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/asciidoc/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/).

-Asciidoctor also supports live editing. For more details read
-[Editing AsciiDoc with Live Preview](https://asciidoctor.org/docs/editing-asciidoc-with-live-preview/).
-Note that if you choose the
-[System Monitor](https://asciidoctor.org/docs/editing-asciidoc-with-live-preview/#using-a-system-monitor)
-option, you can find a Guardfile under `src/docs/asciidoc`.
@@ -1,4 +1,4 @@
-# <img src="src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-5.3.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
+# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-5.3.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)

 This is the home of the Spring Framework: the foundation for all [Spring projects](https://spring.io/projects). Collectively the Spring Framework and the family of Spring projects are often referred to simply as "Spring". 

@@ -14,16 +14,20 @@ For access to artifacts or a distribution zip, see the [Spring Framework Artifac

 ## Documentation

-The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/) and [source](src/docs/asciidoc)), Github [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
+The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/) and [source](framework-docs/src/docs/asciidoc)), GitHub [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
 [API reference](https://docs.spring.io/spring-framework/docs/current/javadoc-api/). There are also [guides and tutorials](https://spring.io/guides) across Spring projects.

 ## Micro-Benchmarks

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

 ## Build from Source

-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source) Wiki page and the [CONTRIBUTING.md](CONTRIBUTING.md) file.
+See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source) wiki page and the [CONTRIBUTING.md](CONTRIBUTING.md) file.
+
+## Continuous Integration Builds
+
+Information regarding CI builds can be found in the [Spring Framework Concourse pipeline](ci/README.adoc) documentation.

 ## Stay in Touch

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

 ## Reporting a Vulnerability

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

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

 configure(allprojects) { project ->
-	apply plugin: "io.spring.dependency-management"
-
-	dependencyManagement {
-		imports {
-			mavenBom "com.fasterxml.jackson:jackson-bom:2.12.0"
-			mavenBom "io.netty:netty-bom:4.1.56.Final"
-			mavenBom "io.projectreactor:reactor-bom:2020.0.3"
-			mavenBom "io.r2dbc:r2dbc-bom:Arabba-SR8"
-			mavenBom "io.rsocket:rsocket-bom:1.1.0"
-			mavenBom "org.eclipse.jetty:jetty-bom:9.4.35.v20201120"
-			mavenBom "org.jetbrains.kotlin:kotlin-bom:1.4.21"
-			mavenBom "org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.4.2"
-			mavenBom "org.junit:junit-bom:5.7.0"
+	repositories {
+		mavenCentral()
+		maven {
+			url "https://repo.spring.io/milestone"
+			content {
+				// Netty 5 optional support
+				includeGroup 'io.projectreactor.netty'
+			}
 		}
-		dependencies {
-			dependencySet(group: 'org.apache.logging.log4j', version: '2.14.0') {
-				entry 'log4j-api'
-				entry 'log4j-core'
-				entry 'log4j-jul'
-				entry 'log4j-slf4j-impl'
-			}
-			dependency "org.slf4j:slf4j-api:1.7.30"
-			dependency("com.google.code.findbugs:findbugs:3.0.1") {
-				exclude group: "dom4j", name: "dom4j"
-			}
-			dependency "com.google.code.findbugs:jsr305:3.0.2"
-
-			dependencySet(group: 'org.aspectj', version: '1.9.6') {
-				entry 'aspectjrt'
-				entry 'aspectjtools'
-				entry 'aspectjweaver'
-			}
-			dependencySet(group: 'org.codehaus.groovy', version: '3.0.7') {
-				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.20"
-			dependency "io.reactivex.rxjava3:rxjava:3.0.9"
-			dependency "io.projectreactor.tools:blockhound:1.0.4.RELEASE"
-
-			dependency "com.caucho:hessian:4.0.63"
-			dependency "com.fasterxml:aalto-xml:1.2.2"
-			dependency("com.fasterxml.woodstox:woodstox-core:6.2.3") {
-				exclude group: "stax", name: "stax-api"
-			}
-			dependency "com.google.code.gson:gson:2.8.6"
-			dependency "com.google.protobuf:protobuf-java-util:3.14.0"
-			dependency "com.googlecode.protobuf-java-format:protobuf-java-format:1.4"
-			dependency("com.thoughtworks.xstream:xstream:1.4.14") {
-				exclude group: "xpp3", name: "xpp3_min"
-				exclude group: "xmlpull", name: "xmlpull"
-			}
-			dependency "org.apache.johnzon:johnzon-jsonb:1.2.8"
-			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.27"
-			dependencySet(group: 'org.jetbrains.kotlinx', version: '1.0.0') {
-				entry 'kotlinx-serialization-core'
-				entry 'kotlinx-serialization-json'
-			}
-
-			dependency "com.h2database:h2:1.4.200"
-			dependency "com.github.ben-manes.caffeine:caffeine:2.8.8"
-			dependency "com.github.librepdf:openpdf:1.3.24"
-			dependency "com.rometools:rome:1.15.0"
-			dependency "commons-io:commons-io:2.5"
-			dependency "io.vavr:vavr:0.10.3"
-			dependency "net.sf.jopt-simple:jopt-simple:5.0.4"
-			dependencySet(group: 'org.apache.activemq', version: '5.16.0') {
-				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.30"
-			dependency "org.hsqldb:hsqldb:2.5.1"
-			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.27.Final"
-			dependency "org.hibernate:hibernate-validator:6.2.0.Final"
-			dependency "org.webjars:webjars-locator-core:0.46"
-			dependency "org.webjars:underscorejs:1.8.3"
-
-			dependencySet(group: 'org.apache.tomcat', version: '9.0.41') {
-				entry 'tomcat-util'
-				entry('tomcat-websocket') {
-					exclude group: "org.apache.tomcat", name: "tomcat-websocket-api"
-					exclude group: "org.apache.tomcat", name: "tomcat-servlet-api"
-				}
-			}
-			dependencySet(group: 'org.apache.tomcat.embed', version: '9.0.41') {
-				entry 'tomcat-embed-core'
-				entry 'tomcat-embed-websocket'
-			}
-			dependencySet(group: 'io.undertow', version: '2.2.3.Final') {
-				entry 'undertow-core'
-				entry('undertow-websockets-jsr') {
-					exclude group: "org.jboss.spec.javax.websocket", name: "jboss-websocket-api_1.1_spec"
-				}
-				entry('undertow-servlet') {
-					exclude group: "org.jboss.spec.javax.servlet", name: "jboss-servlet-api_3.1_spec"
-					exclude group: "org.jboss.spec.javax.annotation", name: "jboss-annotations-api_1.2_spec"
-				}
-			}
-
-			dependencySet(group: 'com.squareup.okhttp3', version: '3.14.9') {
-				entry 'okhttp'
-				entry 'mockwebserver'
-			}
-			dependency("org.apache.httpcomponents:httpclient:4.5.13") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.apache.httpcomponents:httpasyncclient:4.1.4") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency 'org.apache.httpcomponents.client5:httpclient5:5.0.3'
-			dependency 'org.apache.httpcomponents.core5:httpcore5-reactive:5.0.3'
-			dependency "org.eclipse.jetty:jetty-reactive-httpclient:1.1.5"
-
-			dependency "org.jruby:jruby:9.2.13.0"
-			dependency "org.python:jython-standalone:2.7.1"
-			dependency "org.mozilla:rhino:1.7.11"
-
-			dependency "commons-fileupload:commons-fileupload:1.4"
-			dependency "org.synchronoss.cloud:nio-multipart-parser:1.1.0"
-
-			dependency("org.dom4j:dom4j:2.1.3") {
-				exclude group: "jaxen", name: "jaxen"
-				exclude group: "net.java.dev.msv", name: "xsdlib"
-				exclude group: "pull-parser", name: "pull-parser"
-				exclude group: "xpp3", name: "xpp3"
-			}
-			dependency("jaxen:jaxen:1.2.0") {
-				exclude group: "dom4j", name: "dom4j"
-			}
-
-			dependency("junit:junit:4.13.1") {
-				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.3.0"
-			dependency "org.hamcrest:hamcrest:2.1"
-			dependency "org.awaitility:awaitility:3.1.6"
-			dependency "org.assertj:assertj-core:3.18.1"
-			dependencySet(group: 'org.xmlunit', version: '2.8.2') {
-				entry 'xmlunit-assertj'
-				entry('xmlunit-matchers') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-			}
-			dependencySet(group: 'org.mockito', version: '3.7.0') {
-				entry('mockito-core') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-				entry 'mockito-junit-jupiter'
-			}
-			dependency "io.mockk:mockk:1.10.2"
-
-			dependency("net.sourceforge.htmlunit:htmlunit:2.46.0") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.seleniumhq.selenium:htmlunit-driver:2.46.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.4.0"
-			dependency "org.bouncycastle:bcpkix-jdk15on:1.66"
-
-			dependencySet(group: 'org.apache.tiles', version: '3.0.8') {
-				entry 'tiles-api'
-				entry('tiles-core', withoutJclOverSlf4j)
-				entry('tiles-servlet', withoutJclOverSlf4j)
-				entry('tiles-jsp', withoutJclOverSlf4j)
-				entry('tiles-el', withoutJclOverSlf4j)
-				entry('tiles-extras') {
-					exclude group: "org.springframework", name: "spring-web"
-					exclude group: "org.slf4j", name: "jcl-over-slf4j"
-				}
-			}
-			dependency("org.apache.taglibs:taglibs-standard-jstlel:1.2.5") {
-				exclude group: "org.apache.taglibs", name: "taglibs-standard-spec"
-			}
-
-			dependency "com.ibm.websphere:uow:6.0.2.17"
-			dependency "com.jamonapi:jamon:2.82"
-			dependency "joda-time:joda-time:2.10.9"
-			dependency "org.eclipse.persistence:org.eclipse.persistence.jpa:2.7.7"
-			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 {
@@ -307,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 from: "${rootDir}/gradle/custom-java-home.gradle"
+	apply plugin: 'org.springframework.build.conventions'
+	apply from: "${rootDir}/gradle/toolchains.gradle"
 	apply from: "${rootDir}/gradle/ide.gradle"

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

 	test {
@@ -336,52 +69,79 @@ configure([rootProject] + javaProjects) { project ->
 		systemProperty("java.awt.headless", "true")
 		systemProperty("testGroups", project.properties.get("testGroups"))
 		systemProperty("io.netty.leakDetection.level", "paranoid")
+		systemProperty("io.netty5.leakDetectionLevel", "paranoid")
+		systemProperty("io.netty5.leakDetection.targetRecords", "32")
+		systemProperty("io.netty5.buffer.lifecycleTracingEnabled", "true")
+		systemProperty("io.netty5.buffer.leakDetectionEnabled", "true")
+		jvmArgs(["--add-opens=java.base/java.lang=ALL-UNNAMED",
+				 "--add-opens=java.base/java.util=ALL-UNNAMED"])
 	}

 	checkstyle {
-		toolVersion = "8.39"
+		toolVersion = "10.4"
 		configDirectory.set(rootProject.file("src/checkstyle"))
 	}

+	tasks.named("checkstyleMain").configure {
+		maxHeapSize = "1g"
+	}
+
+	tasks.named("checkstyleTest").configure {
+		maxHeapSize = "1g"
+	}
+
 	dependencies {
-		testCompile("org.junit.jupiter:junit-jupiter-api")
-		testCompile("org.junit.jupiter:junit-jupiter-params")
-		testCompile("org.mockito:mockito-core")
-		testCompile("org.mockito:mockito-junit-jupiter")
-		testCompile("io.mockk:mockk")
-		testCompile("org.assertj:assertj-core")
+		dependencyManagement(enforcedPlatform(dependencies.project(path: ":framework-platform")))
+		testImplementation("org.junit.jupiter:junit-jupiter-api")
+		testImplementation("org.junit.jupiter:junit-jupiter-params")
+		testImplementation("org.junit.platform:junit-platform-suite-api")
+		testImplementation("org.mockito:mockito-core")
+		testImplementation("org.mockito:mockito-junit-jupiter")
+		testImplementation("io.mockk:mockk")
+		testImplementation("org.assertj:assertj-core")
 		// Pull in the latest JUnit 5 Launcher API to ensure proper support in IDEs.
-		testRuntime("org.junit.platform:junit-platform-launcher")
-		testRuntime("org.junit.jupiter:junit-jupiter-engine")
-		testRuntime("org.apache.logging.log4j:log4j-core")
-		testRuntime("org.apache.logging.log4j:log4j-slf4j-impl")
-		testRuntime("org.apache.logging.log4j:log4j-jul")
+		testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+		testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+		testRuntimeOnly("org.junit.platform:junit-platform-suite-engine")
+		testRuntimeOnly("org.apache.logging.log4j:log4j-core")
+		testRuntimeOnly("org.apache.logging.log4j:log4j-jul")
+		testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j-impl")
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
-		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.15")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.31")
 	}

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

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

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

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

-	publishing {
-		publications {
-			mavenJava(MavenPublication) {
-				artifact docsZip
-				artifact schemaZip
-				artifact distZip
-			}
-		}
+	tasks.named("checkstyleNohttp").configure {
+		maxHeapSize = "1g"
 	}
+
 }
@@ -5,19 +5,16 @@ 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:

-The `org.springframework.build.compile` plugin applies the Java compiler conventions to the build.
-By default, the build compiles sources with Java `1.8` source and target compatibility.
-You can test a different source compatibility version on the CLI with a project property like:
+* Configuring the Java compiler, see `JavaConventions`
+* Configuring the Kotlin compiler, see `KotlinConventions`
+* Configuring testing in the build with `TestConventions` 

-```
-./gradlew test -PjavaSourceVersion=11
-```

 ## Build Plugins

-## Optional dependencies
+### Optional dependencies

 The `org.springframework.build.optional-dependencies` plugin creates a new `optional`
 Gradle configuration - it adds the dependencies to the project's compile and runtime classpath
@@ -25,7 +22,7 @@ but doesn't affect the classpath of dependent projects.
 This plugin does not provide a `provided` configuration, as the native `compileOnly` and `testCompileOnly`
 configurations are preferred.

-## API Diff
+### API Diff

 This plugin uses the [Gradle JApiCmp](https://github.com/melix/japicmp-gradle-plugin) plugin
 to generate API Diff reports for each Spring Framework module. This plugin is applied once on the root
@@ -39,3 +36,40 @@ current working version with. You can generate the reports for all modules or a
 ```      

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

+ext {
+	def propertiesFile = new File(new File("$projectDir").parentFile, "gradle.properties")
+	propertiesFile.withInputStream {
+		def properties = new Properties()
+		properties.load(it)
+		set("kotlinVersion", properties["kotlinVersion"])
+	}
+}
+
 dependencies {
-	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.2.8"
-	implementation "com.google.guava:guava:28.2-jre" // required by japicmp-gradle-plugin
+	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
+	implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}")
+	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.3.0"
+	implementation "org.gradle:test-retry-gradle-plugin:1.4.1"
 }

 gradlePlugin {
@@ -18,13 +29,17 @@ gradlePlugin {
 			id = "org.springframework.build.api-diff"
 			implementationClass = "org.springframework.build.api.ApiDiffPlugin"
 		}
-		compileConventionsPlugin {
-			id = "org.springframework.build.compile"
-			implementationClass = "org.springframework.build.compile.CompilerConventionsPlugin"
+		conventionsPlugin {
+			id = "org.springframework.build.conventions"
+			implementationClass = "org.springframework.build.ConventionsPlugin"
 		}
 		optionalDependenciesPlugin {
 			id = "org.springframework.build.optional-dependencies"
 			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"
 		}
+		runtimeHintsAgentPlugin {
+			id = "org.springframework.build.runtimehints-agent"
+			implementationClass = "org.springframework.build.hint.RuntimeHintsAgentPlugin"
+		}
 	}
 }
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin;
+
+/**
+ * Plugin to apply conventions to projects that are part of Spring Framework's build.
+ * Conventions are applied in response to various plugins being applied.
+ *
+ * When the {@link JavaBasePlugin} is applied, the conventions in {@link TestConventions}
+ * are applied.
+ * When the {@link JavaBasePlugin} is applied, the conventions in {@link JavaConventions}
+ * are applied.
+ * When the {@link KotlinBasePlugin} is applied, the conventions in {@link KotlinConventions}
+ * are applied.
+ *
+ * @author Brian Clozel
+ */
+public class ConventionsPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		new JavaConventions().apply(project);
+		new KotlinConventions().apply(project);
+		new TestConventions().apply(project);
+	}
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2020 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,36 +14,26 @@
 * limitations under the License.
 */

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

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

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

 /**
 * {@link Plugin} that applies conventions for compiling Java sources in Spring Framework.
- * <p>One can override the default Java source compatibility version
- * with a dedicated property on the CLI: {@code "./gradlew test -PjavaSourceVersion=11"}.
 *
 * @author Brian Clozel
 * @author Sam Brannen
+ * @author Sebastien Deleuze
 */
-public class CompilerConventionsPlugin implements Plugin<Project> {
-
-	/**
-	 * The project property that can be used to switch the Java source
-	 * compatibility version for building source and test classes.
-	 */
-	public static final String JAVA_SOURCE_VERSION_PROPERTY = "javaSourceVersion";
-
-	public static final JavaVersion DEFAULT_COMPILER_VERSION = JavaVersion.VERSION_1_8;
+public class JavaConventions {

 	private static final List<String> COMPILER_ARGS;

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

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

 	/**
@@ -78,16 +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);
-		if (project.hasProperty(JAVA_SOURCE_VERSION_PROPERTY)) {
-			JavaVersion javaSourceVersion = JavaVersion.toVersion(project.property(JAVA_SOURCE_VERSION_PROPERTY));
-			java.setSourceCompatibility(javaSourceVersion);
-		}
-		else {
-			java.setSourceCompatibility(DEFAULT_COMPILER_VERSION);
-		}
-		java.setTargetCompatibility(DEFAULT_COMPILER_VERSION);
-
 		project.getTasks().withType(JavaCompile.class)
 				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
 				.forEach(compileTask -> {
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.gradle.api.Project;
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions;
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile;
+
+/**
+ * @author Brian Clozel
+ */
+public class KotlinConventions {
+
+	void apply(Project project) {
+		project.getPlugins().withId("org.jetbrains.kotlin.jvm",
+				(plugin) -> project.getTasks().withType(KotlinCompile.class, this::configure));
+	}
+
+	private void configure(KotlinCompile compile) {
+		KotlinJvmOptions kotlinOptions = compile.getKotlinOptions();
+		kotlinOptions.setApiVersion("1.7");
+		kotlinOptions.setLanguageVersion("1.7");
+		kotlinOptions.setJvmTarget("17");
+		kotlinOptions.setAllWarningsAsErrors(true);
+		List<String> freeCompilerArgs = new ArrayList<>(compile.getKotlinOptions().getFreeCompilerArgs());
+		freeCompilerArgs.addAll(List.of("-Xsuppress-version-warnings", "-Xjsr305=strict", "-opt-in=kotlin.RequiresOptIn"));
+		compile.getKotlinOptions().setFreeCompilerArgs(freeCompilerArgs);
+	}
+
+}
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build;
+
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaBasePlugin;
+import org.gradle.api.tasks.testing.Test;
+import org.gradle.testretry.TestRetryPlugin;
+import org.gradle.testretry.TestRetryTaskExtension;
+
+/**
+ * Conventions that are applied in the presence of the {@link JavaBasePlugin}. When the
+ * plugin is applied:
+ * <ul>
+ * <li>The {@link TestRetryPlugin Test Retry} plugins is applied so that flaky tests
+ * are retried 3 times when running on the CI.
+ * </ul>
+ *
+ * @author Brian Clozel
+ * @author Andy Wilkinson
+ */
+class TestConventions {
+
+	void apply(Project project) {
+		project.getPlugins().withType(JavaBasePlugin.class, (java) -> configureTestConventions(project));
+	}
+
+	private void configureTestConventions(Project project) {
+		project.getPlugins().apply(TestRetryPlugin.class);
+		project.getTasks().withType(Test.class,
+				(test) -> project.getPlugins().withType(TestRetryPlugin.class, (testRetryPlugin) -> {
+					TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
+					testRetry.getFailOnPassedAfterRetry().set(true);
+					testRetry.getMaxRetries().set(isCi() ? 3 : 0);
+				}));
+	}
+
+	private boolean isCi() {
+		return Boolean.parseBoolean(System.getenv("CI"));
+	}
+
+}
@@ -16,6 +16,7 @@
 package org.springframework.build.api;

 import java.io.File;
+import java.net.URI;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Collections;
@@ -23,6 +24,7 @@ import java.util.List;

 import me.champeau.gradle.japicmp.JapicmpPlugin;
 import me.champeau.gradle.japicmp.JapicmpTask;
+import org.gradle.api.GradleException;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
@@ -32,10 +34,12 @@ import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
 import org.gradle.api.tasks.TaskProvider;
 import org.gradle.jvm.tasks.Jar;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;

 /**
 * {@link Plugin} that applies the {@code "japicmp-gradle-plugin"}
- * and create tasks for all subprojects, diffing the public API one by one
+ * and create tasks for all subprojects named {@code "spring-*"}, diffing the public API one by one
 * and creating the reports in {@code "build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/"}.
 * <p>{@code "./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE"} will output the
 * reports for the API diff between the baseline version and the current one for all modules.
@@ -46,12 +50,16 @@ import org.gradle.jvm.tasks.Jar;
 */
 public class ApiDiffPlugin implements Plugin<Project> {

+	private static final Logger logger = LoggerFactory.getLogger(ApiDiffPlugin.class);
+
 	public static final String TASK_NAME = "apiDiff";

 	private static final String BASELINE_VERSION_PROPERTY = "baselineVersion";

 	private static final List<String> PACKAGE_INCLUDES = Collections.singletonList("org.springframework.*");

+	private static final URI SPRING_MILESTONE_REPOSITORY = URI.create("https://repo.spring.io/milestone");
+
 	@Override
 	public void apply(Project project) {
 		if (project.hasProperty(BASELINE_VERSION_PROPERTY) && project.equals(project.getRootProject())) {
@@ -63,16 +71,24 @@ public class ApiDiffPlugin implements Plugin<Project> {

 	private void applyApiDiffConventions(Project project) {
 		String baselineVersion = project.property(BASELINE_VERSION_PROPERTY).toString();
-		project.subprojects(subProject -> createApiDiffTask(baselineVersion, subProject));
+		project.subprojects(subProject -> {
+			if (subProject.getName().startsWith("spring-")) {
+				createApiDiffTask(baselineVersion, subProject);
+			}
+		});
 	}

 	private void createApiDiffTask(String baselineVersion, Project project) {
 		if (isProjectEligible(project)) {
+			// Add Spring Milestone repository for generating diffs against previous milestones
+			project.getRootProject()
+					.getRepositories()
+					.maven(mavenArtifactRepository -> mavenArtifactRepository.setUrl(SPRING_MILESTONE_REPOSITORY));
 			JapicmpTask apiDiff = project.getTasks().create(TASK_NAME, JapicmpTask.class);
 			apiDiff.setDescription("Generates an API diff report with japicmp");
 			apiDiff.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP);

-			apiDiff.setOldClasspath(project.files(createBaselineConfiguration(baselineVersion, project)));
+			apiDiff.setOldClasspath(createBaselineConfiguration(baselineVersion, project));
 			TaskProvider<Jar> jar = project.getTasks().withType(Jar.class).named("jar");
 			apiDiff.setNewArchives(project.getLayout().files(jar.get().getArchiveFile().get().getAsFile()));
 			apiDiff.setNewClasspath(getRuntimeClassPath(project));
@@ -98,7 +114,16 @@ public class ApiDiffPlugin implements Plugin<Project> {
 		String baseline = String.join(":",
 				project.getGroup().toString(), project.getName(), baselineVersion);
 		Dependency baselineDependency = project.getDependencies().create(baseline + "@jar");
-		return project.getRootProject().getConfigurations().detachedConfiguration(baselineDependency);
+		Configuration baselineConfiguration = project.getRootProject().getConfigurations().detachedConfiguration(baselineDependency);
+		try {
+			// eagerly resolve the baseline configuration to check whether this is a new Spring module
+			baselineConfiguration.resolve();
+			return baselineConfiguration;
+		}
+		catch (GradleException exception) {
+			logger.warn("Could not resolve {} - assuming this is a new Spring module.", baseline);
+		}
+		return project.getRootProject().getConfigurations().detachedConfiguration();
 	}

 	private Configuration getRuntimeClassPath(Project project) {
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.hint;
+
+import java.util.Collections;
+
+import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.provider.SetProperty;
+
+/**
+ * Entry point to the DSL extension for the {@link RuntimeHintsAgentPlugin} Gradle plugin.
+ * @author Brian Clozel
+ */
+public class RuntimeHintsAgentExtension {
+
+	private final SetProperty<String> includedPackages;
+
+	private final SetProperty<String> excludedPackages;
+
+	public RuntimeHintsAgentExtension(ObjectFactory objectFactory) {
+		this.includedPackages = objectFactory.setProperty(String.class).convention(Collections.singleton("org.springframework"));
+		this.excludedPackages = objectFactory.setProperty(String.class).convention(Collections.emptySet());
+	}
+
+	public SetProperty<String> getIncludedPackages() {
+		return this.includedPackages;
+	}
+
+	public SetProperty<String> getExcludedPackages() {
+		return this.excludedPackages;
+	}
+
+	String asJavaAgentArgument() {
+		StringBuilder builder = new StringBuilder();
+		this.includedPackages.get().forEach(packageName -> builder.append('+').append(packageName).append(','));
+		this.excludedPackages.get().forEach(packageName -> builder.append('-').append(packageName).append(','));
+		return builder.toString();
+	}
+}
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2002-2022 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.hint;
+
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.tasks.bundling.Jar;
+import org.gradle.api.tasks.testing.Test;
+
+/**
+ * {@link Plugin} that configures the {@code RuntimeHints} Java agent to test tasks.
+ *
+ * @author Brian Clozel
+ */
+public class RuntimeHintsAgentPlugin implements Plugin<Project> {
+
+	public static final String RUNTIMEHINTS_TEST_TASK = "runtimeHintsTest";
+	private static final String EXTENSION_NAME = "runtimeHintsAgent";
+
+
+	@Override
+	public void apply(Project project) {
+
+		project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
+			RuntimeHintsAgentExtension agentExtension = project.getExtensions().create(EXTENSION_NAME,
+					RuntimeHintsAgentExtension.class, project.getObjects());
+			Test agentTest = project.getTasks().create(RUNTIMEHINTS_TEST_TASK, Test.class, test -> {
+				test.useJUnitPlatform(options -> {
+					options.includeTags("RuntimeHintsTests");
+				});
+				test.include("**/*Tests.class", "**/*Test.class");
+				test.systemProperty("java.awt.headless", "true");
+			});
+			project.afterEvaluate(p -> {
+				Jar jar = project.getRootProject().project("spring-core-test").getTasks().withType(Jar.class).named("jar").get();
+				agentTest.jvmArgs("-javaagent:" + jar.getArchiveFile().get().getAsFile() + "=" + agentExtension.asJavaAgentArgument());
+			});
+			project.getTasks().getByName("check", task -> task.dependsOn(agentTest));
+		});
+	}
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2019 the original author or authors.
+ * Copyright 2002-2021 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -20,15 +20,13 @@ import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginConvention;
+import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.tasks.SourceSetContainer;
-import org.gradle.plugins.ide.eclipse.EclipsePlugin;
-import org.gradle.plugins.ide.eclipse.model.EclipseModel;

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

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

-The Spring Framework is using 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.
+The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
+The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
+for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].

 === Setting up your development environment

@@ -25,13 +26,17 @@ spring                https://ci.spring.io  spring-framework      Wed, 25 Mar 20
 ----

 === Pipeline configuration and structure
+
 The build pipelines are described in `pipeline.yml` file.
+
 This file is listing Concourse resources, i.e. build inputs and outputs such as container images, artifact repositories, source repositories, notification services, etc.
+
 It also describes jobs (a job is a sequence of inputs, tasks and outputs); jobs are organized by groups.

 The `pipeline.yml` definition contains `((parameters))` which are loaded from the `parameters.yml` file or from our https://docs.cloudfoundry.org/credhub/[credhub instance].

 You'll find in this folder the following resources:
+
 * `pipeline.yml` the build pipeline
 * `parameters.yml` the build parameters used for the pipeline
 * `images/` holds the container images definitions used in this pipeline
@@ -41,11 +46,12 @@ You'll find in this folder the following resources:
 === Updating the build pipeline

 Updating files on the repository is not enough to update the build pipeline, as changes need to be applied.
+
 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.
+NOTE: This assumes that you have credhub integration configured with the appropriate secrets.
@@ -4,7 +4,7 @@ changelog:
    - title: ":star: New Features"
      labels:
        - "type: enhancement"
-    - title: ":beetle: Bug Fixes"
+    - title: ":lady_beetle: Bug Fixes"
      labels:
        - "type: bug"
        - "type: regression"
@@ -15,3 +15,6 @@ changelog:
      sort: "title"
      labels:
        - "type: dependency-upgrade"
+  contributors:
+    exclude:
+      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll"]
@@ -1,9 +1,10 @@
 logging:
  level:
    io.spring.concourse: DEBUG
-distribute:
-  optional-deployments:
-    - '.*\\.zip'
 spring:
  main:
-    banner-mode: off
+    banner-mode: off
+sonatype:
+  exclude:
+    - 'build-info\.json'
+    - '.*\.zip'
@@ -0,0 +1,12 @@
+FROM ubuntu:focal-20220922
+
+ADD setup.sh /setup.sh
+ADD get-jdk-url.sh /get-jdk-url.sh
+RUN ./setup.sh
+
+ENV JAVA_HOME /opt/openjdk/java17
+ENV JDK17 /opt/openjdk/java17
+ENV JDK18 /opt/openjdk/java18
+ENV JDK19 /opt/openjdk/java19
+
+ENV PATH $JAVA_HOME/bin:$PATH
@@ -2,16 +2,16 @@
 set -e

 case "$1" in
-	java8)
-		 echo "https://github.com/AdoptOpenJDK/openjdk8-binaries/releases/download/jdk8u275-b01/OpenJDK8U-jdk_x64_linux_hotspot_8u275b01.tar.gz"
+	java17)
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.5+8/bellsoft-jdk17.0.5+8-linux-amd64.tar.gz"
 	;;
-	java11)
-		 echo "https://github.com/AdoptOpenJDK/openjdk11-binaries/releases/download/jdk-11.0.9.1%2B1/OpenJDK11U-jdk_x64_linux_hotspot_11.0.9.1_1.tar.gz"
+	java18)
+		echo "https://github.com/bell-sw/Liberica/releases/download/18.0.2.1%2B1/bellsoft-jdk18.0.2.1+1-linux-amd64.tar.gz"
 	;;
-  java15)
-		 echo "https://github.com/AdoptOpenJDK/openjdk15-binaries/releases/download/jdk-15.0.1%2B9/OpenJDK15U-jdk_x64_linux_hotspot_15.0.1_9.tar.gz"
-  ;;
-  *)
+	java19)
+		echo "https://github.com/bell-sw/Liberica/releases/download/19.0.1%2B11/bellsoft-jdk19.0.1+11-linux-amd64.tar.gz"
+	;;
+	*)
 		echo $"Unknown java version"
 		exit 1
 esac
@@ -12,20 +12,25 @@ ln -fs /usr/share/zoneinfo/UTC /etc/localtime
 dpkg-reconfigure --frontend noninteractive tzdata
 rm -rf /var/lib/apt/lists/*

-curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.3/concourse-java.sh > /opt/concourse-java.sh
-
-curl --output /opt/concourse-release-scripts.jar https://repo.spring.io/release/io/spring/concourse/releasescripts/concourse-release-scripts/0.2.1/concourse-release-scripts-0.2.1.jar
+curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/concourse-java.sh > /opt/concourse-java.sh

 ###########################################################
 # JAVA
 ###########################################################
-JDK_URL=$( ./get-jdk-url.sh $1 )

 mkdir -p /opt/openjdk
-cd /opt/openjdk
-curl -L ${JDK_URL} | tar zx --strip-components=1
-test -f /opt/openjdk/bin/java
-test -f /opt/openjdk/bin/javac
+pushd /opt/openjdk > /dev/null
+for jdk in java17 java18 java19
+do
+  JDK_URL=$( /get-jdk-url.sh $jdk )
+  mkdir $jdk
+  pushd $jdk > /dev/null
+  curl -L ${JDK_URL} | tar zx --strip-components=1
+  test -f bin/java
+  test -f bin/javac
+  popd > /dev/null
+done
+popd

 ###########################################################
 # GRADLE ENTERPRISE
@@ -1,8 +0,0 @@
-FROM ubuntu:focal-20201106
-
-ADD setup.sh /setup.sh
-ADD get-jdk-url.sh /get-jdk-url.sh
-RUN ./setup.sh java8
-
-ENV JAVA_HOME /opt/openjdk
-ENV PATH $JAVA_HOME/bin:$PATH
@@ -1,8 +0,0 @@
-FROM ubuntu:focal-20201106
-
-ADD setup.sh /setup.sh
-ADD get-jdk-url.sh /get-jdk-url.sh
-RUN ./setup.sh java11
-
-ENV JAVA_HOME /opt/openjdk
-ENV PATH $JAVA_HOME/bin:$PATH
@@ -1,8 +0,0 @@
-FROM ubuntu:focal-20201106
-
-ADD setup.sh /setup.sh
-ADD get-jdk-url.sh /get-jdk-url.sh
-RUN ./setup.sh java15
-
-ENV JAVA_HOME /opt/openjdk
-ENV PATH $JAVA_HOME/bin:$PATH
@@ -1,14 +1,14 @@
-email-server: "smtp.svc.pivotal.io"
-email-from: "ci@spring.io"
-email-to: ["spring-framework-dev@pivotal.io"]
 github-repo: "https://github.com/spring-projects/spring-framework.git"
 github-repo-name: "spring-projects/spring-framework"
+sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "master"
+branch: "main"
+milestone: "6.0.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
-bintray-subject: "spring"
-bintray-repo: "jars"
-task-timeout: 1h00m
+registry-mirror-host: docker.repo.spring.io
+registry-mirror-username: ((artifactory-username))
+registry-mirror-password: ((artifactory-password))
+task-timeout: 1h00m
@@ -1,21 +1,33 @@
 anchors:
-  artifactory-task-params: &artifactory-task-params
-    ARTIFACTORY_SERVER: ((artifactory-server))
-    ARTIFACTORY_USERNAME: ((artifactory-username))
-    ARTIFACTORY_PASSWORD: ((artifactory-password))
-  bintray-task-params: &bintray-task-params
-    BINTRAY_SUBJECT: ((bintray-subject))
-    BINTRAY_REPO: ((bintray-repo))
-    BINTRAY_USERNAME: ((bintray-username))
-    BINTRAY_API_KEY: ((bintray-api-key))
-  docker-resource-source: &docker-resource-source
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
-    tag: 5.3.x
+  git-repo-resource-source: &git-repo-resource-source
+    uri: ((github-repo))
+    username: ((github-username))
+    password: ((github-ci-release-token))
+    branch: ((branch))
  gradle-enterprise-task-params: &gradle-enterprise-task-params
    GRADLE_ENTERPRISE_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
    GRADLE_ENTERPRISE_CACHE_USERNAME: ((gradle_enterprise_cache_user.username))
    GRADLE_ENTERPRISE_CACHE_PASSWORD: ((gradle_enterprise_cache_user.password))
+  sonatype-task-params: &sonatype-task-params
+    SONATYPE_USERNAME: ((sonatype-username))
+    SONATYPE_PASSWORD: ((sonatype-password))
+    SONATYPE_URL: ((sonatype-url))
+    SONATYPE_STAGING_PROFILE: ((sonatype-staging-profile))
+  artifactory-task-params: &artifactory-task-params
+    ARTIFACTORY_SERVER: ((artifactory-server))
+    ARTIFACTORY_USERNAME: ((artifactory-username))
+    ARTIFACTORY_PASSWORD: ((artifactory-password))
+  build-project-task-params: &build-project-task-params
+      BRANCH: ((branch))
+      <<: *gradle-enterprise-task-params
+  docker-resource-source: &docker-resource-source
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+    tag: ((milestone))
+  registry-mirror-vars: &registry-mirror-vars
+    registry-mirror-host: ((registry-mirror-host))
+    registry-mirror-username: ((registry-mirror-username))
+    registry-mirror-password: ((registry-mirror-password))
  slack-fail-params: &slack-fail-params
    text: >
      :concourse-failed: <https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}|${BUILD_PIPELINE_NAME} ${BUILD_JOB_NAME} failed!>
@@ -24,9 +36,6 @@ anchors:
    silent: true
    icon_emoji: ":concourse:"
    username: concourse-ci
-  sonatype-task-params: &sonatype-task-params
-    SONATYPE_USER_TOKEN: ((sonatype-user-token))
-    SONATYPE_PASSWORD_TOKEN: ((sonatype-user-token-password))
  changelog-task-params: &changelog-task-params
    name: generated-changelog/tag
    tag: generated-changelog/tag
@@ -36,38 +45,42 @@ anchors:
    GITHUB_TOKEN: ((github-ci-release-token))

 resource_types:
+- name: registry-image
+  type: registry-image
+  source:
+    repository: concourse/registry-image-resource
+    tag: 1.5.0
 - name: artifactory-resource
  type: registry-image
  source:
    repository: springio/artifactory-resource
-    tag: 0.0.12
+    tag: 0.0.17
+- name: github-release
+  type: registry-image
+  source:
+    repository: concourse/github-release-resource
+    tag: 1.5.5
 - name: github-status-resource
  type: registry-image
  source:
    repository: dpb587/github-status-resource
    tag: master
+- name: pull-request
+  type: registry-image
+  source:
+    repository: teliaoss/github-pr-resource
+    tag: v0.23.0
 - name: slack-notification
  type: registry-image
  source:
    repository: cfcommunity/slack-notification-resource
    tag: latest
-
 resources:
 - name: git-repo
  type: git
  icon: github
  source:
-    uri: ((github-repo))
-    username: ((github-username))
-    password: ((github-password))
-    branch: ((branch))
- name: every-morning
-  type: time
-  icon: alarm
-  source:
-    start: 8:00 AM
-    stop: 9:00 AM
-    location: Europe/Vienna
+    <<: *git-repo-resource-source
 - name: ci-images-git-repo
  type: git
  icon: github
@@ -75,24 +88,19 @@ resources:
    uri: ((github-repo))
    branch: ((branch))
    paths: ["ci/images/*"]
- name: spring-framework-ci-image
-  type: docker-image
+- name: ci-image
+  type: registry-image
  icon: docker
  source:
    <<: *docker-resource-source
-    repository: ((docker-hub-organization))/spring-framework-ci-image
- name: spring-framework-jdk11-ci-image
-  type: docker-image
-  icon: docker
+    repository: ((docker-hub-organization))/spring-framework-ci
+- name: every-morning
+  type: time
+  icon: alarm
  source:
-    <<: *docker-resource-source
-    repository: ((docker-hub-organization))/spring-framework-jdk11-ci-image
- name: spring-framework-jdk15-ci-image
-  type: docker-image
-  icon: docker
-  source:
-    <<: *docker-resource-source
-    repository: ((docker-hub-organization))/spring-framework-jdk15-ci-image
+    start: 8:00 AM
+    stop: 9:00 AM
+    location: Europe/Vienna
 - name: artifactory-repo
  type: artifactory-resource
  icon: package-variant
@@ -101,6 +109,14 @@ resources:
    username: ((artifactory-username))
    password: ((artifactory-password))
    build_name: ((build-name))
+- name: git-pull-request
+  type: pull-request
+  icon: source-pull
+  source:
+    access_token: ((github-ci-pull-request-token))
+    repository: ((github-repo-name))
+    base_branch: ((branch))
+    ignore_paths: ["ci/*"]
 - name: repo-status-build
  type: github-status-resource
  icon: eye-check-outline
@@ -109,22 +125,22 @@ resources:
    access_token: ((github-ci-status-token))
    branch: ((branch))
    context: build
- name: repo-status-jdk11-build
+- name: repo-status-jdk18-build
  type: github-status-resource
  icon: eye-check-outline
  source:
    repository: ((github-repo-name))
    access_token: ((github-ci-status-token))
    branch: ((branch))
-    context: jdk11-build
- name: repo-status-jdk15-build
+    context: jdk18-build
+- name: repo-status-jdk19-build
  type: github-status-resource
  icon: eye-check-outline
  source:
    repository: ((github-repo-name))
    access_token: ((github-ci-status-token))
    branch: ((branch))
-    context: jdk15-build
+    context: jdk19-build
 - name: slack-alert
  type: slack-notification
  icon: slack
@@ -147,43 +163,40 @@ resources:
    repository: spring-framework
    access_token: ((github-ci-release-token))
    pre_release: false
-
 jobs:
- name: build-spring-framework-ci-images
+- name: build-ci-images
  plan:
-  - get: ci-images-git-repo
-    trigger: true
-  - in_parallel:
-    - put: spring-framework-ci-image
+    - get: git-repo
+    - get: ci-images-git-repo
+      trigger: true
+    - task: build-ci-image
+      privileged: true
+      file: git-repo/ci/tasks/build-ci-image.yml
+      output_mapping:
+        image: ci-image
+      vars:
+        ci-image-name: ci-image
+        <<: *registry-mirror-vars
+    - put: ci-image
      params:
-        build: ci-images-git-repo/ci/images
-        dockerfile: ci-images-git-repo/ci/images/spring-framework-ci-image/Dockerfile
-    - put: spring-framework-jdk11-ci-image
-      params:
-        build: ci-images-git-repo/ci/images
-        dockerfile: ci-images-git-repo/ci/images/spring-framework-jdk11-ci-image/Dockerfile
-    - put: spring-framework-jdk15-ci-image
-      params:
-        build: ci-images-git-repo/ci/images
-        dockerfile: ci-images-git-repo/ci/images/spring-framework-jdk15-ci-image/Dockerfile
+        image: ci-image/image.tar
 - name: build
  serial: true
  public: true
  plan:
-  - get: spring-framework-ci-image
+  - get: ci-image
  - get: git-repo
    trigger: true
  - put: repo-status-build
    params: { state: "pending", commit: "git-repo" }
  - do:
    - task: build-project
+      image: ci-image
+      file: git-repo/ci/tasks/build-project.yml
      privileged: true
      timeout: ((task-timeout))
-      image: spring-framework-ci-image
-      file: git-repo/ci/tasks/build-project.yml
      params:
-        BRANCH: ((branch))
-        <<: *gradle-enterprise-task-params
+        <<: *build-project-task-params
    on_failure:
      do:
      - put: repo-status-build
@@ -195,6 +208,8 @@ jobs:
    params: { state: "success", commit: "git-repo" }
  - put: artifactory-repo
    params: &artifactory-params
+      signing_key: ((signing-key))
+      signing_passphrase: ((signing-passphrase))
      repo: libs-snapshot-local
      folder: distribution-repository
      build_uri: "https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}"
@@ -203,89 +218,120 @@ 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
+- name: jdk18-build
  serial: true
  public: true
  plan:
-  - get: spring-framework-jdk11-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
-      privileged: true
-      timeout: ((task-timeout))
-      image: spring-framework-jdk11-ci-image
-      file: git-repo/ci/tasks/check-project.yml
-      params:
-        BRANCH: ((branch))
-        <<: *gradle-enterprise-task-params
-    on_failure:
-      do:
-      - put: repo-status-jdk11-build
-        params: { state: "failure", commit: "git-repo" }
-      - put: slack-alert
-        params:
-          <<: *slack-fail-params
-  - put: repo-status-jdk11-build
-    params: { state: "success", commit: "git-repo" }
- name: jdk15-build
-  serial: true
-  public: true
-  plan:
-    - get: spring-framework-jdk15-ci-image
+    - get: ci-image
    - get: git-repo
    - get: every-morning
      trigger: true
-    - put: repo-status-jdk15-build
+    - put: repo-status-jdk18-build
      params: { state: "pending", commit: "git-repo" }
    - do:
        - task: check-project
+          image: ci-image
+          file: git-repo/ci/tasks/check-project.yml
          privileged: true
          timeout: ((task-timeout))
-          image: spring-framework-jdk15-ci-image
-          file: git-repo/ci/tasks/check-project.yml
          params:
-            BRANCH: ((branch))
-            <<: *gradle-enterprise-task-params
+            TEST_TOOLCHAIN: 18
+            <<: *build-project-task-params
      on_failure:
        do:
-          - put: repo-status-jdk15-build
+          - put: repo-status-jdk18-build
            params: { state: "failure", commit: "git-repo" }
          - put: slack-alert
            params:
              <<: *slack-fail-params
-    - put: repo-status-jdk15-build
+    - put: repo-status-jdk18-build
      params: { state: "success", commit: "git-repo" }
+- name: jdk19-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk19-build
+      params: { state: "pending", commit: "git-repo" }
+    - do:
+        - task: check-project
+          image: ci-image
+          file: git-repo/ci/tasks/check-project.yml
+          privileged: true
+          timeout: ((task-timeout))
+          params:
+            TEST_TOOLCHAIN: 19
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk19-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk19-build
+      params: { state: "success", commit: "git-repo" }
+- name: build-pull-requests
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      resource: git-pull-request
+      trigger: true
+      version: every
+    - do:
+      - put: git-pull-request
+        params:
+          path: git-repo
+          status: pending
+      - task: build-pr
+        image: ci-image
+        file: git-repo/ci/tasks/build-pr.yml
+        privileged: true
+        timeout: ((task-timeout))
+        params:
+          BRANCH: ((branch))
+      on_success:
+        put: git-pull-request
+        params:
+          path: git-repo
+          status: success
+      on_failure:
+        put: git-pull-request
+        params:
+          path: git-repo
+          status: failure
 - name: stage-milestone
  serial: true
  plan:
-    - get: spring-framework-ci-image
+    - get: ci-image
    - get: git-repo
      trigger: false
    - task: stage
-      image: spring-framework-ci-image
+      image: ci-image
      file: git-repo/ci/tasks/stage-version.yml
      params:
        RELEASE_TYPE: M
@@ -300,7 +346,7 @@ jobs:
 - name: promote-milestone
  serial: true
  plan:
-    - get: spring-framework-ci-image
+    - get: ci-image
    - get: git-repo
      trigger: false
    - get: artifactory-repo
@@ -310,7 +356,6 @@ jobs:
        download_artifacts: false
        save_build_info: true
    - task: promote
-      image: spring-framework-ci-image
      file: git-repo/ci/tasks/promote-version.yml
      params:
        RELEASE_TYPE: M
@@ -326,11 +371,11 @@ jobs:
 - name: stage-rc
  serial: true
  plan:
-    - get: spring-framework-ci-image
+    - get: ci-image
    - get: git-repo
      trigger: false
    - task: stage
-      image: spring-framework-ci-image
+      image: ci-image
      file: git-repo/ci/tasks/stage-version.yml
      params:
        RELEASE_TYPE: RC
@@ -345,7 +390,7 @@ jobs:
 - name: promote-rc
  serial: true
  plan:
-    - get: spring-framework-ci-image
+    - get: ci-image
    - get: git-repo
      trigger: false
    - get: artifactory-repo
@@ -355,7 +400,6 @@ jobs:
        download_artifacts: false
        save_build_info: true
    - task: promote
-      image: spring-framework-ci-image
      file: git-repo/ci/tasks/promote-version.yml
      params:
        RELEASE_TYPE: RC
@@ -371,11 +415,11 @@ jobs:
 - name: stage-release
  serial: true
  plan:
-    - get: spring-framework-ci-image
+    - get: ci-image
    - get: git-repo
      trigger: false
    - task: stage
-      image: spring-framework-ci-image
+      image: ci-image
      file: git-repo/ci/tasks/stage-version.yml
      params:
        RELEASE_TYPE: RELEASE
@@ -390,26 +434,25 @@ jobs:
 - name: promote-release
  serial: true
  plan:
-    - get: spring-framework-ci-image
+    - get: ci-image
    - get: git-repo
      trigger: false
    - get: artifactory-repo
      trigger: false
      passed: [stage-release]
      params:
-        download_artifacts: false
+        download_artifacts: true
        save_build_info: true
    - task: promote
-      image: spring-framework-ci-image
      file: git-repo/ci/tasks/promote-version.yml
      params:
        RELEASE_TYPE: RELEASE
        <<: *artifactory-task-params
-        <<: *bintray-task-params
- name: sync-to-maven-central
+        <<: *sonatype-task-params
+- name: create-github-release
  serial: true
  plan:
-    - get: spring-framework-ci-image
+    - get: ci-image
    - get: git-repo
    - get: artifactory-repo
      trigger: true
@@ -417,12 +460,6 @@ jobs:
      params:
        download_artifacts: false
        save_build_info: true
-    - task: sync-to-maven-central
-      image: spring-framework-ci-image
-      file: git-repo/ci/tasks/sync-to-maven-central.yml
-      params:
-        <<: *bintray-task-params
-        <<: *sonatype-task-params
    - task: generate-changelog
      file: git-repo/ci/tasks/generate-changelog.yml
      params:
@@ -434,8 +471,10 @@ jobs:

 groups:
 - name: "builds"
-  jobs: ["build", "jdk11-build", "jdk15-build"]
+  jobs: ["build", "jdk18-build", "jdk19-build"]
 - name: "releases"
-  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone","promote-rc", "promote-release", "sync-to-maven-central"]
+  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
 - name: "ci-images"
-  jobs: ["build-spring-framework-ci-images"]
+  jobs: ["build-ci-images"]
+- name: "pull-requests"
+  jobs: [ "build-pull-requests" ]
@@ -0,0 +1,8 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 check
+popd > /dev/null
@@ -4,5 +4,6 @@ set -e
 source $(dirname $0)/common.sh

 pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 check
+./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
@@ -2,7 +2,7 @@
 set -e

 CONFIG_DIR=git-repo/ci/config
-version=$( cat version/version )
+version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )

 java -jar /github-changelog-generator.jar \
  --spring.config.location=${CONFIG_DIR}/changelog-generator.yml \
@@ -1,16 +1,17 @@
 #!/bin/bash

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

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

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

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

-git config user.name "Spring Buildmaster" > /dev/null
-git config user.email "buildmaster@springframework.org" > /dev/null
+git config user.name "Spring Builds" > /dev/null
+git config user.email "spring-builds@users.noreply.github.com" > /dev/null
 git add gradle.properties > /dev/null
 git commit -m"Release v$stageVersion" > /dev/null
 git tag -a "v$stageVersion" -m"Release v$stageVersion" > /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-
-export BUILD_INFO_LOCATION=$(pwd)/artifactory-repo/build-info.json
-version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
-java -jar /opt/concourse-release-scripts.jar syncToCentral "RELEASE" $BUILD_INFO_LOCATION || { exit 1; }
-
-echo "Sync complete"
-echo $version > version/version
@@ -0,0 +1,32 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: concourse/oci-build-task
+    tag: 0.10.0
+    registry_mirror:
+      host: ((registry-mirror-host))
+      username: ((registry-mirror-username))
+      password: ((registry-mirror-password))
+inputs:
+  - name: ci-images-git-repo
+outputs:
+  - name: image
+caches:
+  - path: ci-image-cache
+params:
+  CONTEXT: ci-images-git-repo/ci/images
+  DOCKERFILE: ci-images-git-repo/ci/images/ci-image/Dockerfile
+  DOCKER_HUB_AUTH: ((docker-hub-auth))
+run:
+  path: /bin/sh
+  args:
+    - "-c"
+    - |
+      mkdir -p /root/.docker
+      cat > /root/.docker/config.json <<EOF
+      { "auths": { "https://index.docker.io/v1/": { "auth": "$DOCKER_HUB_AUTH" }}}
+      EOF
+      build
+
@@ -0,0 +1,19 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/build-pr.sh
@@ -10,6 +10,8 @@ caches:
 params:
  BRANCH:
  CI: true
+  MAIN_TOOLCHAIN:
+  TEST_TOOLCHAIN:
  GRADLE_ENTERPRISE_ACCESS_KEY:
  GRADLE_ENTERPRISE_CACHE_USERNAME:
  GRADLE_ENTERPRISE_CACHE_PASSWORD:
@@ -1,13 +1,13 @@
 ---
 platform: linux
 image_resource:
-  type: docker-image
+  type: registry-image
  source:
    repository: springio/github-changelog-generator
-    tag: '0.0.4'
+    tag: '0.0.8'
 inputs:
 - name: git-repo
- name: version
+- name: artifactory-repo
 outputs:
 - name: generated-changelog
 params:
@@ -1,5 +1,10 @@
 ---
 platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/concourse-release-scripts
+    tag: '0.3.4'
 inputs:
 - name: git-repo
 - name: artifactory-repo
@@ -10,9 +15,9 @@ params:
  ARTIFACTORY_SERVER:
  ARTIFACTORY_USERNAME:
  ARTIFACTORY_PASSWORD:
-  BINTRAY_SUBJECT:
-  BINTRAY_REPO:
-  BINTRAY_USERNAME:
-  BINTRAY_API_KEY:
+  SONATYPE_USER:
+  SONATYPE_PASSWORD:
+  SONATYPE_URL:
+  SONATYPE_STAGING_PROFILE:
 run:
  path: git-repo/ci/scripts/promote-version.sh
@@ -1,16 +0,0 @@
---
-platform: linux
-inputs:
- name: git-repo
- name: artifactory-repo
-outputs:
- name: version
-params:
-  BINTRAY_REPO:
-  BINTRAY_SUBJECT:
-  BINTRAY_USERNAME:
-  BINTRAY_API_KEY:
-  SONATYPE_USER_TOKEN:
-  SONATYPE_PASSWORD_TOKEN:
-run:
-  path: git-repo/ci/scripts/sync-to-maven-central.sh
@@ -1,17 +1,30 @@
+description = "Spring Framework Docs"
+
+apply plugin: 'kotlin'
+apply plugin: 'org.asciidoctor.jvm.convert'
+apply plugin: 'org.asciidoctor.jvm.pdf'
+apply from: "${rootDir}/gradle/publications.gradle"
+
+
 configurations {
-	asciidoctorExt
+	asciidoctorExtensions
+}
+
+jar {
+	enabled = false
+}
+
+javadoc {
+	enabled = false
 }

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

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

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

 asciidoctorj {
-	version = '2.4.1'
+	def docRoot = 'https://docs.spring.io'
+	def docsSpringFramework = "${docRoot}/spring-framework/docs/${project.version}"
+	version = '2.4.3'
 	fatalWarnings ".*"
 	options doctype: 'book', eruby: 'erubis'
 	attributes([
 			icons: 'font',
 			idprefix: '',
 			idseparator: '-',
-			docinfo: 'shared',
 			revnumber: project.version,
 			sectanchors: '',
 			sectnums: '',
-			'source-highlighter': 'highlight.js',
-			highlightjsdir: 'js/highlight',
-			'highlightjs-theme': 'googlecode',
-			stylesdir: 'css/',
-			stylesheet: 'stylesheet.css',
-			'spring-version': project.version
+			'spring-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"
 	])
 }

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

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

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

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

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

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

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

 distZip.mustRunAfter moduleProjects.check
+
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifact docsZip
+			artifact schemaZip
+			artifact distZip
+		}
+	}
+}
@@ -1,7 +1,7 @@
 <html>
 <body>
 <p>
-This is the public API documentation for the <a href="https://github.com/SpringSource/spring-framework" target="_top">Spring Framework</a>.
+This is the public API documentation for the <a href="https://github.com/spring-projects/spring-framework" target="_top">Spring Framework</a>.
 </p>
 </body>
 </html>
@@ -0,0 +1,82 @@
+[[appendix]]
+= Appendix
+:toc: left
+:toclevels: 4
+:tabsize: 4
+:docinfo1:
+
+This part of the reference documentation covers topics that apply to multiple modules
+within the core Spring Framework.
+
+
+[[appendix-spring-properties]]
+== Spring Properties
+
+{api-spring-framework}/core/SpringProperties.html[`SpringProperties`] is a static holder
+for properties that control certain low-level aspects of the Spring Framework. Users can
+configure these properties via JVM system properties or programmatically via the
+`SpringProperties.setProperty(String key, String value)` method. The latter may be
+necessary if the deployment environment disallows custom JVM system properties. As an
+alternative, these properties may be configured in a `spring.properties` file in the root
+of the classpath -- for example, deployed within the application's JAR file.
+
+The following table lists all currently supported Spring properties.
+
+.Supported Spring Properties
+|===
+| Name | Description
+
+| `spring.beaninfo.ignore`
+| Instructs Spring to use the `Introspector.IGNORE_ALL_BEANINFO` mode when calling the
+JavaBeans `Introspector`. See
+{api-spring-framework}++/beans/CachedIntrospectionResults.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
+for details.
+
+| `spring.expression.compiler.mode`
+| The mode to use when compiling expressions for the
+<<core.adoc#expressions-compiler-configuration, Spring Expression Language>>.
+
+| `spring.getenv.ignore`
+| Instructs Spring to ignore operating system environment variables if a Spring
+`Environment` property -- for example, a placeholder in a configuration String -- isn't
+resolvable otherwise. See
+{api-spring-framework}++/core/env/AbstractEnvironment.html#IGNORE_GETENV_PROPERTY_NAME++[`AbstractEnvironment`]
+for details.
+
+| `spring.index.ignore`
+| Instructs Spring to ignore the components index located in
+`META-INF/spring.components`. See <<core.adoc#beans-scanning-index, Generating an Index
+of Candidate Components>>.
+
+| `spring.jdbc.getParameterType.ignore`
+| Instructs Spring to ignore `java.sql.ParameterMetaData.getParameterType` completely.
+See the note in <<data-access.adoc#jdbc-batch-list, Batch Operations with a List of Objects>>.
+
+| `spring.jndi.ignore`
+| Instructs Spring to ignore a default JNDI environment, as an optimization for scenarios
+where nothing is ever to be found for such JNDI fallback searches to begin with, avoiding
+the repeated JNDI lookup overhead. See
+{api-spring-framework}++/jndi/JndiLocatorDelegate.html#IGNORE_JNDI_PROPERTY_NAME++[`JndiLocatorDelegate`]
+for details.
+
+| `spring.objenesis.ignore`
+| Instructs Spring to ignore Objenesis, not even attempting to use it. See
+{api-spring-framework}++/objenesis/SpringObjenesis.html#IGNORE_OBJENESIS_PROPERTY_NAME++[`SpringObjenesis`]
+for details.
+
+| `spring.test.constructor.autowire.mode`
+| The default _test constructor autowire mode_ to use if `@TestConstructor` is not present
+on a test class. See <<testing.adoc#integration-testing-annotations-testconstructor,
+Changing the default test constructor autowire mode>>.
+
+| `spring.test.context.cache.maxSize`
+| The maximum size of the context cache in the _Spring TestContext Framework_. See
+<<testing.adoc#testcontext-ctx-management-caching, Context Caching>>.
+
+| `spring.test.enclosing.configuration`
+| The default _enclosing configuration inheritance mode_ to use if
+`@NestedTestConfiguration` is not present on a test class. See
+<<testing.adoc#integration-testing-annotations-nestedtestconfiguration, Changing the
+default enclosing configuration inheritance mode>>.
+
+|===
@@ -1,7 +1,5 @@
 [[spring-core]]
 = Core Technologies
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
 :toc: left
 :toclevels: 4
 :tabsize: 4
@@ -21,6 +19,9 @@ Coverage of Spring's integration with AspectJ (currently the richest -- in terms
 features -- and certainly most mature AOP implementation in the Java enterprise space)
 is also provided.

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

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

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

+include::core/core-aot.adoc[leveloffset=+1]
+
 include::core/core-appendix.adoc[leveloffset=+1]
@@ -25,26 +25,13 @@ target different advice with the same pointcut.
 The `org.springframework.aop.Pointcut` interface is the central interface, used to
 target advices to particular classes and methods. The complete interface follows:

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

 		ClassFilter getClassFilter();

 		MethodMatcher getMethodMatcher();
-
-	}
----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface Pointcut {
-
-		fun getClassFilter(): ClassFilter
-
-		fun getMethodMatcher(): MethodMatcher
-
 	}
 ----

@@ -56,47 +43,25 @@ The `ClassFilter` interface is used to restrict the pointcut to a given set of t
 classes. If the `matches()` method always returns true, all target classes are
 matched. The following listing shows the `ClassFilter` interface definition:

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

 		boolean matches(Class clazz);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface ClassFilter {
-
-		fun matches(clazz: Class<*>): Boolean
-	}
----

 The `MethodMatcher` interface is normally more important. The complete interface follows:

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

-		boolean matches(Method m, Class targetClass);
+		boolean matches(Method m, Class<?> targetClass);

 		boolean isRuntime();

-		boolean matches(Method m, Class targetClass, Object[] args);
-	}
----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface MethodMatcher {
-
-		val isRuntime: Boolean
-
-		fun matches(m: Method, targetClass: Class<*>): Boolean
-
-		fun matches(m: Method, targetClass: Class<*>, args: Array<Any>): Boolean
+		boolean matches(Method m, Class<?> targetClass, Object... args);
 	}
 ----

@@ -335,22 +300,13 @@ Spring is compliant with the AOP `Alliance` interface for around advice that use
 interception. Classes that implement `MethodInterceptor` and that implement around advice should also implement the
 following interface:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	public interface MethodInterceptor extends Interceptor {

 		Object invoke(MethodInvocation invocation) throws Throwable;
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface MethodInterceptor : Interceptor {
-
-		fun invoke(invocation: MethodInvocation) : Any
-	}
----

 The `MethodInvocation` argument to the `invoke()` method exposes the method being
 invoked, the target join point, the AOP proxy, and the arguments to the method. The
@@ -413,22 +369,13 @@ interceptor chain.

 The following listing shows the `MethodBeforeAdvice` interface:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	public interface MethodBeforeAdvice extends BeforeAdvice {

 		void before(Method m, Object[] args, Object target) throws Throwable;
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-interface MethodBeforeAdvice : BeforeAdvice {
-
-	fun before(m: Method, args: Array<Any>, target: Any)
-}
----

 (Spring's API design would allow for
 field before advice, although the usual objects apply to field interception and it is
@@ -591,8 +538,7 @@ TIP: Throws advice can be used with any pointcut.
 An after returning advice in Spring must implement the
 `org.springframework.aop.AfterReturningAdvice` interface, which the following listing shows:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	public interface AfterReturningAdvice extends Advice {

@@ -600,14 +546,6 @@ An after returning advice in Spring must implement the
 				throws Throwable;
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface AfterReturningAdvice : Advice {
-
-		fun afterReturning(returnValue: Any, m: Method, args: Array<Any>, target: Any)
-	}
----

 An after returning advice has access to the return value (which it cannot modify),
 the invoked method, the method's arguments, and the target.
@@ -660,22 +598,13 @@ Spring treats introduction advice as a special kind of interception advice.
 Introduction requires an `IntroductionAdvisor` and an `IntroductionInterceptor` that
 implement the following interface:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	public interface IntroductionInterceptor extends MethodInterceptor {

 		boolean implementsInterface(Class intf);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface IntroductionInterceptor : MethodInterceptor {
-
-		fun implementsInterface(intf: Class<*>): Boolean
-	}
----

 The `invoke()` method inherited from the AOP Alliance `MethodInterceptor` interface must
 implement the introduction. That is, if the invoked method is on an introduced
@@ -686,8 +615,7 @@ Introduction advice cannot be used with any pointcut, as it applies only at the
 rather than the method, level. You can only use introduction advice with the
 `IntroductionAdvisor`, which has the following methods:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	public interface IntroductionAdvisor extends Advisor, IntroductionInfo {

@@ -701,22 +629,6 @@ rather than the method, level. You can only use introduction advice with the
 		Class<?>[] getInterfaces();
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface IntroductionAdvisor : Advisor, IntroductionInfo {
-
-		val classFilter: ClassFilter
-
-		@Throws(IllegalArgumentException::class)
-		fun validateInterfaces()
-	}
-
-	interface IntroductionInfo {
-
-		val interfaces: Array<Class<*>>
-	}
----

 There is no `MethodMatcher` and, hence, no `Pointcut` associated with introduction
 advice. Only class filtering is logical.
@@ -1725,7 +1637,7 @@ The following listing shows an example configuration:

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

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

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


@@ -316,17 +316,17 @@ other class. They can also contain pointcut, advice, and introduction (inter-typ
 declarations.

 .Autodetecting aspects through component scanning
-NOTE: You can register aspect classes as regular beans in your Spring XML configuration or
-autodetect them through classpath scanning -- the same as any other Spring-managed bean.
-However, note that the `@Aspect` annotation is not sufficient for autodetection in
-the classpath. For that purpose, you need to add a separate `@Component` annotation
-(or, alternatively, a custom stereotype annotation that qualifies, as per the rules of
-Spring's component scanner).
+NOTE: You can register aspect classes as regular beans in your Spring XML configuration,
+via `@Bean` methods in `@Configuration` classes, or have Spring autodetect them through
+classpath scanning -- the same as any other Spring-managed bean. However, note that the
+`@Aspect` annotation is not sufficient for autodetection in the classpath. For that
+purpose, you need to add a separate `@Component` annotation (or, alternatively, a custom
+stereotype annotation that qualifies, as per the rules of Spring's component scanner).

 .Advising aspects with other aspects?
-NOTE: In Spring AOP, aspects themselves cannot be the targets of advice
-from other aspects. The `@Aspect` annotation on a class marks it as an aspect and,
-hence, excludes it from auto-proxying.
+NOTE: In Spring AOP, aspects themselves cannot be the targets of advice from other
+aspects. The `@Aspect` annotation on a class marks it as an aspect and, hence, excludes
+it from auto-proxying.



@@ -361,12 +361,12 @@ matches the execution of any method named `transfer`:
 ----

 The pointcut expression that forms the value of the `@Pointcut` annotation is a regular
-AspectJ 5 pointcut expression. For a full discussion of AspectJ's pointcut language, see
+AspectJ pointcut expression. For a full discussion of AspectJ's pointcut language, see
 the https://www.eclipse.org/aspectj/doc/released/progguide/index.html[AspectJ
 Programming Guide] (and, for extensions, the
 https://www.eclipse.org/aspectj/doc/released/adk15notebook/index.html[AspectJ 5
 Developer's Notebook]) or one of the books on AspectJ (such as _Eclipse AspectJ_, by Colyer
-et. al., or _AspectJ in Action_, by Ramnivas Laddad).
+et al., or _AspectJ in Action_, by Ramnivas Laddad).


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

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

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

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

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

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

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

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

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

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

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

 The following example shows how to use around advice:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-Notice that, for the time, being we assume that all business services are idempotent. If
+Notice that, for the time being, we assume that all business services are idempotent. If
 this is not the case, we can refine the aspect so that it retries only genuinely
 idempotent operations, by introducing an `Idempotent` annotation and using the annotation
 to annotate the implementation of service operations, as the following example shows:
@@ -3394,7 +3425,7 @@ definition to configure new `Account` instances.
 You can also use autowiring to avoid having to specify a dedicated bean definition at
 all. To have Spring apply autowiring, use the `autowire` property of the `@Configurable`
 annotation. You can specify either `@Configurable(autowire=Autowire.BY_TYPE)` or
-`@Configurable(autowire=Autowire.BY_NAME` for autowiring by type or by name,
+`@Configurable(autowire=Autowire.BY_NAME)` for autowiring by type or by name,
 respectively. As an alternative, it is preferable to specify explicit, annotation-driven
 dependency injection for your `@Configurable` beans through `@Autowired` or `@Inject`
 at the field or method level (see <<beans-annotation-config>> for further details).
@@ -3471,7 +3502,7 @@ use Java-based configuration, you can add `@EnableSpringConfigured` to any
 ----

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

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

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

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

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




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

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



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

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


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

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

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

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

 	public enum PersistenceContextType {

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

 	enum class PersistenceContextType {

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


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

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

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

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


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

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


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

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


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

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


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

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



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

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



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

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


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

 This element activates the replacement of `${...}` placeholders, which are resolved against a
@@ -562,14 +560,15 @@ 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:

 * Spring's <<core.adoc#beans-factory-metadata, `@Configuration`>> model
-* <<core.adoc#beans-annotation-config, `@Autowired`/`@Inject`>> and `@Value`
-* JSR-250's `@Resource`, `@PostConstruct` and `@PreDestroy` (if available)
+* <<core.adoc#beans-annotation-config, `@Autowired`/`@Inject`>>, `@Value`, and `@Lookup`
+* JSR-250's `@Resource`, `@PostConstruct`, and `@PreDestroy` (if available)
+* JAX-WS's `@WebServiceRef` and EJB 3's `@EJB` (if available)
 * JPA's `@PersistenceContext` and `@PersistenceUnit` (if available)
 * Spring's <<core.adoc#context-functionality-events-annotation, `@EventListener`>>

@@ -584,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,
@@ -613,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
@@ -625,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
@@ -654,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
@@ -666,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
@@ -695,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
@@ -751,7 +750,7 @@ essentially the same as the following XML snippet:
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<bean id="dateFormat" class="java.text.SimpleDateFormat">
-		<constructor-arg value="yyyy-HH-dd HH:mm"/>
+		<constructor-arg value="yyyy-MM-dd HH:mm"/>
 		<property name="lenient" value="true"/>
 	</bean>
 ----
@@ -767,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
@@ -838,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
@@ -928,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
@@ -940,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
@@ -959,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
@@ -983,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
@@ -1017,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
@@ -1197,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:

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



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

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

 	ExpressionParser parser = new SpelExpressionParser(config);

@@ -433,9 +433,9 @@ interpreter and only 3ms using the compiled version of the expression.

 The compiler is not turned on by default, but you can turn it on in either of two
 different ways. You can turn it on by using the parser configuration process
-(<<expressions-parser-configuration, discussed earlier>>) or by using a system
-property when SpEL usage is embedded inside another component. This section
-discusses both of these options.
+(<<expressions-parser-configuration, discussed earlier>>) or by using a Spring property
+when SpEL usage is embedded inside another component. This section discusses both of
+these options.

 The compiler can operate in one of three modes, which are captured in the
 `org.springframework.expression.spel.SpelCompilerMode` enum. The modes are as follows:
@@ -465,7 +465,7 @@ following example shows how to do so:
 .Java
 ----
 	SpelParserConfiguration config = new SpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
-		this.getClass().getClassLoader());
+			this.getClass().getClassLoader());

 	SpelExpressionParser parser = new SpelExpressionParser(config);

@@ -496,10 +496,12 @@ It is important to ensure that, if a classloader is specified, it can see all th
 the expression evaluation process. If you do not specify a classloader, a default classloader is used
 (typically the context classloader for the thread that is running during expression evaluation).

-The second way to configure the compiler is for use when SpEL is embedded inside some other
-component and it may not be possible to configure it through a configuration object. In these
-cases, it is possible to use a system property. You can set the `spring.expression.compiler.mode`
-property to one of the `SpelCompilerMode` enum values (`off`, `immediate`, or `mixed`).
+The second way to configure the compiler is for use when SpEL is embedded inside some
+other component and it may not be possible to configure it through a configuration
+object. In these cases, it is possible to set the `spring.expression.compiler.mode`
+property via a JVM system property (or via the
+<<appendix.adoc#appendix-spring-properties,`SpringProperties`>> mechanism) to one of the
+`SpelCompilerMode` enum values (`off`, `immediate`, or `mixed`).


 [[expressions-compiler-limitations]]
@@ -515,7 +517,7 @@ kinds of expression cannot be compiled at the moment:
 * Expressions using custom resolvers or accessors
 * Expressions using selection or projection

-More types of expression will be compilable in the future.
+More types of expressions will be compilable in the future.



@@ -587,7 +589,7 @@ You can also refer to other bean properties by name, as the following example sh
 To specify a default value, you can place the `@Value` annotation on fields, methods,
 and method or constructor parameters.

-The following example sets the default value of a field variable:
+The following example sets the default value of a field:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -786,7 +788,7 @@ using a literal on one side of a logical comparison operator.
 ----

 Numbers support the use of the negative sign, exponential notation, and decimal points.
-By default, real numbers are parsed by using Double.parseDouble().
+By default, real numbers are parsed by using `Double.parseDouble()`.



@@ -794,10 +796,10 @@ By default, real numbers are parsed by using Double.parseDouble().
 === Properties, Arrays, Lists, Maps, and Indexers

 Navigating with property references is easy. To do so, use a period to indicate a nested
-property value. The instances of the `Inventor` class, `pupin` and `tesla`, were populated with
-data listed in the <<expressions-example-classes, Classes used in the examples>> section.
-To navigate "`down`" and get Tesla's year of birth and Pupin's city of birth, we use the following
-expressions:
+property value. The instances of the `Inventor` class, `pupin` and `tesla`, were
+populated with data listed in the <<expressions-example-classes, Classes used in the
+examples>> section. To navigate "down" the object graph and get Tesla's year of birth and
+Pupin's city of birth, we use the following expressions:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -937,7 +939,7 @@ You can directly express lists in an expression by using `{}` notation.
 ----

 `{}` by itself means an empty list. For performance reasons, if the list is itself
-entirely composed of fixed literals,  a constant list is created to represent the
+entirely composed of fixed literals, a constant list is created to represent the
 expression (rather than building a new list on each evaluation).


@@ -956,7 +958,7 @@ following example shows how to do so:

 	Map mapOfMaps = (Map) parser.parseExpression("{name:{first:'Nikola',last:'Tesla'},dob:{day:10,month:'July',year:1856}}").getValue(context);
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+[source,kotlin,indent=0,subs="verbatim",role="secondary"]
 .Kotlin
 ----
 	// evaluates to a Java map containing the two entries
@@ -965,10 +967,11 @@ following example shows how to do so:
 	val mapOfMaps = parser.parseExpression("{name:{first:'Nikola',last:'Tesla'},dob:{day:10,month:'July',year:1856}}").getValue(context) as Map<*, *>	
 ----

-`{:}` by itself means an empty map. For performance reasons, if the map is itself composed
-of fixed literals or other nested constant structures (lists or maps), a constant map is created
-to represent the expression (rather than building a new map on each evaluation). Quoting of the map keys
-is optional. The examples above do not use quoted keys.
+`{:}` by itself means an empty map. For performance reasons, if the map is itself
+composed of fixed literals or other nested constant structures (lists or maps), a
+constant map is created to represent the expression (rather than building a new map on
+each evaluation). Quoting of the map keys is optional (unless the key contains a period
+(`.`)). The examples above do not use quoted keys.



@@ -1001,8 +1004,7 @@ to have the array populated at construction time. The following example shows ho
 	val numbers3 = parser.parseExpression("new int[4][5]").getValue(context) as Array<IntArray>
 ----

-You cannot currently supply an initializer when you construct
-multi-dimensional array.
+You cannot currently supply an initializer when you construct a multi-dimensional array.



@@ -1050,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
@@ -1064,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
@@ -1076,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]
@@ -1103,7 +1112,7 @@ expression-based `matches` operator. The following listing shows examples of bot
 	boolean trueValue = parser.parseExpression(
 			"'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

-	//evaluates to false
+	// evaluates to false
 	boolean falseValue = parser.parseExpression(
 			"'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);
 ----
@@ -1118,14 +1127,14 @@ expression-based `matches` operator. The following listing shows examples of bot
 	val trueValue = parser.parseExpression(
 			"'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean::class.java)

-	//evaluates to false
+	// evaluates to false
 	val falseValue = parser.parseExpression(
 			"'5.0067' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean::class.java)
 ----

-CAUTION: Be careful with primitive types, as they are immediately boxed up to the wrapper type,
-so `1 instanceof T(int)` evaluates to `false` while `1 instanceof T(Integer)`
-evaluates to `true`, as expected.
+CAUTION: Be careful with primitive types, as they are immediately boxed up to their
+wrapper types. For example, `1 instanceof T(int)` evaluates to `false`, while
+`1 instanceof T(Integer)` evaluates to `true`, as expected.

 Each symbolic operator can also be specified as a purely alphabetic equivalent. This
 avoids problems where the symbols used have special meaning for the document type in
@@ -1153,7 +1162,7 @@ SpEL supports the following logical operators:
 * `or` (`||`)
 * `not` (`!`)

-The following example shows how to use the logical operators
+The following example shows how to use the logical operators:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1220,10 +1229,11 @@ The following example shows how to use the logical operators
 [[expressions-operators-mathematical]]
 ==== Mathematical Operators

-You can use the addition operator on both numbers and strings. You can use the subtraction, multiplication,
-and division operators only on numbers. You can also use
-the modulus (%) and exponential power (^) operators. Standard operator precedence is enforced. The
-following example shows the mathematical operators in use:
+You can use the addition operator (`+`) on both numbers and strings. You can use the
+subtraction (`-`), multiplication (`*`), and division (`/`) operators only on numbers.
+You can also use the modulus (`%`) and exponential power (`^`) operators on numbers.
+Standard operator precedence is enforced. The following example shows the mathematical
+operators in use:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1294,9 +1304,9 @@ following example shows the mathematical operators in use:
 [[expressions-assignment]]
 ==== The Assignment Operator

-To setting a property, use the assignment operator (`=`). This is typically
-done within a call to `setValue` but can also be done inside a call to `getValue`. The
-following listing shows both ways to use the assignment operator:
+To set a property, use the assignment operator (`=`). This is typically done within a
+call to `setValue` but can also be done inside a call to `getValue`. The following
+listing shows both ways to use the assignment operator:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1331,9 +1341,9 @@ You can use the special `T` operator to specify an instance of `java.lang.Class`
 type). Static methods are invoked by using this operator as well. The
 `StandardEvaluationContext` uses a `TypeLocator` to find types, and the
 `StandardTypeLocator` (which can be replaced) is built with an understanding of the
-`java.lang` package. This means that `T()` references to types within `java.lang` do not need to be
-fully qualified, but all other type references must be. The following example shows how
-to use the `T` operator:
+`java.lang` package. This means that `T()` references to types within the `java.lang`
+package do not need to be fully qualified, but all other type references must be. The
+following example shows how to use the `T` operator:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1363,9 +1373,10 @@ to use the `T` operator:
 [[expressions-constructors]]
 === Constructors

-You can invoke constructors by using the `new` operator. You should use the fully qualified class name
-for all but the primitive types (`int`, `float`, and so on) and String. The following
-example shows how to use the `new` operator to invoke constructors:
+You can invoke constructors by using the `new` operator. You should use the fully
+qualified class name for all types except those located in the `java.lang` package
+(`Integer`, `Float`, `String`, and so on). The following example shows how to use the
+`new` operator to invoke constructors:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1374,7 +1385,7 @@ example shows how to use the `new` operator to invoke constructors:
 			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor.class);

-	//create new inventor instance within add method of List
+	// create new Inventor instance within the add() method of List
 	p.parseExpression(
 			"Members.add(new org.spring.samples.spel.inventor.Inventor(
 				'Albert Einstein', 'German'))").getValue(societyContext);
@@ -1386,7 +1397,7 @@ example shows how to use the `new` operator to invoke constructors:
 			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor::class.java)

-	//create new inventor instance within add method of List
+	// create new Inventor instance within the add() method of List
 	p.parseExpression(
 			"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
 			.getValue(societyContext)
@@ -1673,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:

@@ -1752,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
@@ -1800,7 +1811,7 @@ Selection is a powerful expression language feature that lets you transform a
 source collection into another collection by selecting from its entries.

 Selection uses a syntax of `.?[selectionExpression]`. It filters the collection and
-returns a new collection that contain a subset of the original elements. For example,
+returns a new collection that contains a subset of the original elements. For example,
 selection lets us easily get a list of Serbian inventors, as the following example shows:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
@@ -1816,14 +1827,14 @@ selection lets us easily get a list of Serbian inventors, as the following examp
 			"members.?[nationality == 'Serbian']").getValue(societyContext) as List<Inventor>
 ----

-Selection is possible upon both lists and maps. For a list, the selection
-criteria is evaluated against each individual list element. Against a map, the
-selection criteria is evaluated against each map entry (objects of the Java type
-`Map.Entry`). Each map entry has its key and value accessible as properties for use in
-the selection.
+Selection is supported for arrays and anything that implements `java.lang.Iterable` or
+`java.util.Map`. For a list or array, the selection criteria is evaluated against each
+individual element. Against a map, the selection criteria is evaluated against each map
+entry (objects of the Java type `Map.Entry`). Each map entry has its `key` and `value`
+accessible as properties for use in the selection.

-The following expression returns a new map that consists of those elements of the original map
-where the entry value is less than 27:
+The following expression returns a new map that consists of those elements of the
+original map where the entry's value is less than 27:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1836,9 +1847,8 @@ where the entry value is less than 27:
 	val newMap = parser.parseExpression("map.?[value<27]").getValue()
 ----

-
-In addition to returning all the selected elements, you can retrieve only the
-first or the last value. To obtain the first entry matching the selection, the syntax is
+In addition to returning all the selected elements, you can retrieve only the first or
+the last element. To obtain the first element matching the selection, the syntax is
 `.^[selectionExpression]`. To obtain the last matching selection, the syntax is
 `.$[selectionExpression]`.

@@ -1847,11 +1857,11 @@ first or the last value. To obtain the first entry matching the selection, the s
 [[expressions-collection-projection]]
 === Collection Projection

-Projection lets a collection drive the evaluation of a sub-expression, and the
-result is a new collection. The syntax for projection is `.![projectionExpression]`. For
-example, suppose we have a list of inventors but want the list of
-cities where they were born. Effectively, we want to evaluate 'placeOfBirth.city' for
-every entry in the inventor list. The following example uses projection to do so:
+Projection lets a collection drive the evaluation of a sub-expression, and the result is
+a new collection. The syntax for projection is `.![projectionExpression]`. For example,
+suppose we have a list of inventors but want the list of cities where they were born.
+Effectively, we want to evaluate 'placeOfBirth.city' for every entry in the inventor
+list. The following example uses projection to do so:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1866,7 +1876,8 @@ every entry in the inventor list. The following example uses projection to do so
 	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]") as List<*>
 ----

-You can also use a map to drive projection and, in this case, the projection expression is
+Projection is supported for arrays and anything that implements `java.lang.Iterable` or
+`java.util.Map`. When using a map to drive projection, the projection expression is
 evaluated against each entry in the map (represented as a Java `Map.Entry`). The result
 of a projection across a map is a list that consists of the evaluation of the projection
 expression against each map entry.
@@ -8,6 +8,7 @@ Spring. It includes the following topics:
 * <<resources-resource>>
 * <<resources-implementations>>
 * <<resources-resourceloader>>
+* <<resources-resourcepatternresolver>>
 * <<resources-resourceloaderaware>>
 * <<resources-as-dependencies>>
 * <<resources-app-ctx>>
@@ -31,25 +32,38 @@ such as a method to check for the existence of the resource being pointed to.


 [[resources-resource]]
-== The Resource Interface
+== The `Resource` Interface

-Spring's `Resource` interface is meant to be a more capable interface for abstracting
-access to low-level resources. The following listing shows the `Resource` interface
-definition:
+Spring's `Resource` interface located in the `org.springframework.core.io.` package is
+meant to be a more capable interface for abstracting access to low-level resources. The
+following listing provides an overview of the `Resource` interface. See the
+{api-spring-framework}/core/io/Resource.html[`Resource`] javadoc for further details.

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	public interface Resource extends InputStreamSource {

 		boolean exists();

+		boolean isReadable();
+
 		boolean isOpen();

+		boolean isFile();
+
 		URL getURL() throws IOException;

+		URI getURI() throws IOException;
+
 		File getFile() throws IOException;

+		ReadableByteChannel readableChannel() throws IOException;
+
+		long contentLength() throws IOException;
+
+		long lastModified() throws IOException;
+
 		Resource createRelative(String relativePath) throws IOException;

 		String getFilename();
@@ -57,48 +71,18 @@ definition:
 		String getDescription();
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface Resource : InputStreamSource {
-
-		fun exists(): Boolean
-
-		val isOpen: Boolean
-
-		val url: URL
-
-		val file: File
-
-		@Throws(IOException::class)
-		fun createRelative(relativePath: String): Resource
-
-		val filename: String
-
-		val description: String
-	}
----

 As the definition of the `Resource` interface shows, it extends the `InputStreamSource`
 interface. The following listing shows the definition of the `InputStreamSource`
 interface:

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

 		InputStream getInputStream() throws IOException;
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface InputStreamSource {
-
-		val inputStream: InputStream
-	}
----

 Some of the most important methods from the `Resource` interface are:

@@ -119,6 +103,10 @@ Other methods let you obtain an actual `URL` or `File` object representing the
 resource (if the underlying implementation is compatible and supports that
 functionality).

+Some implementations of the `Resource` interface also implement the extended
+{api-spring-framework}/core/io/WritableResource.html[`WritableResource`] interface
+for a resource that supports writing to it.
+
 Spring itself uses the `Resource` abstraction extensively, as an argument type in
 many method signatures when a resource is needed. Other methods in some Spring APIs
 (such as the constructors to various `ApplicationContext` implementations) take a
@@ -127,51 +115,55 @@ that context implementation or, via special prefixes on the `String` path, let t
 caller specify that a specific `Resource` implementation must be created and used.

 While the `Resource` interface is used a lot with Spring and by Spring, it is actually
-very useful to use as a general utility class by itself in your own code, for access to
-resources, even when your code does not know or care about any other parts of Spring.
+very convenient to use as a general utility class by itself in your own code, for access
+to resources, even when your code does not know or care about any other parts of Spring.
 While this couples your code to Spring, it really only couples it to this small set of
-utility classes, which serve as a more capable replacement for `URL` and can be
+utility classes, which serves as a more capable replacement for `URL` and can be
 considered equivalent to any other library you would use for this purpose.

-NOTE: The `Resource` abstraction does not replace functionality.
-It wraps it where possible. For example, a `UrlResource` wraps a URL and uses the
-wrapped `URL` to do its work.
+NOTE: The `Resource` abstraction does not replace functionality. It wraps it where
+possible. For example, a `UrlResource` wraps a URL and uses the wrapped `URL` to do its
+work.




 [[resources-implementations]]
-== Built-in Resource Implementations
+== Built-in `Resource` Implementations

-Spring includes the following `Resource` implementations:
+Spring includes several built-in `Resource` implementations:

 * <<resources-implementations-urlresource>>
 * <<resources-implementations-classpathresource>>
 * <<resources-implementations-filesystemresource>>
+* <<resources-implementations-pathresource>>
 * <<resources-implementations-servletcontextresource>>
 * <<resources-implementations-inputstreamresource>>
 * <<resources-implementations-bytearrayresource>>

+For a complete list of `Resource` implementations available in Spring, consult the
+"All Known Implementing Classes" section of the
+{api-spring-framework}/core/io/Resource.html[`Resource`] javadoc.
+


 [[resources-implementations-urlresource]]
 === `UrlResource`

 `UrlResource` wraps a `java.net.URL` and can be used to access any object that is
-normally accessible with a URL, such as files, an HTTP target, an FTP target, and others. All
-URLs have a standardized `String` representation, such that appropriate standardized
-prefixes are used to indicate one URL type from another. This includes `file:` for
-accessing filesystem paths, `http:` for accessing resources through the HTTP protocol,
-`ftp:` for accessing resources through FTP, and others.
+normally accessible with a URL, such as files, an HTTPS target, an FTP target, and
+others. All URLs have a standardized `String` representation, such that appropriate
+standardized prefixes are used to indicate one URL type from another. This includes
+`file:` for accessing filesystem paths, `https:` for accessing resources through the
+HTTPS protocol, `ftp:` for accessing resources through FTP, and others.

 A `UrlResource` is created by Java code by explicitly using the `UrlResource` constructor
 but is often created implicitly when you call an API method that takes a `String`
-argument meant to represent a path. For the latter case, a JavaBeans
-`PropertyEditor` ultimately decides which type of `Resource` to create. If the path
-string contains well-known (to it, that is) prefix (such as `classpath:`), it
-creates an appropriate specialized `Resource` for that prefix. However, if it does not
-recognize the prefix, it assume the string is a standard URL string and
-creates a `UrlResource`.
+argument meant to represent a path. For the latter case, a JavaBeans `PropertyEditor`
+ultimately decides which type of `Resource` to create. If the path string contains a
+well-known (to property editor, that is) prefix (such as `classpath:`), it creates an
+appropriate specialized `Resource` for that prefix. However, if it does not recognize the
+prefix, it assumes the string is a standard URL string and creates a `UrlResource`.



@@ -182,7 +174,7 @@ This class represents a resource that should be obtained from the classpath. It
 either the thread context class loader, a given class loader, or a given class for
 loading resources.

-This `Resource` implementation supports resolution as `java.io.File` if the class path
+This `Resource` implementation supports resolution as a `java.io.File` if the class path
 resource resides in the file system but not for classpath resources that reside in a
 jar and have not been expanded (by the servlet engine or whatever the environment is)
 to the filesystem. To address this, the various `Resource` implementations always support
@@ -199,8 +191,22 @@ creates a `ClassPathResource` in that case.
 [[resources-implementations-filesystemresource]]
 === `FileSystemResource`

-This is a `Resource` implementation for `java.io.File` and `java.nio.file.Path` handles.
-It supports resolution as a `File` and as a `URL`.
+This is a `Resource` implementation for `java.io.File` handles. It also supports
+`java.nio.file.Path` handles, applying Spring's standard String-based path
+transformations but performing all operations via the `java.nio.file.Files` API. For pure
+`java.nio.path.Path` based support use a `PathResource` instead. `FileSystemResource`
+supports resolution as a `File` and as a `URL`.
+
+
+
+[[resources-implementations-pathresource]]
+=== `PathResource`
+
+This is a `Resource` implementation for `java.nio.file.Path` handles, performing all
+operations and transformations via the `Path` API. It supports resolution as a `File` and
+as a `URL` and also implements the extended `WritableResource` interface. `PathResource`
+is effectively a pure `java.nio.path.Path` based alternative to `FileSystemResource` with
+different `createRelative` behavior.



@@ -221,14 +227,15 @@ dependent on the Servlet container.
 [[resources-implementations-inputstreamresource]]
 === `InputStreamResource`

-An `InputStreamResource` is a `Resource` implementation for a given `InputStream`. It should be used only if no
-specific `Resource` implementation is applicable. In particular, prefer
-`ByteArrayResource` or any of the file-based `Resource` implementations where possible.
+An `InputStreamResource` is a `Resource` implementation for a given `InputStream`. It
+should be used only if no specific `Resource` implementation is applicable. In
+particular, prefer `ByteArrayResource` or any of the file-based `Resource`
+implementations where possible.

-In contrast to other `Resource` implementations, this is a descriptor for an already-opened
-resource. Therefore, it returns `true` from `isOpen()`. Do not use it if you need
-to keep the resource descriptor somewhere or if you need to read a stream multiple
-times.
+In contrast to other `Resource` implementations, this is a descriptor for an
+already-opened resource. Therefore, it returns `true` from `isOpen()`. Do not use it if
+you need to keep the resource descriptor somewhere or if you need to read a stream
+multiple times.



@@ -243,28 +250,22 @@ single-use `InputStreamResource`.



+
 [[resources-resourceloader]]
-== The `ResourceLoader`
+== The `ResourceLoader` Interface

 The `ResourceLoader` interface is meant to be implemented by objects that can return
 (that is, load) `Resource` instances. The following listing shows the `ResourceLoader`
 interface definition:

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

 		Resource getResource(String location);
-	}
----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-interface ResourceLoader {

-	fun getResource(location: String): Resource
-}
+		ClassLoader getClassLoader();
+	}
 ----

 All application contexts implement the `ResourceLoader` interface. Therefore, all
@@ -286,9 +287,9 @@ snippet of code was run against a `ClassPathXmlApplicationContext` instance:
 	val template = ctx.getResource("some/resource/path/myTemplate.txt")
 ----

-Against a `ClassPathXmlApplicationContext`, that code returns a `ClassPathResource`. If the same method were run
-against a `FileSystemXmlApplicationContext` instance, it would return a
-`FileSystemResource`. For a `WebApplicationContext`, it would return a
+Against a `ClassPathXmlApplicationContext`, that code returns a `ClassPathResource`. If
+the same method were run against a `FileSystemXmlApplicationContext` instance, it would
+return a `FileSystemResource`. For a `WebApplicationContext`, it would return a
 `ServletContextResource`. It would similarly return appropriate objects for each context.

 As a result, you can load resources in a fashion appropriate to the particular application
@@ -310,8 +311,7 @@ example shows:
 ----

 Similarly, you can force a `UrlResource` to be used by specifying any of the standard
-`java.net.URL` prefixes. The following pair of examples use the `file` and `http`
-prefixes:
+`java.net.URL` prefixes. The following examples use the `file` and `https` prefixes:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -335,7 +335,8 @@ prefixes:
 	val template = ctx.getResource("https://myhost.com/resource/path/myTemplate.txt")
 ----

-The following table summarizes the strategy for converting `String` objects to `Resource` objects:
+The following table summarizes the strategy for converting `String` objects to `Resource`
+objects:

 [[resources-resource-strings]]
 .Resource strings
@@ -347,11 +348,11 @@ The following table summarizes the strategy for converting `String` objects to `
 | Loaded from the classpath.

 | file:
-| `file:///data/config.xml`
+| `\file:///data/config.xml`
 | Loaded as a `URL` from the filesystem. See also <<resources-filesystemresource-caveats>>.

-| http:
-| `https://myserver/logo.png`
+| https:
+| `\https://myserver/logo.png`
 | Loaded as a `URL`.

 | (none)
@@ -362,29 +363,71 @@ The following table summarizes the strategy for converting `String` objects to `



+[[resources-resourcepatternresolver]]
+== The `ResourcePatternResolver` Interface
+
+The `ResourcePatternResolver` interface is an extension to the `ResourceLoader` interface
+which defines a strategy for resolving a location pattern (for example, an Ant-style path
+pattern) into  `Resource` objects.
+
+[source,java,indent=0,subs="verbatim,quotes"]
+----
+	public interface ResourcePatternResolver extends ResourceLoader {
+
+		String CLASSPATH_ALL_URL_PREFIX = "classpath*:";
+
+		Resource[] getResources(String locationPattern) throws IOException;
+	}
+----
+
+As can be seen above, this interface also defines a special `classpath*:` resource prefix
+for all matching resources from the class path. Note that the resource location is
+expected to be a path without placeholders in this case -- for example,
+`classpath*:/config/beans.xml`. JAR files or different directories in the class path can
+contain multiple files with the same path and the same name. See
+<<resources-app-ctx-wildcards-in-resource-paths>> and its subsections for further details
+on wildcard support with the `classpath*:` resource prefix.
+
+A passed-in `ResourceLoader` (for example, one supplied via
+<<resources-resourceloaderaware,`ResourceLoaderAware`>> semantics) can be checked whether
+it implements this extended interface too.
+
+`PathMatchingResourcePatternResolver` is a standalone implementation that is usable
+outside an `ApplicationContext` and is also used by `ResourceArrayPropertyEditor` for
+populating `Resource[]` bean properties. `PathMatchingResourcePatternResolver` is able to
+resolve a specified resource location path into one or more matching `Resource` objects.
+The source path may be a simple path which has a one-to-one mapping to a target
+`Resource`, or alternatively may contain the special `classpath*:` prefix and/or internal
+Ant-style regular expressions (matched using Spring's
+`org.springframework.util.AntPathMatcher` utility). Both of the latter are effectively
+wildcards.
+
+[NOTE]
+====
+The default `ResourceLoader` in any standard `ApplicationContext` is in fact an instance
+of `PathMatchingResourcePatternResolver` which implements the `ResourcePatternResolver`
+interface. The same is true for the `ApplicationContext` instance itself which also
+implements the `ResourcePatternResolver` interface and delegates to the default
+`PathMatchingResourcePatternResolver`.
+====
+
+
+
+
 [[resources-resourceloaderaware]]
-== The `ResourceLoaderAware` interface
+== The `ResourceLoaderAware` Interface

 The `ResourceLoaderAware` interface is a special callback interface which identifies
-components that expect to be provided with a `ResourceLoader` reference. The following
-listing shows the definition of the `ResourceLoaderAware` interface:
+components that expect to be provided a `ResourceLoader` reference. The following listing
+shows the definition of the `ResourceLoaderAware` interface:

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

 		void setResourceLoader(ResourceLoader resourceLoader);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface ResourceLoaderAware {
-
-		fun setResourceLoader(resourceLoader: ResourceLoader)
-	}
----

 When a class implements `ResourceLoaderAware` and is deployed into an application context
 (as a Spring-managed bean), it is recognized as `ResourceLoaderAware` by the application
@@ -400,7 +443,7 @@ interface (which can be considered a utility interface) and not to the whole Spr
 `ApplicationContext` interface.

 In application components, you may also rely upon autowiring of the `ResourceLoader` as
-an alternative to implementing the `ResourceLoaderAware` interface. The "`traditional`"
+an alternative to implementing the `ResourceLoaderAware` interface. The _traditional_
 `constructor` and `byType` autowiring modes (as described in <<beans-factory-autowire>>)
 are capable of providing a `ResourceLoader` for either a constructor argument or a
 setter method parameter, respectively. For more flexibility (including the ability to
@@ -410,6 +453,11 @@ constructor argument, or method parameter that expects the `ResourceLoader` type
 as the field, constructor, or method in question carries the `@Autowired` annotation.
 For more information, see <<beans-autowired-annotation>>.

+NOTE: To load one or more `Resource` objects for a resource path that contains wildcards
+or makes use of the special `classpath*:` resource prefix, consider having an instance of
+<<resources-resourcepatternresolver,`ResourcePatternResolver`>> autowired into your
+application components instead of `ResourceLoader`.
+



@@ -417,33 +465,58 @@ For more information, see <<beans-autowired-annotation>>.
 == Resources as Dependencies

 If the bean itself is going to determine and supply the resource path through some sort
-of dynamic process, it probably makes sense for the bean to use the `ResourceLoader`
-interface to load resources. For example, consider the loading of a template of some
-sort, where the specific resource that is needed depends on the role of the user. If the
-resources are static, it makes sense to eliminate the use of the `ResourceLoader`
-interface completely, have the bean expose the `Resource` properties it needs,
-and expect them to be injected into it.
+of dynamic process, it probably makes sense for the bean to use the `ResourceLoader` or
+`ResourcePatternResolver` interface to load resources. For example, consider the loading
+of a template of some sort, where the specific resource that is needed depends on the
+role of the user. If the resources are static, it makes sense to eliminate the use of the
+`ResourceLoader` interface (or `ResourcePatternResolver` interface) completely, have the
+bean expose the `Resource` properties it needs, and expect them to be injected into it.

 What makes it trivial to then inject these properties is that all application contexts
 register and use a special JavaBeans `PropertyEditor`, which can convert `String` paths
-to `Resource` objects. So, if `myBean` has a template property of type `Resource`, it can
-be configured with a simple string for that resource, as the following example shows:
+to `Resource` objects. For example, the following `MyBean` class has a `template`
+property of type `Resource`.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	package example;
+
+	public class MyBean {
+
+		private Resource template;
+
+		public setTemplate(Resource template) {
+			this.template = template;
+		}
+
+		// ...
+	}
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	class MyBean(var template: Resource)
+----
+
+In an XML configuration file, the `template` property can be configured with a simple
+string for that resource, as the following example shows:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
-	<bean id="myBean" class="...">
+	<bean id="myBean" class="example.MyBean">
 		<property name="template" value="some/resource/path/myTemplate.txt"/>
 	</bean>
 ----

-Note that the resource path has no prefix. Consequently, because the application context itself is
-going to be used as the `ResourceLoader`, the resource itself is loaded through a
-`ClassPathResource`, a `FileSystemResource`, or a `ServletContextResource`,
-depending on the exact type of the context.
+Note that the resource path has no prefix. Consequently, because the application context
+itself is going to be used as the `ResourceLoader`, the resource is loaded through a
+`ClassPathResource`, a `FileSystemResource`, or a `ServletContextResource`, depending on
+the exact type of the application context.

-If you need to force a specific `Resource` type to be used, you can use a prefix.
-The following two examples show how to force a `ClassPathResource` and a
-`UrlResource` (the latter being used to access a filesystem file):
+If you need to force a specific `Resource` type to be used, you can use a prefix. The
+following two examples show how to force a `ClassPathResource` and a `UrlResource` (the
+latter being used to access a file in the filesystem):

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -455,6 +528,66 @@ The following two examples show how to force a `ClassPathResource` and a
 	<property name="template" value="file:///some/resource/path/myTemplate.txt"/>
 ----

+If the `MyBean` class is refactored for use with annotation-driven configuration, the
+path to `myTemplate.txt` can be stored under a key named `template.path` -- for example,
+in a properties file made available to the Spring `Environment` (see
+<<beans-environment>>). The template path can then be referenced via the `@Value`
+annotation using a property placeholder (see <<beans-value-annotations>>). Spring will
+retrieve the value of the template path as a string, and a special `PropertyEditor` will
+convert the string to a `Resource` object to be injected into the `MyBean` constructor.
+The following example demonstrates how to achieve this.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	@Component
+	public class MyBean {
+
+		private final Resource template;
+
+		public MyBean(@Value("${template.path}") Resource template) {
+			this.template = template;
+		}
+
+		// ...
+	}
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	@Component
+	class MyBean(@Value("\${template.path}") private val template: Resource)
+----
+
+If we want to support multiple templates discovered under the same path in multiple
+locations in the classpath -- for example, in multiple jars in the classpath -- we can
+use the special `classpath*:` prefix and wildcarding to define a `templates.path` key as
+`classpath*:/config/templates/*.txt`. If we redefine the `MyBean` class as follows,
+Spring will convert the template path pattern into an array of `Resource` objects that
+can be injected into the `MyBean` constructor.
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	@Component
+	public class MyBean {
+
+		private final Resource[] templates;
+
+		public MyBean(@Value("${templates.path}") Resource[] templates) {
+			this.templates = templates;
+		}
+
+		// ...
+	}
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	@Component
+	class MyBean(@Value("\${templates.path}") private val templates: Resource[])
+----
+



@@ -504,12 +637,12 @@ used. However, consider the following example, which creates a `FileSystemXmlApp
 	val ctx = FileSystemXmlApplicationContext("conf/appContext.xml")
 ----

-Now the bean definition is loaded from a filesystem location (in this case, relative to
+Now the bean definitions are loaded from a filesystem location (in this case, relative to
 the current working directory).

-Note that the use of the special classpath prefix or a standard URL prefix on the
-location path overrides the default type of `Resource` created to load the
-definition. Consider the following example:
+Note that the use of the special `classpath` prefix or a standard URL prefix on the
+location path overrides the default type of `Resource` created to load the bean
+definitions. Consider the following example:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -523,9 +656,9 @@ definition. Consider the following example:
 	val ctx = FileSystemXmlApplicationContext("classpath:conf/appContext.xml")
 ----

-Using `FileSystemXmlApplicationContext` loads the bean definitions from the classpath. However, it is still a
-`FileSystemXmlApplicationContext`. If it is subsequently used as a `ResourceLoader`, any
-unprefixed paths are still treated as filesystem paths.
+Using `FileSystemXmlApplicationContext` loads the bean definitions from the classpath.
+However, it is still a `FileSystemXmlApplicationContext`. If it is subsequently used as a
+`ResourceLoader`, any unprefixed paths are still treated as filesystem paths.


 [[resources-app-ctx-classpathxml]]
@@ -534,33 +667,34 @@ unprefixed paths are still treated as filesystem paths.
 The `ClassPathXmlApplicationContext` exposes a number of constructors to enable
 convenient instantiation. The basic idea is that you can supply merely a string array
 that contains only the filenames of the XML files themselves (without the leading path
-information) and also supplies a `Class`. The `ClassPathXmlApplicationContext`
-then derives the path information from the supplied class.
+information) and also supply a `Class`. The `ClassPathXmlApplicationContext` then derives
+the path information from the supplied class.

 Consider the following directory layout:

 [literal,subs="verbatim,quotes"]
 ----
 com/
-  foo/
+  example/
    services.xml
-    daos.xml
+    repositories.xml
    MessengerService.class
 ----

-The following example shows how a `ClassPathXmlApplicationContext` instance composed of the beans defined in
-files named `services.xml` and `daos.xml` (which are on the classpath) can be instantiated:
+The following example shows how a `ClassPathXmlApplicationContext` instance composed of
+the beans defined in files named `services.xml` and `repositories.xml` (which are on the
+classpath) can be instantiated:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
 	ApplicationContext ctx = new ClassPathXmlApplicationContext(
-		new String[] {"services.xml", "daos.xml"}, MessengerService.class);
+		new String[] {"services.xml", "repositories.xml"}, MessengerService.class);
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	val ctx = ClassPathXmlApplicationContext(arrayOf("services.xml", "daos.xml"), MessengerService::class.java)
+	val ctx = ClassPathXmlApplicationContext(arrayOf("services.xml", "repositories.xml"), MessengerService::class.java)
 ----

 See the {api-spring-framework}/context/support/ClassPathXmlApplicationContext.html[`ClassPathXmlApplicationContext`]
@@ -572,13 +706,13 @@ javadoc for details on the various constructors.
 === Wildcards in Application Context Constructor Resource Paths

 The resource paths in application context constructor values may be simple paths (as
-shown earlier), each of which has a one-to-one mapping to a target `Resource` or, alternately, may
-contain the special "classpath*:" prefix or internal Ant-style regular expressions
+shown earlier), each of which has a one-to-one mapping to a target `Resource` or,
+alternately, may contain the special `classpath*:` prefix or internal Ant-style patterns
 (matched by using Spring's `PathMatcher` utility). Both of the latter are effectively
 wildcards.

 One use for this mechanism is when you need to do component-style application assembly. All
-components can 'publish' context definition fragments to a well-known location path, and,
+components can _publish_ context definition fragments to a well-known location path, and,
 when the final application context is created using the same path prefixed with
 `classpath*:`, all component fragments are automatically picked up.

@@ -602,23 +736,23 @@ file:C:/some/path/\*-context.xml
 classpath:com/mycompany/**/applicationContext.xml
 ----

-When the path location contains an Ant-style pattern, the resolver follows a more complex procedure to try to resolve the
-wildcard. It produces a `Resource` for the path up to the last non-wildcard segment and
-obtains a URL from it. If this URL is not a `jar:` URL or container-specific variant
-(such as `zip:` in WebLogic, `wsjar` in WebSphere, and so on), a `java.io.File` is
-obtained from it and used to resolve the wildcard by traversing the filesystem. In the
-case of a jar URL, the resolver either gets a `java.net.JarURLConnection` from it or
-manually parses the jar URL and then traverses the contents of the jar file to resolve
-the wildcards.
+When the path location contains an Ant-style pattern, the resolver follows a more complex
+procedure to try to resolve the wildcard. It produces a `Resource` for the path up to the
+last non-wildcard segment and obtains a URL from it. If this URL is not a `jar:` URL or
+container-specific variant (such as `zip:` in WebLogic, `wsjar` in WebSphere, and so on),
+a `java.io.File` is obtained from it and used to resolve the wildcard by traversing the
+filesystem. In the case of a jar URL, the resolver either gets a
+`java.net.JarURLConnection` from it or manually parses the jar URL and then traverses the
+contents of the jar file to resolve the wildcards.

 [[resources-app-ctx-portability]]
 ===== Implications on Portability

-If the specified path is already a file URL (either implicitly because the base
+If the specified path is already a `file` URL (either implicitly because the base
 `ResourceLoader` is a filesystem one or explicitly), wildcarding is guaranteed to
 work in a completely portable fashion.

-If the specified path is a classpath location, the resolver must obtain the last
+If the specified path is a `classpath` location, the resolver must obtain the last
 non-wildcard path segment URL by making a `Classloader.getResource()` call. Since this
 is just a node of the path (not the file at the end), it is actually undefined (in the
 `ClassLoader` javadoc) exactly what sort of a URL is returned in this case. In practice,
@@ -657,14 +791,15 @@ must be obtained (internally, this essentially happens through a call to
 context definition.

 NOTE: The wildcard classpath relies on the `getResources()` method of the underlying
-classloader. As most application servers nowadays supply their own classloader
+`ClassLoader`. As most application servers nowadays supply their own `ClassLoader`
 implementation, the behavior might differ, especially when dealing with jar files. A
-simple test to check if `classpath*` works is to use the classloader to load a file from
+simple test to check if `classpath*` works is to use the `ClassLoader` to load a file from
 within a jar on the classpath:
 `getClass().getClassLoader().getResources("<someFileInsideTheJar>")`. Try this test with
-files that have the same name but are placed inside two different locations. In case an
-inappropriate result is returned, check the application server documentation for
-settings that might affect the classloader behavior.
+files that have the same name but reside in two different locations -- for example, files
+with the same name and same path but in different jars on the classpath. In case an
+inappropriate result is returned, check the application server documentation for settings
+that might affect the `ClassLoader` behavior.

 You can also combine the `classpath*:` prefix with a `PathMatcher` pattern in the
 rest of the location path (for example, `classpath*:META-INF/*-beans.xml`). In this
@@ -692,7 +827,7 @@ as well, but this is not guaranteed to lead to portable behavior.
 [NOTE]
 ====
 The scanning of classpath packages requires the presence of corresponding directory
-entries in the classpath. When you build JARs with Ant, do not activate the files-only
+entries in the classpath. When you build JARs with Ant, do not activate the `files-only`
 switch of the JAR task. Also, classpath directories may not get exposed based on security
 policies in some environments -- for example, stand-alone applications on JDK 1.7.0_45
 and higher (which requires 'Trusted-Library' to be set up in your manifests. See
@@ -704,7 +839,7 @@ avoiding the aforementioned portability problems with searching the jar file roo
 ====

 Ant-style patterns with `classpath:` resources are not guaranteed to find matching
-resources if the root package to search is available in multiple class path locations.
+resources if the root package to search is available in multiple classpath locations.
 Consider the following example of a resource location:

 [literal,subs="verbatim,quotes"]
@@ -719,12 +854,13 @@ Now consider an Ant-style path that someone might use to try to find that file:
 classpath:com/mycompany/**/service-context.xml
 ----

-Such a resource may be in only one location, but when a path such as the preceding example
-is used to try to resolve it, the resolver works off the (first) URL returned by
-`getResource("com/mycompany");`. If this base package node exists in multiple
-classloader locations, the actual end resource may not be there. Therefore, in such a case
-you should prefer using `classpath*:` with the same Ant-style pattern, which
-searches all class path locations that contain the root package.
+Such a resource may exist in only one location in the classpath, but when a path such as
+the preceding example is used to try to resolve it, the resolver works off the (first)
+URL returned by `getResource("com/mycompany");`. If this base package node exists in
+multiple `ClassLoader` locations, the desired resource may not exist in the first
+location found. Therefore, in such cases you should prefer using `classpath*:` with the
+same Ant-style pattern, which searches all classpath locations that contain the
+`com.mycompany` base package: `classpath*:com/mycompany/**/service-context.xml`.



@@ -103,7 +103,7 @@ example implements `Validator` for `Person` instances:
 ----
 	class PersonValidator : Validator {

-		/**
+		/\**
 		 * This Validator validates only Person instances
 		 */
 		override fun supports(clazz: Class<*>): Boolean {
@@ -215,7 +215,7 @@ as the following example shows:
 Validation errors are reported to the `Errors` object passed to the validator. In the case
 of Spring Web MVC, you can use the `<spring:bind/>` tag to inspect the error messages, but
 you can also inspect the `Errors` object yourself. More information about the
-methods it offers can be found in the {api-spring-framework}validation/Errors.html[javadoc].
+methods it offers can be found in the {api-spring-framework}/validation/Errors.html[javadoc].



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

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

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -500,8 +500,9 @@ the various `PropertyEditor` implementations that Spring provides:

 | `LocaleEditor`
 | Can resolve strings to `Locale` objects and vice-versa (the string format is
-  `[language]_[country]_[variant]`, same as the `toString()` method of
-  `Locale`). By default, registered by `BeanWrapperImpl`.
+  `[language]\_[country]_[variant]`, same as the `toString()` method of
+  `Locale`). Also accepts spaces as separators, as an alternative to underscores.
+  By default, registered by `BeanWrapperImpl`.

 | `PatternEditor`
 | Can resolve strings to `java.util.regex.Pattern` objects and vice-versa.
@@ -541,10 +542,9 @@ com

 Note that you can also use the standard `BeanInfo` JavaBeans mechanism here as well
 (described to some extent
-https://docs.oracle.com/javase/tutorial/javabeans/advanced/customization.html[
-here]). The following example use the `BeanInfo` mechanism to
-explicitly register one or more `PropertyEditor` instances with the properties of an
-associated class:
+https://docs.oracle.com/javase/tutorial/javabeans/advanced/customization.html[here]). The
+following example uses the `BeanInfo` mechanism to explicitly register one or more
+`PropertyEditor` instances with the properties of an associated class:

 [literal,subs="verbatim,quotes"]
 ----
@@ -567,9 +567,10 @@ associates a `CustomNumberEditor` with the `age` property of the `Something` cla
 			try {
 				final PropertyEditor numberPE = new CustomNumberEditor(Integer.class, true);
 				PropertyDescriptor ageDescriptor = new PropertyDescriptor("age", Something.class) {
+					@Override
 					public PropertyEditor createPropertyEditor(Object bean) {
 						return numberPE;
-					};
+					}
 				};
 				return new PropertyDescriptor[] { ageDescriptor };
 			}
@@ -625,10 +626,10 @@ nested property setup, so we strongly recommend that you use it with the
 where it can be automatically detected and applied.

 Note that all bean factories and application contexts automatically use a number of
-built-in property editors, through their use a `BeanWrapper` to
+built-in property editors, through their use of a `BeanWrapper` to
 handle property conversions. The standard property editors that the `BeanWrapper`
 registers are listed in the <<beans-beans-conversion, previous section>>.
-Additionally, `ApplicationContexts` also override or add additional editors to handle
+Additionally, ``ApplicationContext``s also override or add additional editors to handle
 resource lookups in a manner appropriate to the specific application context type.

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

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

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

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

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

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

 		private final PropertyEditorRegistrar customPropertyEditorRegistrar;

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

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

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

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

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

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



@@ -874,8 +876,7 @@ application where type conversion is needed.
 The SPI to implement type conversion logic is simple and strongly typed, as the following
 interface definition shows:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.core.convert.converter;

@@ -884,16 +885,6 @@ interface definition shows:
 		T convert(S source);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.core.convert.converter
-
-	interface Converter<S, T> {
-
-		fun convert(source: S): T
-	}
----

 To create your own converter, implement the `Converter` interface and parameterize `S`
 as the type you are converting from and `T` as the type you are converting to. You can also transparently apply such a
@@ -910,8 +901,7 @@ Several converter implementations are provided in the `core.convert.support` pac
 a convenience. These include converters from strings to numbers and other common types.
 The following listing shows the `StringToInteger` class, which is a typical `Converter` implementation:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.core.convert.support;

@@ -922,20 +912,6 @@ The following listing shows the `StringToInteger` class, which is a typical `Con
 		}
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.core.convert.support
-
-	import org.springframework.core.convert.converter.Converter
-
-	internal class StringToInteger : Converter<String, Int> {
-
-		override fun convert(source: String): Int? {
-			return Integer.valueOf(source)
-		}
-	}
----



@@ -946,8 +922,7 @@ When you need to centralize the conversion logic for an entire class hierarchy
 (for example, when converting from `String` to `Enum` objects), you can implement
 `ConverterFactory`, as the following example shows:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.core.convert.converter;

@@ -956,16 +931,6 @@ When you need to centralize the conversion logic for an entire class hierarchy
 		<T extends R> Converter<S, T> getConverter(Class<T> targetType);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.core.convert.converter
-
-	interface ConverterFactory<S, R> {
-
-		fun <T : R> getConverter(targetType: Class<T>): Converter<S, T>
-	}
----

 Parameterize S to be the type you are converting from and R to be the base type defining
 the __range__ of classes you can convert to. Then implement `getConverter(Class<T>)`,
@@ -974,7 +939,6 @@ where T is a subclass of R.
 Consider the `StringToEnumConverterFactory` as an example:

 [source,java,indent=0,subs="verbatim,quotes"]
-.Java
 ----
 	package org.springframework.core.convert.support;

@@ -1011,8 +975,7 @@ context that you can use when you implement your conversion logic. Such context
 type conversion be driven by a field annotation or by generic information declared on a
 field signature. The following listing shows the interface definition of `GenericConverter`:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.core.convert.converter;

@@ -1023,18 +986,6 @@ field signature. The following listing shows the interface definition of `Generi
 		Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.core.convert.converter
-
-	interface GenericConverter {
-
-		fun getConvertibleTypes(): Set<ConvertiblePair>?
-
-		fun convert(@Nullable source: Any?, sourceType: TypeDescriptor, targetType: TypeDescriptor): Any?
-	}
----

 To implement a `GenericConverter`, have `getConvertibleTypes()` return the supported
 source->target type pairs. Then implement `convert(Object, TypeDescriptor,
@@ -1063,8 +1014,7 @@ on the target field, or you might want to run a `Converter` only if a specific m
 `ConditionalGenericConverter` is the union of the `GenericConverter` and
 `ConditionalConverter` interfaces that lets you define such custom matching criteria:

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

@@ -1074,19 +1024,9 @@ on the target field, or you might want to run a `Converter` only if a specific m
 	public interface ConditionalGenericConverter extends GenericConverter, ConditionalConverter {
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface ConditionalConverter {

-		fun matches(sourceType: TypeDescriptor, targetType: TypeDescriptor): Boolean
-	}
-
-	interface ConditionalGenericConverter : GenericConverter, ConditionalConverter
----
-
-A good example of a `ConditionalGenericConverter` is an `EntityConverter` that converts
-between a persistent entity identifier and an entity reference. Such an `EntityConverter`
+A good example of a `ConditionalGenericConverter` is an `IdToEntityConverter` that converts
+between a persistent entity identifier and an entity reference. Such an `IdToEntityConverter`
 might match only if the target entity type declares a static finder method (for example,
 `findAccount(Long)`). You might perform such a finder method check in the implementation of
 `matches(TypeDescriptor, TypeDescriptor)`.
@@ -1099,8 +1039,7 @@ might match only if the target entity type declares a static finder method (for
 `ConversionService` defines a unified API for executing type conversion logic at
 runtime. Converters are often run behind the following facade interface:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.core.convert;

@@ -1113,24 +1052,6 @@ runtime. Converters are often run behind the following facade interface:
 		boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType);

 		Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
-
-	}
----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.core.convert
-
-	interface ConversionService {
-
-		fun canConvert(sourceType: Class<*>, targetType: Class<*>): Boolean
-
-		fun <T> convert(source: Any, targetType: Class<T>): T
-
-		fun canConvert(sourceType: TypeDescriptor, targetType: TypeDescriptor): Boolean
-
-		fun convert(source: Any, sourceType: TypeDescriptor, targetType: TypeDescriptor): Any
-
 	}
 ----

@@ -1301,8 +1222,7 @@ provides a unified type conversion API for both SPIs.
 The `Formatter` SPI to implement field formatting logic is simple and strongly typed. The
 following listing shows the `Formatter` interface definition:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.format;

@@ -1313,25 +1233,15 @@ following listing shows the `Formatter` interface definition:
 `Formatter` extends from the `Printer` and `Parser` building-block interfaces. The
 following listing shows the definitions of those two interfaces:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	public interface Printer<T> {

 		String print(T fieldValue, Locale locale);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface Printer<T> {

-		fun print(fieldValue: T, locale: Locale): String
-	}
----
-
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	import java.text.ParseException;

@@ -1340,15 +1250,6 @@ following listing shows the definitions of those two interfaces:
 		T parse(String clientValue, Locale locale) throws ParseException;
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	interface Parser<T> {
-
-		@Throws(ParseException::class)
-		fun parse(clientValue: String, locale: Locale): T
-	}
----

 To create your own `Formatter`, implement the `Formatter` interface shown earlier.
 Parameterize `T` to be the type of object you wish to format -- for example,
@@ -1432,8 +1333,7 @@ Field formatting can be configured by field type or annotation. To bind
 an annotation to a `Formatter`, implement `AnnotationFormatterFactory`. The following
 listing shows the definition of the `AnnotationFormatterFactory` interface:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.format;

@@ -1446,22 +1346,9 @@ listing shows the definition of the `AnnotationFormatterFactory` interface:
 		Parser<?> getParser(A annotation, Class<?> fieldType);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.format
-
-	interface AnnotationFormatterFactory<A : Annotation> {
-
-		val fieldTypes: Set<Class<*>>
-
-		fun getPrinter(annotation: A, fieldType: Class<*>): Printer<*>
-
-		fun getParser(annotation: A, fieldType: Class<*>): Parser<*>
-	}
----

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

@@ -1602,36 +1489,23 @@ for use with Spring's `DataBinder` and the Spring Expression Language (SpEL).

 The following listing shows the `FormatterRegistry` SPI:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.format;

 	public interface FormatterRegistry extends ConverterRegistry {

-		void addFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?> parser);
+		void addPrinter(Printer<?> printer);
+
+		void addParser(Parser<?> parser);
+
+		void addFormatter(Formatter<?> formatter);

 		void addFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter);

-		void addFormatterForFieldType(Formatter<?> formatter);
+		void addFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?> parser);

-		void addFormatterForAnnotation(AnnotationFormatterFactory<?> factory);
-	}
----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.format
-
-	interface FormatterRegistry : ConverterRegistry {
-
-		fun addFormatterForFieldType(fieldType: Class<*>, printer: Printer<*>, parser: Parser<*>)
-
-		fun addFormatterForFieldType(fieldType: Class<*>, formatter: Formatter<*>)
-
-		fun addFormatterForFieldType(formatter: Formatter<*>)
-
-		fun addFormatterForAnnotation(factory: AnnotationFormatterFactory<*>)
+		void addFormatterForFieldAnnotation(AnnotationFormatterFactory<? extends Annotation> annotationFormatterFactory);
 	}
 ----

@@ -1651,8 +1525,7 @@ these rules once, and they are applied whenever formatting is needed.
 `FormatterRegistrar` is an SPI for registering formatters and converters through the
 FormatterRegistry. The following listing shows its interface definition:

-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-.Java
+[source,java,indent=0,subs="verbatim,quotes"]
 ----
 	package org.springframework.format;

@@ -1661,16 +1534,6 @@ FormatterRegistry. The following listing shows its interface definition:
 		void registerFormatters(FormatterRegistry registry);
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-.Kotlin
----
-	package org.springframework.format
-
-	interface FormatterRegistrar {
-
-		fun registerFormatters(registry: FormatterRegistry)
-	}
----

 A `FormatterRegistrar` is useful when registering multiple related converters and
 formatters for a given formatting category, such as date formatting. It can also be
@@ -1876,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:
@@ -1911,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 {
@@ -1934,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)
@@ -1971,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
@@ -2007,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 {

@@ -2020,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,10 @@
+[[data.access.appendix]]
 = Appendix




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

 This part of the appendix lists XML schemas for data access, including the following:
@@ -0,0 +1,9 @@
+<div id="header">
+<h1>Spring Framework Documentation</h1>
+<!--
+<div class="details">
+<span id="revnumber">{revnumber}</span>
+</div>
+-->
+<span><strong>{revnumber}</strong></span>
+</div>
@@ -1,18 +1,11 @@
+:noheader:
 = Spring Framework Documentation
-:doc-root: https://docs.spring.io
-:api-spring-framework: {doc-root}/spring-framework/docs/{spring-version}/javadoc-api/org/springframework
-
-****
-_What's New_, _Upgrade Notes_, _Supported Versions_, and other topics,
-independent of release cadence, are maintained externally on the project's
-https://github.com/spring-projects/spring-framework/wiki[*Github Wiki*].
-****

 [horizontal]
 <<overview.adoc#overview, Overview>> :: history, design philosophy, feedback,
 getting started.
 <<core.adoc#spring-core, Core>> :: IoC Container, Events, Resources, i18n,
-Validation, Data Binding, Type Conversion, SpEL, AOP.
+Validation, Data Binding, Type Conversion, SpEL, AOP, AOT.
 <<testing.adoc#testing, Testing>> :: Mock Objects, TestContext Framework,
 Spring MVC Test, WebTestClient.
 <<data-access.adoc#spring-data-tier, Data Access>> :: Transactions, DAO Support,
@@ -20,10 +13,15 @@ JDBC, R2DBC, O/R Mapping, XML Marshalling.
 <<web.adoc#spring-web, Web Servlet>> :: Spring MVC, WebSocket, SockJS,
 STOMP Messaging.
 <<web-reactive.adoc#spring-webflux, Web Reactive>> :: Spring WebFlux, WebClient,
-WebSocket.
-<<integration.adoc#spring-integration, Integration>> :: Remoting, JMS, JCA, JMX,
+WebSocket, RSocket.
+<<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.
+
+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
@@ -32,7 +30,7 @@ Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clem
 Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane
 Nicoll, Sebastien Deleuze, Jay Bryant, Mark Paluch

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

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




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

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



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

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

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



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

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



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

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


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

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


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

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



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

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



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

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


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

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



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

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



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

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



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

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

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

 	class FortuneController implements Controller {

@@ -8,15 +8,14 @@ with existing libraries written in Java.

 The Spring Framework provides first-class support for Kotlin and lets developers write
 Kotlin applications almost as if the Spring Framework was a native Kotlin framework.
+Most of the code samples of the reference documentation are
+provided in Kotlin in addition to Java.

 The easiest way to build a Spring application with Kotlin is to leverage Spring Boot and
 its https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-kotlin.html[dedicated Kotlin support].
 https://spring.io/guides/tutorials/spring-boot-kotlin/[This comprehensive tutorial]
 will teach you how to build Spring Boot applications with Kotlin using https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].

-As of Spring Framework 5.2, most of the code samples of the reference documentation are
-provided in Kotlin in addition to Java.
-
 Feel free to join the #spring channel of https://slack.kotlinlang.org/[Kotlin Slack]
 or ask a question with `spring` and `kotlin` as tags on
 https://stackoverflow.com/questions/tagged/spring+kotlin[Stackoverflow] if you need support.
@@ -24,13 +23,20 @@ https://stackoverflow.com/questions/tagged/spring+kotlin[Stackoverflow] if you n
 [[kotlin-requirements]]
 == Requirements

-Spring Framework supports Kotlin 1.3 and requires
-https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib[`kotlin-stdlib`]
-(or one of its variants, such as https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-stdlib-jdk8[`kotlin-stdlib-jdk8`])
-and https://bintray.com/bintray/jcenter/org.jetbrains.kotlin%3Akotlin-reflect[`kotlin-reflect`]
+Spring Framework supports Kotlin 1.3+ and requires
+https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-stdlib[`kotlin-stdlib`]
+(or one of its variants, such as https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-stdlib-jdk8[`kotlin-stdlib-jdk8`])
+and https://search.maven.org/artifact/org.jetbrains.kotlin/kotlin-reflect[`kotlin-reflect`]
 to be present on the classpath. They are provided by default if you bootstrap a Kotlin project on
 https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io].

+WARNING: Kotlin https://kotlinlang.org/docs/inline-classes.html[inline classes] are not yet supported.
+
+NOTE: The https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module] is required
+for serializing or deserializing JSON data for Kotlin classes with Jackson, so make sure to add the
+`com.fasterxml.jackson.module:jackson-module-kotlin` dependency to your project if you have such need.
+It is automatically registered when found in the classpath.
+
 [[kotlin-extensions]]
 == Extensions

@@ -38,8 +44,8 @@ Kotlin https://kotlinlang.org/docs/reference/extensions.html[extensions] provide
 to extend existing classes with additional functionality. The Spring Framework Kotlin APIs
 use these extensions to add new Kotlin-specific conveniences to existing Spring APIs.

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

 NOTE: Keep in mind that Kotlin extensions need to be imported to be used. This means,
 for example, that the `GenericApplicationContext.registerBean` Kotlin extension
@@ -120,11 +126,6 @@ Kotlin parameter names are recognized through a dedicated `KotlinReflectionParam
 which allows finding interface method parameter names without requiring the Java 8 `-parameters`
 compiler flag to be enabled during compilation.

-The https://github.com/FasterXML/jackson-module-kotlin[Jackson Kotlin module], which is required
-for serializing or deserializing JSON data, is automatically registered when
-found in the classpath, and a warning message is logged if Jackson and Kotlin are
-detected without the Jackson Kotlin module being present.
-
 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.
@@ -210,7 +211,7 @@ the constructor parameters will be autowired by type:
 ----

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

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

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

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

@@ -344,7 +345,7 @@ Spring Framework provides a
 https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/view/script/ScriptTemplateView.html[`ScriptTemplateView`]
 which supports https://www.jcp.org/en/jsr/detail?id=223[JSR-223] to render templates by using script engines.

-By leveraging `kotlin-script-runtime` and `scripting-jsr223-embeddable` dependencies, it
+By leveraging `scripting-jsr223` dependencies, it
 is possible to use such feature to render Kotlin-based templates with
 https://github.com/Kotlin/kotlinx.html[kotlinx.html] DSL or Kotlin multiline interpolated `String`.

@@ -352,8 +353,7 @@ https://github.com/Kotlin/kotlinx.html[kotlinx.html] DSL or Kotlin multiline int
 [source,kotlin,indent=0]
 ----
 dependencies {
-	compile("org.jetbrains.kotlin:kotlin-script-runtime:${kotlinVersion}")
-	runtime("org.jetbrains.kotlin:kotlin-scripting-jsr223-embeddable:${kotlinVersion}")
+        runtime("org.jetbrains.kotlin:kotlin-scripting-jsr223:${kotlinVersion}")
 }
 ----

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

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

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

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

 === Dependencies

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

 === WebFlux.fn

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

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

 ==== Constructor injection

-As described in the <<testing#testcontext-junit-jupiter-di#spring-web-reactive, dedicated section>>,
+As described in the <<testing#testcontext-junit-jupiter-di, dedicated section>>,
 JUnit 5 allows constructor injection of beans which is pretty useful with Kotlin
 in order to use `val` instead of `lateinit var`. You can use
 {api-spring-framework}/test/context/TestConstructor.html[`@TestConstructor(autowireMode = AutowireMode.ALL)`]
@@ -44,7 +44,7 @@ parallel, the Spring WebFlux reactive web framework.
 A note about modules: Spring's framework jars allow for deployment to JDK 9's module path
 ("Jigsaw"). For use in Jigsaw-enabled applications, the Spring Framework 5 jars come with
 "Automatic-Module-Name" manifest entries which define stable language-level module names
-("spring.core", "spring.context" etc) independent from jar artifact names (the jars follow
+("spring.core", "spring.context", etc.) independent from jar artifact names (the jars follow
 the same naming pattern with "-" instead of ".", e.g. "spring-core" and "spring-context").
 Of course, Spring's framework jars keep working fine on the classpath on both JDK 8 and 9+.

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

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

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

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

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

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

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

 For how-to questions or diagnosing or debugging issues, we suggest using Stack Overflow. Click
-https://stackoverflow.com/questions/tagged/spring+or+spring-mvc+or+spring-aop+or+spring-jdbc+or+spring-r2dbc+or+spring-transactions+or+spring-annotations+or+spring-jms+or+spring-el+or+spring-test+or+spring+or+spring-remoting+or+spring-orm+or+spring-jmx+or+spring-cache+or+spring-webflux+or+spring-rsocket?tab=Newest[here]
+https://stackoverflow.com/questions/tagged/spring+or+spring-mvc+or+spring-aop+or+spring-jdbc+or+spring-r2dbc+or+spring-transactions+or+spring-annotations+or+spring-jms+or+spring-el+or+spring-test+or+spring+or+spring-orm+or+spring-jmx+or+spring-cache+or+spring-webflux+or+spring-rsocket?tab=Newest[here]
 for a list of the suggested tags to use on Stack Overflow. If you're fairly certain that
 there is a problem in the Spring Framework or would like to suggest a feature, please use
 the https://github.com/spring-projects/spring-framework/issues[GitHub Issues].
@@ -135,8 +139,7 @@ https://github.com/spring-projects/spring-framework[Github]. However, please kee
 that, for all but the most trivial issues, we expect a ticket to be filed in the issue
 tracker, where discussions take place and leave a record for future reference.

-For more details see the guidelines at the
-https://github.com/spring-projects/spring-framework/blob/master/CONTRIBUTING.md[CONTRIBUTING],
+For more details see the guidelines at the {spring-framework-main-code}/CONTRIBUTING.md[CONTRIBUTING],
 top-level project page.


@@ -2,7 +2,7 @@
 = RSocket
 :gh-rsocket: https://github.com/rsocket
 :gh-rsocket-java: {gh-rsocket}/rsocket-java
-:gh-rsocket-extentions: {gh-rsocket}/rsocket/blob/master/Extensions
+:gh-rsocket-extensions: {gh-rsocket}/rsocket/blob/master/Extensions

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

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

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

 Protocol extensions define common metadata formats for use in applications:

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



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -1846,7 +1863,8 @@ constructor takes precedence over both `@TestConstructor` and the default mode.
 =====
 The default _test constructor autowire mode_ can be changed by setting the
 `spring.test.constructor.autowire.mode` JVM system property to `all`. Alternatively, the
-default mode may be set via the `SpringProperties` mechanism.
+default mode may be set via the
+<<appendix.adoc#appendix-spring-properties,`SpringProperties`>> mechanism.

 As of Spring Framework 5.3, the default mode may also be configured as a
 https://junit.org/junit5/docs/current/user-guide/#running-tests-config-params[JUnit Platform configuration parameter].
@@ -1869,7 +1887,7 @@ Spring test configuration annotations are processed within enclosing class hiera
 for inner test classes.

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

@@ -1878,8 +1896,8 @@ change the default mode.
 =====
 The default _enclosing configuration inheritance mode_ is `INHERIT`, but it can be
 changed by setting the `spring.test.enclosing.configuration` JVM system property to
-`OVERRIDE`. Alternatively, the default mode may be set via the `SpringProperties`
-mechanism.
+`OVERRIDE`. Alternatively, the default mode may be set via the
+<<appendix.adoc#appendix-spring-properties,`SpringProperties`>> mechanism.
 =====

 The <<testcontext-framework>> honors `@NestedTestConfiguration` semantics for the
@@ -1958,6 +1976,19 @@ example, you can create a custom `@EnabledOnMac` annotation as follows:
 	annotation class EnabledOnMac {}
 ----

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

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

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

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

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

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

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

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

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

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

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

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

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

 Contrast the comments in this example with the previous example.

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

 [[testcontext-ctx-management-caching]]
 ===== Context Caching
@@ -4565,8 +4667,8 @@ The size of the context cache is bounded with a default maximum size of 32. When
 maximum size is reached, a least recently used (LRU) eviction policy is used to evict and
 close stale contexts. You can configure the maximum size from the command line or a build
 script by setting a JVM system property named `spring.test.context.cache.maxSize`. As an
-alternative, you can set the same property programmatically by using the
-`SpringProperties` API.
+alternative, you can set the same property via the
+<<appendix.adoc#appendix-spring-properties,`SpringProperties`>> mechanism.

 Since having a large number of application contexts loaded within a given test suite can
 cause the suite to take an unnecessarily long time to run, it is often beneficial to
@@ -4657,7 +4759,7 @@ have different levels in a context hierarchy configured using different resource
 The remaining JUnit Jupiter based examples in this section show common configuration
 scenarios for integration tests that require the use of context hierarchies.

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

 		mockMvc.perform(asyncDispatch(mvcResult)) // <4>
 				.andExpect {
-					status().isOk() // <5>
+					status { isOk() } // <5>
 					content().string("body")
 				}
 	}
@@ -7470,12 +7725,35 @@ or reactive type such as Reactor `Mono`:
 [[spring-mvc-test-vs-streaming-response]]
 ===== Streaming Responses

-There are no options built into Spring MVC Test for container-less testing of streaming
-responses. However you can test streaming requests through the <<WebTestClient>>.
-This is also supported in Spring Boot where you can
-{doc-spring-boot}/html/spring-boot-features.html#boot-features-testing-spring-boot-applications-testing-with-running-server[test a running server]
-with `WebTestClient`. One extra advantage is the ability to use the `StepVerifier` from
-project Reactor that allows declaring expectations on a stream of data.
+The best way to test streaming responses such as Server-Sent Events is through the
+<<WebTestClient>> which can be used as a test client to connect to a `MockMvc` instance
+to perform tests on Spring MVC controllers without a running server. For example:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	WebTestClient client = MockMvcWebTestClient.bindToController(new SseController()).build();
+
+	FluxExchangeResult<Person> exchangeResult = client.get()
+			.uri("/persons")
+			.exchange()
+			.expectStatus().isOk()
+			.expectHeader().contentType("text/event-stream")
+			.returnResult(Person.class);
+
+	// Use StepVerifier from Project Reactor to test the streaming response
+
+	StepVerifier.create(exchangeResult.getResponseBody())
+			.expectNext(new Person("N0"), new Person("N1"), new Person("N2"))
+			.expectNextCount(4)
+			.consumeNextWith(person -> assertThat(person.getName()).endsWith("7"))
+			.thenCancel()
+			.verify();
+----
+
+`WebTestClient` can also connect to a live server and perform full end-to-end integration
+tests. This is also supported in Spring Boot where you can
+{doc-spring-boot}/html/spring-boot-features.html#boot-features-testing-spring-boot-applications-testing-with-running-server[test a running server].


 [[spring-mvc-test-server-filters]]
@@ -7549,9 +7827,9 @@ of testing even within the same project.
 ===== Further Examples

 The framework's own tests include
-https://github.com/spring-projects/spring-framework/tree/master/spring-test/src/test/java/org/springframework/test/web/servlet/samples[
+{spring-framework-main-code}/spring-test/src/test/java/org/springframework/test/web/servlet/samples[
 many sample tests] intended to show how to use MockMvc on its own or through the
-https://github.com/spring-projects/spring-framework/tree/master/spring-test/src/test/java/org/springframework/test/web/servlet/samples/client[
+{spring-framework-main-code}/spring-test/src/test/java/org/springframework/test/web/servlet/samples/client[
 WebTestClient]. Browse these examples for further ideas.


@@ -7559,13 +7837,13 @@ WebTestClient]. Browse these examples for further ideas.
 ==== HtmlUnit Integration

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

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

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

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

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

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

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

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

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

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


 [[spring-mvc-test-client]]
@@ -8760,7 +9038,7 @@ configuration. Check for the support for code completion on static members.
 ==== Further Examples of Client-side REST Tests

 Spring MVC Test's own tests include
-https://github.com/spring-projects/spring-framework/tree/master/spring-test/src/test/java/org/springframework/test/web/client/samples[example
+{spring-framework-main-code}/spring-test/src/test/java/org/springframework/test/web/client/samples[example
 tests] of client-side REST tests.


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

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

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

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

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

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

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


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

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


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

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

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

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

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

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

@@ -82,7 +82,7 @@ as the following example shows:
 			.build("Westin", "123")
 ----

-You shorter it further still with a full URI template, as the following example shows:
+You can shorten it further still with a full URI template, as the following example shows:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -94,19 +94,18 @@ You shorter it further still with a full URI template, as the following example
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-val uri = UriComponentsBuilder
-		.fromUriString("https://example.com/hotels/{hotel}?q={q}")
-		.build("Westin", "123")
+	val uri = UriComponentsBuilder
+			.fromUriString("https://example.com/hotels/{hotel}?q={q}")
+			.build("Westin", "123")
 ----



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

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


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

@@ -214,8 +212,10 @@ TIP: Consider ";", which is legal in a path but has reserved meaning. The first
 replaces ";", since it is a legal character in a path.

 For most cases, the first option is likely to give the expected result, because it treats URI
-variables as opaque data to be fully encoded, while option 2 is useful only if
-URI variables intentionally contain reserved characters.
+variables as opaque data to be fully encoded, while the second option is useful if URI
+variables do intentionally contain reserved characters. The second option is also useful
+when not expanding URI variables at all since that will also encode anything that
+incidentally looks like a URI variable.

 The following example uses the first option:

@@ -250,7 +250,7 @@ as the following example shows:
 ----
 	URI uri = UriComponentsBuilder.fromPath("/hotel list/{city}")
 			.queryParam("q", "{q}")
-			.build("New York", "foo+bar")
+			.build("New York", "foo+bar");
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
@@ -265,18 +265,18 @@ You can shorten it further still with a full URI template, as the following exam
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	URI uri = UriComponentsBuilder.fromPath("/hotel list/{city}?q={q}")
-			.build("New York", "foo+bar")
+	URI uri = UriComponentsBuilder.fromUriString("/hotel list/{city}?q={q}")
+			.build("New York", "foo+bar");
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	val uri = UriComponentsBuilder.fromPath("/hotel list/{city}?q={q}")
+	val uri = UriComponentsBuilder.fromUriString("/hotel list/{city}?q={q}")
 			.build("New York", "foo+bar")
 ----

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

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
@@ -318,7 +318,7 @@ the approach to encoding, based on one of the below encoding modes:
 the first option in the earlier list, to pre-encode the URI template and strictly encode URI variables when
 expanded.
 * `VALUES_ONLY`: Does not encode the URI template and, instead, applies strict encoding
-to URI variables through `UriUtils#encodeUriUriVariables` prior to expanding them into the
+to URI variables through `UriUtils#encodeUriVariables` prior to expanding them into the
 template.
 * `URI_COMPONENT`: Uses `UriComponents#encode()`, corresponding to the second option in the earlier list, to
 encode URI component value _after_ URI variables are expanded.
@@ -1,5 +1,6 @@
 [[webflux-cors]]
 = CORS
+:doc-spring-security: {doc-root}/spring-security/reference
 [.small]#<<web.adoc#mvc-cors, Web MVC>>#

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

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

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

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

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


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

 [source,java,role="primary"]
 .Java
@@ -181,7 +182,7 @@ The following example shows how to access form data:
 [source,java,role="primary"]
 .Java
 ----
-Mono<MultiValueMap<String, String> map = request.formData();
+Mono<MultiValueMap<String, String>> map = request.formData();
 ----
 [source,kotlin,role="secondary"]
 .Kotlin
@@ -194,7 +195,7 @@ The following example shows how to access multipart data as a map:
 [source,java,role="primary"]
 .Java
 ----
-Mono<MultiValueMap<String, Part> map = request.multipartData();
+Mono<MultiValueMap<String, Part>> map = request.multipartData();
 ----
 [source,kotlin,role="secondary"]
 .Kotlin
@@ -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
@@ -505,6 +549,8 @@ The example shown above also uses two request predicates, as the builder uses
 Router functions are evaluated in order: if the first route does not match, the
 second is evaluated, and so on.
 Therefore, it makes sense to declare more specific routes before general ones.
+This is also important when registering router functions as Spring beans, as will
+be described later.
 Note that this behavior is different from the annotation-based programming model, where the
 "most specific" controller method is picked automatically.

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

 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
@@ -600,7 +646,7 @@ RouterFunction<ServerResponse> route = route()
 		"/person".nest {
 			GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
 			GET(accept(APPLICATION_JSON), handler::listPeople)
-			POST("/person", handler::createPerson)
+			POST(handler::createPerson)
 		}
 	}
 ----
@@ -618,7 +664,7 @@ We can further improve by using the `nest` method together with `accept`:
 			.nest(accept(APPLICATION_JSON), b2 -> b2
 				.GET("/{id}", handler::getPerson)
 				.GET(handler::listPeople))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.build();
 ----
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
@@ -629,7 +675,7 @@ We can further improve by using the `nest` method together with `accept`:
 			accept(APPLICATION_JSON).nest {
 				GET("/{id}", handler::getPerson)
 				GET(handler::listPeople)
-				POST("/person", handler::createPerson)
+				POST(handler::createPerson)
 			}
 		}
 	}
@@ -656,8 +702,8 @@ components required to process requests. The WebFlux Java configuration declares
 infrastructure components to support functional endpoints:

 * `RouterFunctionMapping`: Detects one or more `RouterFunction<?>` beans in the Spring
-configuration, combines them through `RouterFunction.andOther`, and routes requests to the
-resulting composed `RouterFunction`.
+configuration, <<core.adoc#beans-factory-ordered, orders them>>, combines them through
+`RouterFunction.andOther`, and routes requests to the resulting composed `RouterFunction`.
 * `HandlerFunctionAdapter`: Simple adapter that lets `DispatcherHandler` invoke
 a `HandlerFunction` that was mapped to a request.
 * `ServerResponseResultHandler`: Handles the result from the invocation of a
@@ -764,7 +810,7 @@ For instance, consider the following example:
 				.before(request -> ServerRequest.from(request) // <1>
 					.header("X-RequestHeader", "Value")
 					.build()))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.after((request, response) -> logResponse(response)) // <2>
 		.build();
 ----
@@ -782,7 +828,7 @@ For instance, consider the following example:
 				ServerRequest.from(it)
 						.header("X-RequestHeader", "Value").build()
 			}
-			POST("/person", handler::createPerson)
+			POST(handler::createPerson)
 			after { _, response -> // <2>
 				logResponse(response)
 			}
@@ -813,7 +859,7 @@ The following example shows how to do so:
 			.nest(accept(APPLICATION_JSON), b2 -> b2
 				.GET("/{id}", handler::getPerson)
 				.GET(handler::listPeople))
-			.POST("/person", handler::createPerson))
+			.POST(handler::createPerson))
 		.filter((request, next) -> {
 			if (securityManager.allowAccessTo(request.path())) {
 				return next.handle(request);
@@ -833,7 +879,7 @@ The following example shows how to do so:
 			("/person" and accept(APPLICATION_JSON)).nest {
 				GET("/{id}", handler::getPerson)
 				GET("", handler::listPeople)
-				POST("/person", handler::createPerson)
+				POST(handler::createPerson)
 				filter { request, next ->
 					if (securityManager.allowAccessTo(request.path())) {
 						next(request)
@@ -26,7 +26,7 @@ configuration involves a few bean declarations, such as
 `SpringResourceTemplateResolver`, `SpringWebFluxTemplateEngine`, and
 `ThymeleafReactiveViewResolver`. For more details, see
 https://www.thymeleaf.org/documentation.html[Thymeleaf+Spring] and the WebFlux integration
-http://forum.thymeleaf.org/Thymeleaf-3-0-8-JUST-PUBLISHED-td4030687.html[announcement].
+https://web.archive.org/web/20210623051330/http%3A//forum.thymeleaf.org/Thymeleaf-3-0-8-JUST-PUBLISHED-td4030687.html[announcement].



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

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


@@ -380,8 +380,8 @@ The following example shows how compile a template:
 ----

 Check out the Spring Framework unit tests,
-https://github.com/spring-projects/spring-framework/tree/master/spring-webflux/src/test/java/org/springframework/web/reactive/result/view/script[Java], and
-https://github.com/spring-projects/spring-framework/tree/master/spring-webflux/src/test/resources/org/springframework/web/reactive/result/view/script[resources],
+{spring-framework-main-code}/spring-webflux/src/test/java/org/springframework/web/reactive/result/view/script[Java], and
+{spring-framework-main-code}/spring-webflux/src/test/resources/org/springframework/web/reactive/result/view/script[resources],
 for more configuration examples.


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

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

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

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



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

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

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

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

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

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

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

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

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


 [[webflux-client-filter]]
@@ -889,9 +966,8 @@ a filter for basic authentication through a static factory method:
 			.build()
 ----

-You can create a new `WebClient` instance by using another as a starting point. This allows
-insert or removing filters without affecting the original `WebClient`. Below is an example
-that inserts a basic authentication filter at index 0:
+Filters can be added or removed by mutating an existing `WebClient` instance, resulting
+in a new `WebClient` instance that does not affect the original one. For example:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -912,6 +988,54 @@ that inserts a basic authentication filter at index 0:
 			.build()
 ----

+`WebClient` is a thin facade around the chain of filters followed by an
+`ExchangeFunction`. It provides a workflow to make requests, to encode to and from higher
+level objects, and it helps to ensure that response content is always consumed.
+When filters handle the response in some way, extra care must be taken to always consume
+its content or to otherwise propagate it downstream to the `WebClient` which will ensure
+the same. Below is a filter that handles the `UNAUTHORIZED` status code but ensures that
+any response content, whether expected or not, is released:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+.Java
+----
+	public ExchangeFilterFunction renewTokenFilter() {
+		return (request, next) -> next.exchange(request).flatMap(response -> {
+			if (response.statusCode().value() == HttpStatus.UNAUTHORIZED.value()) {
+				return response.releaseBody()
+						.then(renewToken())
+						.flatMap(token -> {
+							ClientRequest newRequest = ClientRequest.from(request).build();
+							return next.exchange(newRequest);
+						});
+			} else {
+				return Mono.just(response);
+			}
+		});
+	}
+----
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+.Kotlin
+----
+	fun renewTokenFilter(): ExchangeFilterFunction? {
+		return ExchangeFilterFunction { request: ClientRequest?, next: ExchangeFunction ->
+			next.exchange(request!!).flatMap { response: ClientResponse ->
+				if (response.statusCode().value() == HttpStatus.UNAUTHORIZED.value()) {
+					return@flatMap response.releaseBody()
+							.then(renewToken())
+							.flatMap { token: String? ->
+								val newRequest = ClientRequest.from(request).build()
+								next.exchange(newRequest)
+							}
+				} else {
+					return@flatMap Mono.just(response)
+				}
+			}
+		}
+	}
+----
+
+

 [[webflux-client-attributes]]
 == Attributes
@@ -1016,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>()
@@ -1071,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 .
 ====


@@ -1083,7 +1207,7 @@ controller method .
 To test code that uses the `WebClient`, you can use a mock web server, such as the
 https://github.com/square/okhttp#mockwebserver[OkHttp MockWebServer]. To see an example
 of its use, check out
-https://github.com/spring-projects/spring-framework/blob/master/spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientIntegrationTests.java[`WebClientIntegrationTests`]
+{spring-framework-main-code}/spring-webflux/src/test/java/org/springframework/web/reactive/function/client/WebClientIntegrationTests.java[`WebClientIntegrationTests`]
 in the Spring Framework test suite or the
 https://github.com/square/okhttp/tree/master/samples/static-server[`static-server`]
 sample in the OkHttp repository.
@@ -353,7 +353,7 @@ into the attributes of the `WebSocketSession`.


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

 The `RequestUpgradeStrategy` for each server exposes configuration specific to the
--- a/Show More
+++ b/Show More