Release v6.0.2

Additional documentation notes on Java/Kotlin parameter name retention
See gh-29563
2026-06-08 17:33:33 +00:00 · 2022-11-24 13:35:34 +00:00 · 2022-11-24 14:08:53 +01:00 · 2022-11-24 12:40:25 +00:00 · 2022-11-24 12:01:51 +01:00 · 2022-11-24 12:01:03 +01:00
4295 changed files with 135457 additions and 105091 deletions
@@ -1,33 +0,0 @@
-name: Send notification
-description: Sends a Google Chat message as a notification of the job's outcome
-inputs:
-  webhook-url:
-    description: 'Google Chat Webhook URL'
-    required: true
-  status:
-    description: 'Status of the job'
-    required: true
-  build-scan-url:
-    description: 'URL of the build scan to include in the notification'
-  run-name:
-    description: 'Name of the run to include in the notification'
-    default: ${{ format('{0} {1}', github.ref_name, github.job) }}
-runs:
-  using: composite
-  steps:
-    - shell: bash
-      run: |
-        echo "BUILD_SCAN=${{ inputs.build-scan-url == '' && ' [build scan unavailable]' || format(' [<{0}|Build Scan>]', inputs.build-scan-url) }}" >> "$GITHUB_ENV"
-        echo "RUN_URL=${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" >> "$GITHUB_ENV"
-    - shell: bash
-      if: ${{ inputs.status == 'success' }}
-      run: |
-        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was successful ${{ env.BUILD_SCAN }}"}' || true
-    - shell: bash
-      if: ${{ inputs.status == 'failure' }}
-      run: |
-        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<users/all> *<${{ env.RUN_URL }}|${{ inputs.run-name }}> failed* ${{ env.BUILD_SCAN }}"}' || true
-    - shell: bash
-      if: ${{ inputs.status == 'cancelled' }}
-      run: |
-        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was cancelled"}' || true
@@ -3,8 +3,6 @@ name: Backport Bot
 on:
  issues:
    types: [labeled]
-  pull_request:
-    types: [labeled]
  push:
    branches:
      - '*.x'
@@ -15,16 +13,13 @@ jobs:
    permissions:
      contents: read
      issues: write
-      pull-requests: write
    runs-on: ubuntu-latest
    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Java
-        uses: actions/setup-java@v4
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
        with:
-          distribution: 'liberica'
-          java-version: 17
+          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
@@ -1,63 +0,0 @@
-name: Build and deploy snapshot
-on:
-  push:
-    branches:
-      - 5.3.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-deploy-snapshot:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    name: Build and deploy snapshot
-    runs-on: ubuntu-latest
-    steps:
-      - name: Set up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: 8
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
-        with:
-          cache-read-only: false
-      - name: Configure Gradle properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
-          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
-      - name: Build and publish
-        id: build
-        env:
-          CI: 'true'
-          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
-          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-        run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
-      - name: Deploy
-        uses: spring-io/artifactory-deploy-action@v0.0.1
-        with:
-          uri: 'https://repo.spring.io'
-          username: ${{ secrets.ARTIFACTORY_USERNAME }}
-          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          build-name: ${{ format('spring-framework-{0}', github.ref_name)}}
-          repository: 'libs-snapshot-local'
-          folder: 'deployment-repository'
-          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
-          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          artifact-properties: |
-            /**/spring-*.zip::zip.name=spring-framework,zip.deployed=false
-            /**/spring-*-docs.zip::zip.type=docs
-            /**/spring-*-dist.zip::zip.type=dist
-            /**/spring-*-schema.zip::zip.type=schema
-      - name: Send notification
-        uses: ./.github/actions/send-notification
-        if: always()
-        with:
-          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-          status: ${{ job.status }}
-          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | Linux | Java 8', github.ref_name) }}
@@ -1,80 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - 5.3.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  ci:
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    strategy:
-      matrix:
-        os:
-          - id: ubuntu-latest
-            name: Linux
-        java:
-          - version: 8
-            toolchain: false
-          - version: 17
-            toolchain: true
-          - version: 21
-            toolchain: true
-        exclude:
-          - os:
-              name: Linux
-            java:
-              version: 8
-    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
-    runs-on: ${{ matrix.os.id }}
-    steps:
-      - name: Set up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: |
-            ${{ matrix.java.version }}
-            ${{ matrix.java.toolchain && '8' || '' }}
-      - name: Prepare Windows runner
-        if: ${{ runner.os == 'Windows' }}
-        run: |
-          git config --global core.autocrlf true
-          git config --global core.longPaths true
-          Stop-Service -name Docker
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Gradle
-        uses: gradle/actions/setup-gradle@417ae3ccd767c252f5661f1ace9f835f9654f2b5
-        with:
-          cache-read-only: false
-      - name: Configure Gradle properties
-        shell: bash
-        run: |
-          mkdir -p $HOME/.gradle
-          echo 'systemProp.user.name=spring-builds+github' >> $HOME/.gradle/gradle.properties
-          echo 'systemProp.org.gradle.internal.launcher.welcomeMessageEnabled=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
-          echo 'org.gradle.daemon=4' >> $HOME/.gradle/gradle.properties
-      - name: Configure toolchain properties
-        if: ${{ matrix.java.toolchain }}
-        shell: bash
-        run: |
-          echo toolchainVersion=${{ matrix.java.version }} >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.auto-detect=false >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.auto-download=false >> $HOME/.gradle/gradle.properties
-          echo systemProp.org.gradle.java.installations.paths=${{ format('$JAVA_HOME_{0}_X64', matrix.java.version) }} >> $HOME/.gradle/gradle.properties
-      - name: Build
-        id: build
-        env:
-          CI: 'true'
-          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
-          DEVELOCITY_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
-        run: ./gradlew check
-      - name: Send notification
-        uses: ./.github/actions/send-notification
-        if: always()
-        with:
-          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-          status: ${{ job.status }}
-          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | {1} | Java {2}', github.ref_name, matrix.os.name, matrix.java.version) }}
@@ -9,5 +9,5 @@ jobs:
    name: "Validation"
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
-      - uses: gradle/wrapper-validation-action@v2
+      - uses: actions/checkout@v3
+      - uses: gradle/wrapper-validation-action@v1
@@ -1,38 +1,42 @@
+# Miscellaneous
 *.java.hsp
 *.sonarj
 *.sw*
 .DS_Store
-.settings
-.springBeans
-bin
 build.sh
 integration-repo
 ivy-cache
+argfile*
+activemq-data/
+classes/
+
+# Log files
 jxl.log
 jmx.log
 derby.log
-spring-test/test-output/
-.gradle
-argfile*
-pom.xml
-activemq-data/

-classes/
+# Gradle artifacts
+.gradle
+.gradletasknamecache
 /build
 buildSrc/build
 /spring-*/build
-/spring-core/graalvm/build
-/spring-core/kotlin-coroutines/build
 /framework-bom/build
 /framework-docs/build
 /integration-tests/build
 /src/asciidoc/build
+spring-test/test-output/
+
+# Maven artifacts
+pom.xml
 target/
-/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
@@ -43,9 +47,6 @@ spring-*/src/main/java/META-INF/MANIFEST.MF
 out
 test-output
 atlassian-ide-plugin.xml
-.gradletasknamecache

 # VS Code
 .vscode/
-
-cached-antora-playbook.yml
@@ -10,10 +10,11 @@ Phillip Webb <pwebb@vmware.com> <pwebb@gopivotal.com>
 Chris Beams <cbeams@vmware.com>
 Chris Beams <cbeams@vmware.com> <cbeams@pivotal.io>
 Chris Beams <cbeams@vmware.com> <cbeams@gopivotal.com>
-Arjen Poutsma <apoutsma@vmware.com>
-Arjen Poutsma <apoutsma@vmware.com> <apoutsma@pivotal.io>
-Arjen Poutsma <apoutsma@vmware.com> <apoutsma@gopivotal.com>
-Arjen Poutsma <apoutsma@vmware.com> <poutsma@mac.com>
+Arjen Poutsma <poutsmaa@vmware.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@pivotal.io>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@gopivotal.com>
+Arjen Poutsma <poutsmaa@vmware.com> <poutsma@mac.com>
+Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@vmware.com>
 Oliver Drotbohm <odrotbohm@vmware.com>
 Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@vmware.com>
 Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@pivotal.io>
@@ -1,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=8.0.382-librca
+java=17.0.5-librca
@@ -6,7 +6,7 @@ First off, thank you for taking the time to contribute! :+1: :tada:

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

 ### How to Contribute

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

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

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

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

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

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

 #### Issue Lifecycle

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

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

 1. Should you create an issue first? No, just create the pull request and use the
@@ -120,12 +123,13 @@ define the source file coding standards we use along with some IDEA editor setti

 ### Reference Docs

-The reference documentation is in the [src/docs/asciidoc](src/docs/asciidoc) directory, in
+The reference documentation is in the [framework-docs/src/docs/asciidoc](framework-docs/src/docs/asciidoc) directory, in
 [Asciidoctor](https://asciidoctor.org/) format. For trivial changes, you may be able to browse,
 edit source files, and submit directly from GitHub.

-When making changes locally, execute `./gradlew asciidoctor` and then browse the result under
-`build/docs/ref-docs/html5/index.html`.
+When making changes locally, execute `./gradlew :framework-docs:asciidoctor` and then browse the result under
+`framework-docs/build/docs/ref-docs/html5/index.html`.

 Asciidoctor also supports live editing. For more details see
 [AsciiDoc Tooling](https://docs.asciidoctor.org/asciidoctor/latest/tooling/).
+
@@ -1,4 +1,4 @@
-# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml/badge.svg?branch=5.3.x)](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml?query=branch%3A5.3.x) [![Revved up by Develocity](https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
+# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-5.3.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-5.3.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)

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

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

 ## Documentation

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

 ## Micro-Benchmarks
@@ -1,297 +1,39 @@
 plugins {
-	id 'io.spring.dependency-management' version '1.0.11.RELEASE' apply false
 	id 'io.spring.nohttp' version '0.0.10'
-	id 'io.freefair.aspectj' version '6.2.0' apply false
-	id 'org.jetbrains.dokka' version '1.6.10' apply false
-	id 'org.jetbrains.kotlin.jvm' version '1.5.32' apply false
-	id 'org.jetbrains.kotlin.plugin.serialization' version "1.5.32" apply false
-	id 'org.asciidoctor.jvm.convert' version '3.3.2'
-	id 'org.asciidoctor.jvm.pdf' version '3.3.2'
+	id '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.39.0'
-	id 'com.github.johnrengelman.shadow' version '7.0.0' apply false
-	id 'de.undercouch.download' version '4.1.2'
-	id 'me.champeau.jmh' version "0.6.6" apply false
+	id 'com.github.ben-manes.versions' version '0.42.0'
+	id 'com.github.johnrengelman.shadow' version '7.1.2' apply false
+	id 'de.undercouch.download' version '5.1.0'
+	id 'me.champeau.jmh' version '0.6.6' apply false
 }

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

 configure(allprojects) { project ->
-	apply plugin: "io.spring.dependency-management"
-
-	dependencyManagement {
-		imports {
-			mavenBom "com.fasterxml.jackson:jackson-bom:2.12.7"
-			mavenBom "io.netty:netty-bom:4.1.109.Final"
-			mavenBom "io.projectreactor:reactor-bom:2020.0.44"
-			mavenBom "io.r2dbc:r2dbc-bom:Arabba-SR13"
-			mavenBom "io.rsocket:rsocket-bom:1.1.3"
-			mavenBom "org.eclipse.jetty:jetty-bom:9.4.54.v20240208"
-			mavenBom "org.jetbrains.kotlin:kotlin-bom:1.5.32"
-			mavenBom "org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.5.2"
-			mavenBom "org.jetbrains.kotlinx:kotlinx-serialization-bom:1.2.2"
-			mavenBom "org.junit:junit-bom:5.8.2"
+	repositories {
+		mavenCentral()
+		maven {
+			url "https://repo.spring.io/milestone"
+			content {
+				// Netty 5 optional support
+				includeGroup 'io.projectreactor.netty'
+			}
 		}
-		dependencies {
-			dependencySet(group: 'org.apache.logging.log4j', version: '2.21.1') {
-				entry 'log4j-api'
-				entry 'log4j-core'
-				entry 'log4j-jul'
-				entry 'log4j-slf4j-impl'
-			}
-			dependency "org.slf4j:slf4j-api:1.7.36"
-			dependency("com.google.code.findbugs:findbugs:3.0.1") {
-				exclude group: "dom4j", name: "dom4j"
-			}
-			dependency "com.google.code.findbugs:jsr305:3.0.2"
-
-			dependencySet(group: 'org.aspectj', version: '1.9.7') {
-				entry 'aspectjrt'
-				entry 'aspectjtools'
-				entry 'aspectjweaver'
-			}
-			dependencySet(group: 'org.codehaus.groovy', version: '3.0.9') {
-				entry 'groovy'
-				entry 'groovy-jsr223'
-				entry 'groovy-templates'  // requires findbugs for warning-free compilation
-				entry 'groovy-test'
-				entry 'groovy-xml'
-			}
-
-			dependency "io.reactivex:rxjava:1.3.8"
-			dependency "io.reactivex:rxjava-reactive-streams:1.2.1"
-			dependency "io.reactivex.rxjava2:rxjava:2.2.21"
-			dependency "io.reactivex.rxjava3:rxjava:3.1.8"
-			dependency "io.smallrye.reactive:mutiny:1.9.0"
-			dependency "io.projectreactor.tools:blockhound:1.0.8.RELEASE"
-
-			dependency "com.caucho:hessian:4.0.63"
-			dependency "com.fasterxml:aalto-xml:1.3.1"
-			dependency("com.fasterxml.woodstox:woodstox-core:6.2.8") {
-				exclude group: "stax", name: "stax-api"
-			}
-			dependency "com.google.code.gson:gson:2.8.9"
-			dependency "com.google.protobuf:protobuf-java-util:3.19.3"
-			dependency "com.googlecode.protobuf-java-format:protobuf-java-format:1.4"
-			dependency("com.thoughtworks.xstream:xstream:1.4.19") {
-				exclude group: "xpp3", name: "xpp3_min"
-				exclude group: "xmlpull", name: "xmlpull"
-			}
-			dependency "org.apache.johnzon:johnzon-jsonb:1.2.18"
-			dependency("org.codehaus.jettison:jettison:1.3.8") {
-				exclude group: "stax", name: "stax-api"
-			}
-			dependencySet(group: 'org.jibx', version: '1.3.3') {
-				entry 'jibx-bind'
-				entry 'jibx-run'
-			}
-			dependency "org.ogce:xpp3:1.1.6"
-			dependency "org.yaml:snakeyaml:1.33"
-
-			dependency "com.h2database:h2:2.1.214"
-			dependency "com.github.ben-manes.caffeine:caffeine:2.9.3"
-			dependency "com.github.librepdf:openpdf:1.3.33"
-			dependency "com.rometools:rome:1.18.0"
-			dependency "commons-io:commons-io:2.5"
-			dependency "io.vavr:vavr:0.10.4"
-			dependency "net.sf.jopt-simple:jopt-simple:5.0.4"
-			dependencySet(group: 'org.apache.activemq', version: '5.16.2') {
-				entry 'activemq-broker'
-				entry('activemq-kahadb-store') {
-					exclude group: "org.springframework", name: "spring-context"
-				}
-				entry 'activemq-stomp'
-			}
-			dependency "org.apache.bcel:bcel:6.0"
-			dependency "org.apache.commons:commons-pool2:2.9.0"
-			dependencySet(group: 'org.apache.derby', version: '10.14.2.0') {
-				entry 'derby'
-				entry 'derbyclient'
-			}
-			dependency "org.apache.poi:poi-ooxml:4.1.2"
-			dependency "org.apache-extras.beanshell:bsh:2.0b6"
-			dependency "org.freemarker:freemarker:2.3.31"
-			dependency "org.hsqldb:hsqldb:2.5.2"
-			dependency "org.quartz-scheduler:quartz:2.3.2"
-			dependency "org.codehaus.fabric3.api:commonj:1.1.0"
-			dependency "net.sf.ehcache:ehcache:2.10.6"
-			dependency "org.ehcache:jcache:1.0.1"
-			dependency "org.ehcache:ehcache:3.4.0"
-			dependency "org.hibernate:hibernate-core:5.4.33.Final"
-			dependency "org.hibernate:hibernate-validator:6.2.5.Final"
-			dependency "org.webjars:webjars-locator-core:0.48"
-			dependency "org.webjars:underscorejs:1.8.3"
-
-			dependencySet(group: 'org.apache.tomcat', version: '9.0.82') {
-				entry 'tomcat-util'
-				entry('tomcat-websocket') {
-					exclude group: "org.apache.tomcat", name: "tomcat-servlet-api"
-					exclude group: "org.apache.tomcat", name: "tomcat-websocket-api"
-				}
-			}
-			dependencySet(group: 'org.apache.tomcat.embed', version: '9.0.82') {
-				entry 'tomcat-embed-core'
-				entry 'tomcat-embed-websocket'
-			}
-			dependencySet(group: 'io.undertow', version: '2.2.29.Final') {
-				entry 'undertow-core'
-				entry('undertow-servlet') {
-					exclude group: "org.jboss.spec.javax.servlet", name: "jboss-servlet-api_4.0_spec"
-					exclude group: "org.jboss.spec.javax.annotation", name: "jboss-annotations-api_1.3_spec"
-				}
-				entry('undertow-websockets-jsr') {
-					exclude group: "org.jboss.spec.javax.websocket", name: "jboss-websocket-api_1.1_spec"
-				}
-			}
-
-			dependency "org.eclipse.jetty:jetty-reactive-httpclient:1.1.13"
-			dependency 'org.apache.httpcomponents.client5:httpclient5:5.1.3'
-			dependency 'org.apache.httpcomponents.core5:httpcore5-reactive:5.1.3'
-			dependency("org.apache.httpcomponents:httpclient:4.5.13") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.apache.httpcomponents:httpasyncclient:4.1.5") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependencySet(group: 'com.squareup.okhttp3', version: '3.14.9') {
-				entry 'okhttp'
-				entry 'mockwebserver'
-			}
-
-			dependency "org.jruby:jruby:9.2.20.1"
-			dependency "org.python:jython-standalone:2.7.1"
-			dependency "org.mozilla:rhino:1.7.11"
-
-			dependency "commons-fileupload:commons-fileupload:1.4"
-			dependency "org.synchronoss.cloud:nio-multipart-parser:1.1.0"
-
-			dependency("org.dom4j:dom4j:2.1.3") {
-				exclude group: "jaxen", name: "jaxen"
-				exclude group: "net.java.dev.msv", name: "xsdlib"
-				exclude group: "pull-parser", name: "pull-parser"
-				exclude group: "xpp3", name: "xpp3"
-			}
-			dependency("jaxen:jaxen:1.2.0") {
-				exclude group: "dom4j", name: "dom4j"
-			}
-
-			dependency("junit:junit:4.13.2") {
-				exclude group: "org.hamcrest", name: "hamcrest-core"
-			}
-			dependency("de.bechte.junit:junit-hierarchicalcontextrunner:4.12.1") {
-				exclude group: "junit", name: "junit"
-			}
-			dependency "org.testng:testng:7.4.0"
-			dependency "org.junit.support:testng-engine:1.0.4"
-			dependency "org.hamcrest:hamcrest:2.2"
-			dependency "org.awaitility:awaitility:3.1.6"
-			dependency "org.assertj:assertj-core:3.24.2"
-			dependencySet(group: 'org.xmlunit', version: '2.9.0') {
-				entry 'xmlunit-assertj'
-				entry('xmlunit-matchers') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-			}
-			dependencySet(group: 'org.mockito', version: '4.9.0') {  // spring-beans tests fail with 4.10+
-				entry('mockito-core') {
-					exclude group: "org.hamcrest", name: "hamcrest-core"
-				}
-				entry 'mockito-junit-jupiter'
-			}
-			dependency "io.mockk:mockk:1.12.1"
-
-			dependency("net.sourceforge.htmlunit:htmlunit:2.70.0") {
-				exclude group: "commons-logging", name: "commons-logging"
-			}
-			dependency("org.seleniumhq.selenium:htmlunit-driver:2.70.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.7.0"
-			dependency "org.bouncycastle:bcpkix-jdk18on:1.71"
-
-			dependencySet(group: 'org.apache.tiles', version: '3.0.8') {
-				entry 'tiles-api'
-				entry('tiles-core', withoutJclOverSlf4j)
-				entry('tiles-servlet', withoutJclOverSlf4j)
-				entry('tiles-jsp', withoutJclOverSlf4j)
-				entry('tiles-el', withoutJclOverSlf4j)
-				entry('tiles-extras') {
-					exclude group: "org.springframework", name: "spring-web"
-					exclude group: "org.slf4j", name: "jcl-over-slf4j"
-				}
-			}
-			dependency("org.apache.taglibs:taglibs-standard-jstlel:1.2.5") {
-				exclude group: "org.apache.taglibs", name: "taglibs-standard-spec"
-			}
-
-			dependency "com.ibm.websphere:uow:6.0.2.17"
-			dependency "com.jamonapi:jamon:2.82"
-			dependency "joda-time:joda-time:2.10.13"
-			dependency "org.eclipse.persistence:org.eclipse.persistence.jpa:2.7.12"
-			dependency "org.javamoney:moneta:1.3"
-
-			dependency "com.sun.activation:javax.activation:1.2.0"
-			dependency "com.sun.mail:javax.mail:1.6.2"
-			dependencySet(group: 'com.sun.xml.bind', version: '2.3.0.1') {
-				entry 'jaxb-core'
-				entry 'jaxb-impl'
-				entry 'jaxb-xjc'
-			}
-
-			dependency "javax.activation:javax.activation-api:1.2.0"
-			dependency "javax.annotation:javax.annotation-api:1.3.2"
-			dependency "javax.cache:cache-api:1.1.0"
-			dependency "javax.ejb:javax.ejb-api:3.2"
-			dependency "javax.el:javax.el-api:3.0.1-b04"
-			dependency "javax.enterprise.concurrent:javax.enterprise.concurrent-api:1.0"
-			dependency "javax.faces:javax.faces-api:2.2"
-			dependency "javax.inject:javax.inject:1"
-			dependency "javax.inject:javax.inject-tck:1"
-			dependency "javax.interceptor:javax.interceptor-api:1.2.2"
-			dependency "javax.jms:javax.jms-api:2.0.1"
-			dependency "javax.json:javax.json-api:1.1.4"
-			dependency "javax.json.bind:javax.json.bind-api:1.0"
-			dependency "javax.mail:javax.mail-api:1.6.2"
-			dependency "javax.money:money-api:1.0.3"
-			dependency "javax.resource:javax.resource-api:1.7.1"
-			dependency "javax.servlet:javax.servlet-api:4.0.1"
-			dependency "javax.servlet.jsp:javax.servlet.jsp-api:2.3.2-b02"
-			dependency "javax.servlet.jsp.jstl:javax.servlet.jsp.jstl-api:1.2.1"
-			dependency "javax.transaction:javax.transaction-api:1.3"
-			dependency "javax.validation:validation-api:2.0.1.Final"
-			dependency "javax.websocket:javax.websocket-api:1.1"
-			dependency "javax.xml.bind:jaxb-api:2.3.1"
-			dependency "javax.xml.ws:jaxws-api:2.3.1"
-
-			dependency "org.eclipse.persistence:javax.persistence:2.2.0"
-
-			// Substitute for "javax.management:jmxremote_optional:1.0.1_04" which
-			// is not available on Maven Central
-			dependency "org.glassfish.external:opendmk_jmxremote_optional_jar:1.0-b01-ea"
-			dependency "org.glassfish:javax.el:3.0.1-b08"
-			dependency "org.glassfish.main:javax.jws:4.0-b33"
-			dependency "org.glassfish.tyrus:tyrus-container-servlet:1.13.1"
+		maven { url "https://repo.spring.io/libs-spring-framework-build" }
+		if (version.contains('-')) {
+			maven { url "https://repo.spring.io/milestone" }
 		}
-		generatedPomCustomization {
-			enabled = false
-		}
-		resolutionStrategy {
-			cacheChangingModulesFor 0, "seconds"
-		}
-		repositories {
-			mavenCentral()
-			maven { url "https://repo.spring.io/libs-spring-framework-build" }
+		if (version.endsWith('-SNAPSHOT')) {
+			maven { url "https://repo.spring.io/snapshot" }
 		}
 	}
 	configurations.all {
@@ -308,27 +50,17 @@ configure([rootProject] + javaProjects) { project ->
 	apply plugin: "java"
 	apply plugin: "java-test-fixtures"
 	apply plugin: "checkstyle"
-	apply plugin: 'org.springframework.build.compile'
+	apply plugin: 'org.springframework.build.conventions'
 	apply from: "${rootDir}/gradle/toolchains.gradle"
 	apply from: "${rootDir}/gradle/ide.gradle"

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

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

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

+	tasks.named("checkstyleMain").configure {
+		maxHeapSize = "1g"
+	}
+
+	tasks.named("checkstyleTest").configure {
+		maxHeapSize = "1g"
+	}
+
 	dependencies {
+		dependencyManagement(enforcedPlatform(dependencies.project(path: ":framework-platform")))
 		testImplementation("org.junit.jupiter:junit-jupiter-api")
 		testImplementation("org.junit.jupiter:junit-jupiter-params")
 		testImplementation("org.junit.platform:junit-platform-suite-api")
@@ -362,35 +109,33 @@ configure([rootProject] + javaProjects) { project ->
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
-		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.41")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.31")
 	}

 	ext.javadocLinks = [
-			"https://docs.oracle.com/javase/8/docs/api/",
-			"https://docs.oracle.com/javaee/7/api/",
+			"https://docs.oracle.com/en/java/javase/17/docs/api/",
+			"https://jakarta.ee/specifications/platform/9/apidocs/",
 			"https://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/",  // CommonJ
 			"https://www.ibm.com/docs/api/v1/content/SSEQTP_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/",
 			"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/",
 			"https://docs.jboss.org/jbossas/javadoc/7.1.2.Final/",
-			"https://tiles.apache.org/tiles-request/apidocs/",
-			"https://tiles.apache.org/framework/apidocs/",
 			"https://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
-			// Temporarily commenting out Ehcache and Quartz since javadoc on JDK 8 cannot access them.
-			// "https://www.ehcache.org/apidocs/2.10.4/",
-			// "https://www.quartz-scheduler.org/api/2.3.0/",
-			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/2.12.7/",
-			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.12.7/",
-			"https://www.javadoc.io/doc/com.fasterxml.jackson.dataformat/jackson-dataformat-xml/2.12.7/",
-			"https://hc.apache.org/httpcomponents-client-5.1.x/current/httpclient5/apidocs/",
+			"https://www.quartz-scheduler.org/api/2.3.0/",
+			"https://fasterxml.github.io/jackson-core/javadoc/2.10/",
+			"https://fasterxml.github.io/jackson-databind/javadoc/2.10/",
+			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.10/",
+			"https://hc.apache.org/httpcomponents-client-5.2.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
-			// Disabling linking to JUnit 5.8.2, since the `package-list` file no longer exists due to
-			// https://github.com/junit-team/junit5/commit/67ad4e545518b0ce2b0e7c96df31a669866d5003.
-			// "https://junit.org/junit5/docs/5.8.2/api/",
+			// TODO Uncomment link to JUnit 5 docs once we have sorted out
+			// the following warning in the build.
+			//
+			// warning: The code being documented uses packages in the unnamed module, but the packages defined in https://junit.org/junit5/docs/5.9.1/api/ are in named modules.
+			//
+			// "https://junit.org/junit5/docs/5.9.1/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
-			// Temporarily commenting out R2DBC since javadoc on JDK 8 cannot access it.
-			// "https://r2dbc.io/spec/0.8.5.RELEASE/api/",
+			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
 			// The external Javadoc link for JSR 305 must come last to ensure that types from
 			// JSR 250 (such as @PostConstruct) are still supported. This is due to the fact
 			// that JSR 250 and JSR 305 both define types in javax.annotation, which results
@@ -407,17 +152,14 @@ configure(moduleProjects) { project ->
 configure(rootProject) {
 	description = "Spring Framework"

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

 	nohttp {
 		source.exclude "**/test-output/**"
 		allowlistFile = project.file("src/nohttp/allowlist.lines")
 		def rootPath = file(rootDir).toPath()
-		def projectDirs = allprojects.collect { it.projectDir } + "${rootDir}/spring-core-test" + "${rootDir}/buildSrc" + "${rootDir}/framework-docs"
+		def projectDirs = allprojects.collect { it.projectDir } + "${rootDir}/buildSrc"
 		projectDirs.forEach { dir ->
 			[ 'bin', 'build', 'out', '.settings' ]
 				.collect { rootPath.relativize(new File(dir, it).toPath()) }
@@ -432,14 +174,4 @@ configure(rootProject) {
 		maxHeapSize = "1g"
 	}

-	publishing {
-		publications {
-			mavenJava(MavenPublication) {
-				artifact docsZip
-				artifact schemaZip
-				artifact distZip
-			}
-		}
-	}
-
 }
@@ -5,9 +5,12 @@ They are declared in the `build.gradle` file in this folder.

 ## Build Conventions

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

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

 ## Build Plugins

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

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

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

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

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

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

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

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

 	private static final List<String> COMPILER_ARGS;

@@ -59,9 +58,8 @@ public class CompilerConventionsPlugin implements Plugin<Project> {
 				"-Xlint:-deprecation", "-Xlint:-unchecked"));
 	}

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

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

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

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

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

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

 	private static final String BASELINE_VERSION_PROPERTY = "baselineVersion";

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

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

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

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

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

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

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

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

 === Setting up your development environment

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

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

 NOTE: This assumes that you have credhub integration configured with the appropriate secrets.
@@ -17,4 +17,4 @@ changelog:
        - "type: dependency-upgrade"
  contributors:
    exclude:
-      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll", "simonbasle"]
+      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll"]
@@ -1,10 +1,12 @@
-FROM ubuntu:jammy-20240125
+FROM ubuntu:focal-20220922

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

-ENV JAVA_HOME /opt/openjdk/java8
+ENV 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,11 +2,14 @@
 set -e

 case "$1" in
-	java8)
-		 echo "https://github.com/bell-sw/Liberica/releases/download/8u402%2B7/bellsoft-jdk8u402+7-linux-amd64.tar.gz"
-	;;
 	java17)
-		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.10%2B13/bellsoft-jdk17.0.10+13-linux-amd64.tar.gz"
+		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.5+8/bellsoft-jdk17.0.5+8-linux-amd64.tar.gz"
+	;;
+	java18)
+		echo "https://github.com/bell-sw/Liberica/releases/download/18.0.2.1%2B1/bellsoft-jdk18.0.2.1+1-linux-amd64.tar.gz"
+	;;
+	java19)
+		echo "https://github.com/bell-sw/Liberica/releases/download/19.0.1%2B11/bellsoft-jdk19.0.1+11-linux-amd64.tar.gz"
 	;;
 	*)
 		echo $"Unknown java version"
@@ -20,7 +20,7 @@ curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/c

 mkdir -p /opt/openjdk
 pushd /opt/openjdk > /dev/null
-for jdk in java8 java17
+for jdk in java17 java18 java19
 do
  JDK_URL=$( /get-jdk-url.sh $jdk )
  mkdir $jdk
@@ -3,8 +3,12 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "5.3.x"
-milestone: "5.3.x"
+branch: "main"
+milestone: "6.0.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
+registry-mirror-host: docker.repo.spring.io
+registry-mirror-username: ((artifactory-username))
+registry-mirror-password: ((artifactory-password))
+task-timeout: 1h00m
@@ -5,7 +5,9 @@ anchors:
    password: ((github-ci-release-token))
    branch: ((branch))
  gradle-enterprise-task-params: &gradle-enterprise-task-params
-    DEVELOCITY_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
+    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))
@@ -21,6 +23,19 @@ anchors:
  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!>
+      [$TEXT_FILE_CONTENT]
+    text_file: git-repo/build/build-scan-uri.txt
+    silent: true
+    icon_emoji: ":concourse:"
+    username: concourse-ci
  changelog-task-params: &changelog-task-params
    name: generated-changelog/tag
    tag: generated-changelog/tag
@@ -33,27 +48,33 @@ resource_types:
 - name: registry-image
  type: registry-image
  source:
-    <<: *docker-resource-source
    repository: concourse/registry-image-resource
-    tag: 1.8.0
+    tag: 1.5.0
 - name: artifactory-resource
  type: registry-image
  source:
-    <<: *docker-resource-source
    repository: springio/artifactory-resource
-    tag: 0.0.18
+    tag: 0.0.17
 - name: github-release
  type: registry-image
  source:
-    <<: *docker-resource-source
    repository: concourse/github-release-resource
-    tag: 1.8.0
+    tag: 1.5.5
 - name: github-status-resource
  type: registry-image
  source:
-    <<: *docker-resource-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
@@ -73,7 +94,13 @@ resources:
  source:
    <<: *docker-resource-source
    repository: ((docker-hub-organization))/spring-framework-ci
-    tag: ((milestone))
+- name: every-morning
+  type: time
+  icon: alarm
+  source:
+    start: 8:00 AM
+    stop: 9:00 AM
+    location: Europe/Vienna
 - name: artifactory-repo
  type: artifactory-resource
  icon: package-variant
@@ -82,6 +109,43 @@ 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
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: 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: 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: jdk19-build
+- name: slack-alert
+  type: slack-notification
+  icon: slack
+  source:
+    url: ((slack-webhook-url))
 - name: github-pre-release
  type: github-release
  icon: briefcase-download-outline
@@ -112,27 +176,41 @@ jobs:
        image: ci-image
      vars:
        ci-image-name: ci-image
-        <<: *docker-resource-source
+        <<: *registry-mirror-vars
    - put: ci-image
      params:
        image: ci-image/image.tar
- name: stage-milestone
+- name: build
  serial: true
+  public: true
  plan:
  - get: ci-image
  - get: git-repo
-    trigger: false
-  - task: stage
-    image: ci-image
-    file: git-repo/ci/tasks/stage-version.yml
-    params:
-      RELEASE_TYPE: M
-      <<: *gradle-enterprise-task-params
+    trigger: true
+  - put: repo-status-build
+    params: { state: "pending", commit: "git-repo" }
+  - do:
+    - task: build-project
+      image: ci-image
+      file: git-repo/ci/tasks/build-project.yml
+      privileged: true
+      timeout: ((task-timeout))
+      params:
+        <<: *build-project-task-params
+    on_failure:
+      do:
+      - put: repo-status-build
+        params: { state: "failure", commit: "git-repo" }
+      - put: slack-alert
+        params:
+          <<: *slack-fail-params
+  - put: repo-status-build
+    params: { state: "success", commit: "git-repo" }
  - put: artifactory-repo
    params: &artifactory-params
      signing_key: ((signing-key))
      signing_passphrase: ((signing-passphrase))
-      repo: libs-staging-local
+      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}"
      build_number: "${BUILD_PIPELINE_NAME}-${BUILD_JOB_NAME}-${BUILD_NAME}"
@@ -140,26 +218,131 @@ 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"
-  - put: git-repo
-    params:
-      repository: stage-git-repo
+    get_params:
+      threads: 8
+- name: jdk18-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk18-build
+      params: { state: "pending", commit: "git-repo" }
+    - do:
+        - task: check-project
+          image: ci-image
+          file: git-repo/ci/tasks/check-project.yml
+          privileged: true
+          timeout: ((task-timeout))
+          params:
+            TEST_TOOLCHAIN: 18
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk18-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - 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: ci-image
+    - get: git-repo
+      trigger: false
+    - task: stage
+      image: ci-image
+      file: git-repo/ci/tasks/stage-version.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+        repo: libs-staging-local
+    - put: git-repo
+      params:
+        repository: stage-git-repo
 - name: promote-milestone
  serial: true
  plan:
@@ -200,6 +383,7 @@ jobs:
    - put: artifactory-repo
      params:
        <<: *artifactory-params
+        repo: libs-staging-local
    - put: git-repo
      params:
        repository: stage-git-repo
@@ -243,6 +427,7 @@ jobs:
    - put: artifactory-repo
      params:
        <<: *artifactory-params
+        repo: libs-staging-local
    - put: git-repo
      params:
        repository: stage-git-repo
@@ -285,7 +470,11 @@ jobs:
        <<: *changelog-task-params

 groups:
+- name: "builds"
+  jobs: ["build", "jdk18-build", "jdk19-build"]
 - name: "releases"
  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
 - name: "ci-images"
  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
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+repository=$(pwd)/distribution-repository
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
+popd > /dev/null
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK18 \
+  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check
+popd > /dev/null
@@ -5,8 +5,10 @@ image_resource:
  source:
    repository: concourse/oci-build-task
    tag: 0.10.0
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
+    registry_mirror:
+      host: ((registry-mirror-host))
+      username: ((registry-mirror-username))
+      password: ((registry-mirror-password))
 inputs:
  - name: ci-images-git-repo
 outputs:
@@ -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
@@ -0,0 +1,22 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: distribution-repository
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/build-project.sh
@@ -0,0 +1,24 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: distribution-repository
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  MAIN_TOOLCHAIN:
+  TEST_TOOLCHAIN:
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/check-project.sh
@@ -5,8 +5,6 @@ image_resource:
  source:
    repository: springio/github-changelog-generator
    tag: '0.0.8'
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
 inputs:
 - name: git-repo
 - name: artifactory-repo
@@ -4,9 +4,7 @@ image_resource:
  type: registry-image
  source:
    repository: springio/concourse-release-scripts
-    tag: '0.4.0'
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
+    tag: '0.3.4'
 inputs:
 - name: git-repo
 - name: artifactory-repo
@@ -1,17 +1,42 @@
+description = "Spring Framework Docs"
+
+apply plugin: 'kotlin'
+apply plugin: 'org.asciidoctor.jvm.convert'
+apply plugin: 'org.asciidoctor.jvm.pdf'
+apply from: "${rootDir}/gradle/publications.gradle"
+
+
 configurations {
-	asciidoctorExt
+	asciidoctorExtensions
 }

 dependencies {
-	asciidoctorExt("io.spring.asciidoctor:spring-asciidoctor-extensions-block-switch:0.6.1")
+	api(project(":spring-context"))
+	api(project(":spring-web"))
+
+	implementation(project(":spring-core-test"))
+	implementation("org.assertj:assertj-core")
+}
+
+checkstyle {
+	sourceSets = []
+}
+
+jar {
+	enabled = false
+}
+
+javadoc {
+	enabled = false
+}
+
+dependencies {
+	asciidoctorExtensions "io.spring.asciidoctor.backends:spring-asciidoctor-backends:0.0.3"
 }

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

@@ -42,15 +67,11 @@ task api(type: Javadoc) {
 		author = true
 		header = rootProject.description
 		use = true
-		overview = "src/docs/api/overview.html"
-		stylesheetFile = file("src/docs/api/stylesheet.css")
+		overview = "framework-docs/src/docs/api/overview.html"
 		splitIndex = true
 		links(project.ext.javadocLinks)
 		addBooleanOption('Xdoclint:syntax', true) // only check syntax with doclint
-		addBooleanOption('Xwerror', true) // fail build on Javadoc warnings
-		if (JavaVersion.current().isJava9Compatible()) {
-			addBooleanOption('html5', true)
-		}
+		addBooleanOption('Werror', true) // fail build on Javadoc warnings
 	}
 	source moduleProjects.collect { project ->
 		project.sourceSets.main.allJava
@@ -62,73 +83,48 @@ task api(type: Javadoc) {
 /**
 * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
 */
-pluginManager.withPlugin("kotlin") {
-	tasks.dokkaHtmlMultiModule.configure {
-		dependsOn {
-			tasks.getByName("api")
-		}
-		moduleName.set("spring-framework")
-		outputDirectory.set(project.file("$buildDir/docs/kdoc"))
+rootProject.tasks.dokkaHtmlMultiModule.configure {
+	dependsOn {
+		tasks.getByName("api")
 	}
-}
-
-task downloadResources(type: Download) {
-	src "https://repo.spring.io/artifactory/snapshot/io/spring/docresources/" +
-			"spring-doc-resources/0.2.6-SNAPSHOT/spring-doc-resources-0.2.6-20210308.231804-2.zip"
-	dest project.file("$buildDir/docs/spring-doc-resources.zip")
-	onlyIfModified true
-	useETag "all"
-}
-
-task extractDocResources(type: Copy, dependsOn: downloadResources) {
-	from project.zipTree(downloadResources.dest);
-	into "$buildDir/docs/spring-docs-resources/"
+	moduleName.set("spring-framework")
+	outputDirectory.set(project.file("$buildDir/docs/kdoc"))
 }

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

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

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

 /**
 * Zip all docs (API and reference) into a single archive
 */
-task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', 'dokkaHtmlMultiModule']) {
+task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', rootProject.tasks.dokkaHtmlMultiModule]) {
 	group = "Distribution"
 	description = "Builds -${archiveClassifier} archive containing api and reference " +
 			"for deployment at https://docs.spring.io/spring-framework/docs/."
@@ -168,7 +167,7 @@ task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', 'dok
 	from ("$asciidoctorPdf.outputDir") {
 		into "reference/pdf"
 	}
-	from (dokkaHtmlMultiModule.outputDirectory) {
+	from (rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
 		into "kdoc-api"
 	}
 }
@@ -247,3 +246,14 @@ task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
 }

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

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

 This part of the reference documentation covers all the technologies that are
 absolutely integral to the Spring Framework.
@@ -19,6 +17,9 @@ Coverage of Spring's integration with AspectJ (currently the richest -- in terms
 features -- and certainly most mature AOP implementation in the Java enterprise space)
 is also provided.

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

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

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

+include::core/core-aot.adoc[leveloffset=+1]
+
 include::core/core-appendix.adoc[leveloffset=+1]
@@ -1755,5 +1755,5 @@ support for new custom advice types be added without changing the core framework
 The only constraint on a custom `Advice` type is that it must implement the
 `org.aopalliance.aop.Advice` marker interface.

-See the {api-spring-framework}/aop/framework/adapter/package-frame.html[`org.springframework.aop.framework.adapter`]
+See the {api-spring-framework}/aop/framework/adapter/package-summary.html[`org.springframework.aop.framework.adapter`]
 javadoc for further information.
@@ -262,8 +262,8 @@ element, as the following example shows:
 ----

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


@@ -1516,57 +1516,18 @@ check the type of the elements.
 [[aop-ataspectj-advice-params-names]]
 ===== Determining Argument Names

-Parameter binding in advice invocations relies on matching the names used in pointcut
-expressions to the parameter names declared in advice and pointcut method signatures.
+The parameter binding in advice invocations relies on matching names used in pointcut
+expressions to declared parameter names in advice and pointcut method signatures.
+Parameter names are not available through Java reflection, so Spring AOP uses the
+following strategy to determine parameter names:

-NOTE: This section uses the terms _argument_ and _parameter_ interchangeably, since
-AspectJ APIs refer to parameter names as argument names.
+* If the parameter names have been explicitly specified by the user, the specified
+  parameter names are used. Both the advice and the pointcut annotations have
+  an optional `argNames` attribute that you can use to specify the argument names of
+  the annotated method. These argument names are available at runtime. The following example
+  shows how to use the `argNames` attribute:

-Spring AOP uses the following `ParameterNameDiscoverer` implementations to determine
-parameter names. Each discoverer will be given a chance to discover parameter names, and
-the first successful discoverer wins. If none of the registered discoverers is capable
-of determining parameter names, an exception will be thrown.
-
-`AspectJAnnotationParameterNameDiscoverer` :: Uses parameter names that have been explicitly
-  specified by the user via the `argNames` attribute in the corresponding advice or
-  pointcut annotation. See <<aop-ataspectj-advice-params-names-explicit>> for details.
-`KotlinReflectionParameterNameDiscoverer` :: Uses Kotlin reflection APIs to determine
-  parameter names. This discoverer is only used if such APIs are present on the classpath.
-  Not supported in a GraalVM native image.
-`StandardReflectionParameterNameDiscoverer` :: Uses the standard `java.lang.reflect.Parameter`
-  API to determine parameter names. Requires that code be compiled with the `-parameters`
-  flag for `javac`. Recommended approach on Java 8+.
-`LocalVariableTableParameterNameDiscoverer` :: Analyzes the local variable table available
-  in the byte code of the advice class to determine parameter names from debug information.
-  Requires that code be compiled with debug symbols (`-g:vars` at a minimum). Deprecated
-  as of Spring Framework 6.0 for removal in Spring Framework 6.1 in favor of compiling
-  code with `-parameters`. Not supported in a GraalVM native image unless the corresponding
-  class files are present as resources within the image.
-`AspectJAdviceParameterNameDiscoverer` :: Deduces parameter names from the pointcut
-  expression, `returning`, and `throwing` clauses. See the
-  {api-spring-framework}/aop/aspectj/AspectJAdviceParameterNameDiscoverer.html[javadoc]
-  for details on the algorithm used.
-
-[[aop-ataspectj-advice-params-names-explicit]]
-===== Explicit Argument Names
-
-@AspectJ advice and pointcut annotations have an optional `argNames` attribute that you
-can use to specify the argument names of the annotated method.
-
-[TIP]
-====
-If an @AspectJ aspect has been compiled by the AspectJ compiler (`ajc`) even without
-debug information, you do not need to add the `argNames` attribute, since the compiler
-retains the needed information.
-
-Similarly, if an @AspectJ aspect has been compiled with `javac` using the `-parameters`
-flag, you do not need to add the `argNames` attribute, since the compiler retains the
-needed information.
-====
-
-The following example shows how to use the `argNames` attribute:
-
-[source,java,indent=0,subs="verbatim",role="primary"]
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
 	@Before(value="com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditable)",
@@ -1576,7 +1537,7 @@ The following example shows how to use the `argNames` attribute:
 		// ... use code and bean
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	@Before(value = "com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditable)", argNames = "bean,auditable")
@@ -1585,12 +1546,14 @@ The following example shows how to use the `argNames` attribute:
 		// ... use code and bean
 	}
 ----
-If the first parameter is of type `JoinPoint`, `ProceedingJoinPoint`, or
-`JoinPoint.StaticPart`, you can omit the name of the parameter from the value of the
-`argNames` attribute. For example, if you modify the preceding advice to receive the join
-point object, the `argNames` attribute does not need to include it:

-[source,java,indent=0,subs="verbatim",role="primary"]
+
+If the first parameter is of the `JoinPoint`, `ProceedingJoinPoint`, or
+`JoinPoint.StaticPart` type, you can leave out the name of the parameter from the value
+of the `argNames` attribute. For example, if you modify the preceding advice to receive
+the join point object, the `argNames` attribute need not include it:
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
 	@Before(value="com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditable)",
@@ -1600,7 +1563,7 @@ point object, the `argNames` attribute does not need to include it:
 		// ... use code, bean, and jp
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	@Before(value = "com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditable)", argNames = "bean,auditable")
@@ -1610,13 +1573,13 @@ point object, the `argNames` attribute does not need to include it:
 	}
 ----

-The special treatment given to the first parameter of type `JoinPoint`,
-`ProceedingJoinPoint`, or `JoinPoint.StaticPart` is particularly convenient for advice
-methods that do not collect any other join point context. In such situations, you may
-omit the `argNames` attribute. For example, the following advice does not need to declare
+The special treatment given to the first parameter of the `JoinPoint`,
+`ProceedingJoinPoint`, and `JoinPoint.StaticPart` types is particularly convenient for
+advice instances that do not collect any other join point context. In such situations, you may
+omit the `argNames` attribute. For example, the following advice need not declare
 the `argNames` attribute:

-[source,java,indent=0,subs="verbatim",role="primary"]
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
 	@Before("com.xyz.lib.Pointcuts.anyPublicMethod()")
@@ -1624,7 +1587,7 @@ the `argNames` attribute:
 		// ... use jp
 	}
 ----
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
 	@Before("com.xyz.lib.Pointcuts.anyPublicMethod()")
@@ -1633,6 +1596,28 @@ 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
+  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
+  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
+retain the needed information.
+
+* If the code has been compiled without the necessary debug information, Spring AOP
+  tries to deduce the pairing of binding variables to parameters (for example, if
+  only one variable is bound in the pointcut expression, and the advice method
+  takes only one parameter, the pairing is obvious). If the binding of variables is
+  ambiguous given the available information, an `AmbiguousBindingException` is
+  thrown.
+* If all of the above strategies fail, an `IllegalArgumentException` is thrown.
+
 [[aop-ataspectj-advice-proceeding-with-the-call]]
 ===== Proceeding with Arguments

@@ -2006,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
@@ -3517,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"]
@@ -3616,7 +3601,7 @@ visibility may be annotated, including private methods. Annotating non-public me
 directly is the only way to get transaction demarcation for the execution of such methods.

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

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




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

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



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

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


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

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

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

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

 	public enum PersistenceContextType {

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

 	enum class PersistenceContextType {

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


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

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

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

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


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

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


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

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


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

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


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

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



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

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



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

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


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

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


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

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


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

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


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

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


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

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


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

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



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

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

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



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

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


 To create new XML configuration extensions:

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

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



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

 Creating an XML configuration extension for use with Spring's IoC container starts with
@@ -765,7 +766,7 @@ defined in the enumeration.



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

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



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

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



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

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


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

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


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

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



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

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



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

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


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

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

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

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

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

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


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

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


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

 This part of the appendix lists the existing `StartupSteps` that the core container is instrumented with.
@@ -125,7 +125,7 @@ release it immediately, it can do so via `DataBufferUtils.release(dataBuffer)`.
 . If a `Decoder` is using `Flux` or `Mono` operators such as `flatMap`, `reduce`, and
 others that prefetch and cache data items internally, or is using operators such as
 `filter`, `skip`, and others that leave out items, then
-`doOnDiscard(PooledDataBuffer.class, DataBufferUtils::release)` must be added to the
+`doOnDiscard(DataBuffer.class, DataBufferUtils::release)` must be added to the
 composition chain to ensure such buffers are released prior to being discarded, possibly
 also as a result of an error or cancellation signal.
 . If a `Decoder` holds on to one or more data buffers in any other way, it must
@@ -744,42 +744,25 @@ topics:
 [[expressions-ref-literal]]
 === Literal Expressions

-SpEL supports the following types of literal expressions.
+The types of literal expressions supported are strings, numeric values (int, real, hex),
+boolean, and null. Strings are delimited by single quotation marks. To put a single quotation mark itself
+in a string, use two single quotation mark characters.

- strings
- numeric values: integer (`int` or `long`), hexadecimal (`int` or `long`), real (`float`
-  or `double`)
- boolean values: `true` or `false`
- null
-
-Strings can delimited by single quotation marks (`'`) or double quotation marks (`"`). To
-include a single quotation mark within a string literal enclosed in single quotation
-marks, use two adjacent single quotation mark characters. Similarly, to include a double
-quotation mark within a string literal enclosed in double quotation marks, use two
-adjacent double quotation mark characters.
-
-Numbers support the use of the negative sign, exponential notation, and decimal points.
-By default, real numbers are parsed by using `Double.parseDouble()`.
-
-The following listing shows simple usage of literals. Typically, they are not used in
-isolation like this but, rather, as part of a more complex expression -- for example,
-using a literal on one side of a logical comparison operator or as an argument to a
-method.
+The following listing shows simple usage of literals. Typically, they are not used
+in isolation like this but, rather, as part of a more complex expression -- for example,
+using a literal on one side of a logical comparison operator.

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
 	ExpressionParser parser = new SpelExpressionParser();

-	// evaluates to "Hello World"
+	// evals to "Hello World"
 	String helloWorld = (String) parser.parseExpression("'Hello World'").getValue();

-	// evaluates to "Tony's Pizza"
-	String pizzaParlor = (String) parser.parseExpression("'Tony''s Pizza'").getValue();
-
 	double avogadrosNumber = (Double) parser.parseExpression("6.0221415E+23").getValue();

-	// evaluates to 2147483647
+	// evals to 2147483647
 	int maxValue = (Integer) parser.parseExpression("0x7FFFFFFF").getValue();

 	boolean trueValue = (Boolean) parser.parseExpression("true").getValue();
@@ -791,15 +774,12 @@ method.
 ----
 	val parser = SpelExpressionParser()

-	// evaluates to "Hello World"
+	// evals to "Hello World"
 	val helloWorld = parser.parseExpression("'Hello World'").value as String

-	// evaluates to "Tony's Pizza"
-	val pizzaParlor = parser.parseExpression("'Tony''s Pizza'").value as String
-
 	val avogadrosNumber = parser.parseExpression("6.0221415E+23").value as Double

-	// evaluates to 2147483647
+	// evals to 2147483647
 	val maxValue = parser.parseExpression("0x7FFFFFFF").value as Int

 	val trueValue = parser.parseExpression("true").value as Boolean
@@ -807,6 +787,9 @@ method.
 	val nullValue = parser.parseExpression("null").value
 ----

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


 [[expressions-properties-arrays]]
@@ -821,7 +804,7 @@ Pupin's city of birth, we use the following expressions:
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
 ----
-	// evaluates to 1856
+	// evals to 1856
 	int year = (Integer) parser.parseExpression("birthdate.year + 1900").getValue(context);

 	String city = (String) parser.parseExpression("placeOfBirth.city").getValue(context);
@@ -829,7 +812,7 @@ Pupin's city of birth, we use the following expressions:
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 .Kotlin
 ----
-	// evaluates to 1856
+	// evals to 1856
 	val year = parser.parseExpression("birthdate.year + 1900").getValue(context) as Int

 	val city = parser.parseExpression("placeOfBirth.city").getValue(context) as String
@@ -1069,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
@@ -1083,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
@@ -1095,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]
@@ -1577,22 +1577,20 @@ For example, the following Java configuration registers a global `yyyyMMdd` form
 		public FormattingConversionService conversionService() {

 			// Use the DefaultFormattingConversionService but do not register defaults
-			DefaultFormattingConversionService conversionService =
-				new DefaultFormattingConversionService(false);
+			DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService(false);

 			// Ensure @NumberFormat is still supported
-			conversionService.addFormatterForFieldAnnotation(
-				new NumberFormatAnnotationFormatterFactory());
+			conversionService.addFormatterForFieldAnnotation(new NumberFormatAnnotationFormatterFactory());

 			// Register JSR-310 date conversion with a specific global format
-			DateTimeFormatterRegistrar dateTimeRegistrar = new DateTimeFormatterRegistrar();
-			dateTimeRegistrar.setDateFormatter(DateTimeFormatter.ofPattern("yyyyMMdd"));
-			dateTimeRegistrar.registerFormatters(conversionService);
+			DateTimeFormatterRegistrar registrar = new DateTimeFormatterRegistrar();
+			registrar.setDateFormatter(DateTimeFormatter.ofPattern("yyyyMMdd"));
+			registrar.registerFormatters(conversionService);

 			// Register date conversion with a specific global format
-			DateFormatterRegistrar dateRegistrar = new DateFormatterRegistrar();
-			dateRegistrar.setFormatter(new DateFormatter("yyyyMMdd"));
-			dateRegistrar.registerFormatters(conversionService);
+			DateFormatterRegistrar registrar = new DateFormatterRegistrar();
+			registrar.setFormatter(new DateFormatter("yyyyMMdd"));
+			registrar.registerFormatters(conversionService);

 			return conversionService;
 		}
@@ -1613,14 +1611,14 @@ For example, the following Java configuration registers a global `yyyyMMdd` form
 				addFormatterForFieldAnnotation(NumberFormatAnnotationFormatterFactory())

 				// Register JSR-310 date conversion with a specific global format
-				val dateTimeRegistrar = DateTimeFormatterRegistrar()
-				dateTimeRegistrar.setDateFormatter(DateTimeFormatter.ofPattern("yyyyMMdd"))
-				dateTimeRegistrar.registerFormatters(this)
+				val registrar = DateTimeFormatterRegistrar()
+				registrar.setDateFormatter(DateTimeFormatter.ofPattern("yyyyMMdd"))
+				registrar.registerFormatters(this)

 				// Register date conversion with a specific global format
-				val dateRegistrar = DateFormatterRegistrar()
-				dateRegistrar.setFormatter(DateFormatter("yyyyMMdd"))
-				dateRegistrar.registerFormatters(this)
+				val registrar = DateFormatterRegistrar()
+				registrar.setFormatter(DateFormatter("yyyyMMdd"))
+				registrar.registerFormatters(this)
 			}
 		}
 	}
@@ -1636,7 +1634,7 @@ If you prefer XML-based configuration, you can use a
 		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		xsi:schemaLocation="
 			http://www.springframework.org/schema/beans
-			https://www.springframework.org/schema/beans/spring-beans.xsd>
+			https://www.springframework.org/schema/beans/spring-beans.xsd">

 		<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
 			<property name="registerDefaultFormatters" value="false" />
@@ -1741,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:
@@ -1776,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 {
@@ -1799,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)
@@ -1836,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
@@ -1872,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 {

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

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

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

 This part of the reference documentation is concerned with data access and the
 interaction between the data access layer and the business or service layer.
@@ -58,7 +56,7 @@ and <<transaction-solutions-to-common-problems, solutions to common problems>>.
 [[transaction-motivation]]
 === Advantages of the Spring Framework's Transaction Support Model

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

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

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

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

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

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

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

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

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

-If you use Hibernate and Java EE container-managed JTA transactions, you should use the
+If you use Hibernate and Jakarta EE container-managed JTA transactions, you should use the
 same `JtaTransactionManager` as in the previous JTA example for JDBC, as the following
 example shows. Also, it is recommended to make Hibernate aware of JTA through its
 transaction coordinator and possibly also its connection release mode configuration:
@@ -502,7 +500,7 @@ behind the scenes and you need not write any special code.
 At the very lowest level exists the `TransactionAwareDataSourceProxy` class. This is a
 proxy for a target `DataSource`, which wraps the target `DataSource` to add awareness of
 Spring-managed transactions. In this respect, it is similar to a transactional JNDI
-`DataSource`, as provided by a Java EE server.
+`DataSource`, as provided by a Jakarta EE server.

 You should almost never need or want to use this class, except when existing
 code must be called and passed a standard JDBC `DataSource` interface implementation. In
@@ -1042,40 +1040,45 @@ including checked exceptions by specifying _rollback rules_.
 [NOTE]
 ====
 Rollback rules determine if a transaction should be rolled back when a given exception is
-thrown, and the rules are based on patterns. A pattern can be a fully qualified class
-name or a substring of a fully qualified class name for an exception type (which must be
-a subclass of `Throwable`), with no wildcard support at present. For example, a value of
-`"javax.servlet.ServletException"` or `"ServletException"` will match
-`javax.servlet.ServletException` and its subclasses.
+thrown, and the rules are based on exception types or exception patterns.

 Rollback rules may be configured in XML via the `rollback-for` and `no-rollback-for`
-attributes, which allow patterns to be specified as strings. When using
+attributes, which allow rules to be defined as patterns. When using
 <<transaction-declarative-attransactional-settings,`@Transactional`>>, rollback rules may
 be configured via the `rollbackFor`/`noRollbackFor` and
-`rollbackForClassName`/`noRollbackForClassName` attributes, which allow patterns to be
-specified as `Class` references or strings, respectively. When an exception type is
-specified as a class reference its fully qualified name will be used as the pattern.
-Consequently, `@Transactional(rollbackFor = example.CustomException.class)` is equivalent
-to `@Transactional(rollbackForClassName = "example.CustomException")`.
+`rollbackForClassName`/`noRollbackForClassName` attributes, which allow rules to be
+defined based on exception types or patterns, respectively.
+
+When a rollback rule is defined with an exception type, that type will be used to match
+against the type of a thrown exception and its super types, providing type safety and
+avoiding any unintentional matches that may occur when using a pattern. For example, a
+value of `jakarta.servlet.ServletException.class` will only match thrown exceptions of
+type `jakarta.servlet.ServletException` and its subclasses.
+
+When a rollback rule is defined with an exception pattern, the pattern can be a fully
+qualified class name or a substring of a fully qualified class name for an exception type
+(which must be a subclass of `Throwable`), with no wildcard support at present. For
+example, a value of `"jakarta.servlet.ServletException"` or `"ServletException"` will
+match `jakarta.servlet.ServletException` and its subclasses.

 [WARNING]
 =====
-You must carefully consider how specific the pattern is and whether to include package
+You must carefully consider how specific a pattern is and whether to include package
 information (which isn't mandatory). For example, `"Exception"` will match nearly
 anything and will probably hide other rules. `"java.lang.Exception"` would be correct if
 `"Exception"` were meant to define a rule for all checked exceptions. With more unique
 exception names such as `"BaseBusinessException"` there is likely no need to use the
 fully qualified class name for the exception pattern.

-Furthermore, rollback rules may result in unintentional matches for similarly named
-exceptions and nested classes. This is due to the fact that a thrown exception is
-considered to be a match for a given rollback rule if the name of thrown exception
-contains the exception pattern configured for the rollback rule. For example, given a
-rule configured to match on `com.example.CustomException`, that rule would match against
-an exception named `com.example.CustomExceptionV2` (an exception in the same package as
-`CustomException` but with an additional suffix) or an exception named
-`com.example.CustomException$AnotherException` (an exception declared as a nested class
-in `CustomException`).
+Furthermore, pattern-based rollback rules may result in unintentional matches for
+similarly named exceptions and nested classes. This is due to the fact that a thrown
+exception is considered to be a match for a given pattern-based rollback rule if the name
+of the thrown exception contains the exception pattern configured for the rollback rule.
+For example, given a rule configured to match on `"com.example.CustomException"`, that
+rule will match against an exception named `com.example.CustomExceptionV2` (an exception
+in the same package as `CustomException` but with an additional suffix) or an exception
+named `com.example.CustomException$AnotherException` (an exception declared as a nested
+class in `CustomException`).
 =====
 ====

@@ -1344,8 +1347,8 @@ source code puts the declarations much closer to the affected code. There is not
 danger of undue coupling, because code that is meant to be used transactionally is
 almost always deployed that way anyway.

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

 The ease-of-use afforded by the use of the `@Transactional` annotation is best
@@ -1455,6 +1458,7 @@ In XML configuration, the `<tx:annotation-driven/>` tag provides similar conveni
 ----
 <1> The line that makes the bean instance transactional.

+
 TIP: You can omit the `transaction-manager` attribute in the `<tx:annotation-driven/>`
 tag if the bean name of the `TransactionManager` that you want to wire in has the name
 `transactionManager`. If the `TransactionManager` bean that you want to dependency-inject
@@ -1562,27 +1566,30 @@ chapter for examples.
 ====

 You can apply the `@Transactional` annotation to an interface definition, a method
-on an interface, a class definition, or a method on a class. However, the mere presence
-of the `@Transactional` annotation is not enough to activate the transactional behavior.
-The `@Transactional` annotation is merely metadata that can be consumed by corresponding
-runtime infrastructure which uses that metadata to configure the appropriate beans with
-transactional behavior. In the preceding example, the `<tx:annotation-driven/>` element
-switches on actual transaction management at runtime.
+on an interface, a class definition, or a method on a class. However, the
+mere presence of the `@Transactional` annotation is not enough to activate the
+transactional behavior. The `@Transactional` annotation is merely metadata that can
+be consumed by some runtime infrastructure that is `@Transactional`-aware and that
+can use the metadata to configure the appropriate beans with transactional behavior.
+In the preceding example, the `<tx:annotation-driven/>` element switches on the
+transactional behavior.

-TIP: The Spring team recommends that you annotate methods of concrete classes with the
-`@Transactional` annotation, rather than relying on annotated methods in interfaces,
-even if the latter does work for interface-based and target-class proxies as of 5.0.
-Since Java annotations are not inherited from interfaces, interface-declared annotations
-are still not recognized by the weaving infrastructure when using AspectJ mode, so the
-aspect does not get applied. As a consequence, your transaction annotations may be
-silently ignored: Your code might appear to "work" until you test a rollback scenario.
+TIP: The Spring team recommends that you annotate only concrete classes (and methods of
+concrete classes) with the `@Transactional` annotation, as opposed to annotating interfaces.
+You certainly can place the `@Transactional` annotation on an interface (or an interface
+method), but this works only as you would expect it to if you use interface-based
+proxies. The fact that Java annotations are not inherited from interfaces means that,
+if you use class-based proxies (`proxy-target-class="true"`) or the weaving-based
+aspect (`mode="aspectj"`), the transaction settings are not recognized by the proxying
+and weaving infrastructure, and the object is not wrapped in a transactional proxy.

 NOTE: In proxy mode (which is the default), only external method calls coming in through
 the proxy are intercepted. This means that self-invocation (in effect, a method within
 the target object calling another method of the target object) does not lead to an actual
 transaction at runtime even if the invoked method is marked with `@Transactional`. Also,
 the proxy must be fully initialized to provide the expected behavior, so you should not
-rely on this feature in your initialization code -- e.g. in a `@PostConstruct` method.
+rely on this feature in your initialization code -- for example, in a `@PostConstruct`
+method.

 Consider using AspectJ mode (see the `mode` attribute in the following table) if you
 expect self-invocations to be wrapped with transactions as well. In this case, there is
@@ -1607,20 +1614,20 @@ is modified) to support `@Transactional` runtime behavior on any kind of method.
  framework (following proxy semantics, as discussed earlier, applying to method calls
  coming in through the proxy only). The alternative mode (`aspectj`) instead weaves the
  affected classes with Spring's AspectJ transaction aspect, modifying the target class
-  byte code to apply to any kind of method call. AspectJ weaving requires `spring-aspects.jar`
-  in the classpath as well as having load-time weaving (or compile-time weaving) enabled.
-  (See <<core.adoc#aop-aj-ltw-spring, Spring configuration>> for details on how to set up
-  load-time weaving.)
+  byte code to apply to any kind of method call. AspectJ weaving requires
+  `spring-aspects.jar` in the classpath as well as having load-time weaving (or compile-time
+  weaving) enabled. (See <<core.adoc#aop-aj-ltw-spring, Spring configuration>>
+  for details on how to set up load-time weaving.)

 | `proxy-target-class`
 | `proxyTargetClass`
 | `false`
 | Applies to `proxy` mode only. Controls what type of transactional proxies are created
-  for classes annotated with the `@Transactional` annotation. If the `proxy-target-class`
-  attribute is set to `true`, class-based proxies are created. If `proxy-target-class` is
-  `false` or if the attribute is omitted, then standard JDK interface-based proxies are
-  created. (See <<core.adoc#aop-proxying, Proxying Mechanisms>> for a detailed examination
-  of the different proxy types.)
+  for classes annotated with the `@Transactional` annotation. If the
+  `proxy-target-class` attribute is set to `true`, class-based proxies are created.
+  If `proxy-target-class` is `false` or if the attribute is omitted, then standard JDK
+  interface-based proxies are created. (See <<core.adoc#aop-proxying, Proxying Mechanisms>>
+  for a detailed examination of the different proxy types.)

 | `order`
 | `order`
@@ -1766,7 +1773,7 @@ properties of the `@Transactional` annotation:

 TIP: See <<transaction-declarative-rollback-rules, Rollback rules>> for further details
 on rollback rule semantics, patterns, and warnings regarding possible unintentional
-matches.
+matches for pattern-based rollback rules.

 Currently, you cannot have explicit control over the name of a transaction, where 'name'
 means the transaction name that appears in a transaction monitor, if applicable
@@ -1831,17 +1838,17 @@ The following listing shows the bean declarations:
 ----
 	<tx:annotation-driven/>

-		<bean id="transactionManager1" class="org.springframework.jdbc.support.JdbcTransactionManager">
+		<bean id="transactionManager1" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 			...
 			<qualifier value="order"/>
 		</bean>

-		<bean id="transactionManager2" class="org.springframework.jdbc.support.JdbcTransactionManager">
+		<bean id="transactionManager2" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 			...
 			<qualifier value="account"/>
 		</bean>

-		<bean id="transactionManager3" class="org.springframework.data.r2dbc.connection.R2dbcTransactionManager">
+		<bean id="transactionManager3" class="org.springframework.data.r2dbc.connectionfactory.R2dbcTransactionManager">
 			...
 			<qualifier value="reactive-account"/>
 		</bean>
@@ -1990,14 +1997,6 @@ status and with an inner transaction's locks released immediately after its comp
 Such an independent inner transaction can also declare its own isolation level, timeout,
 and read-only settings and not inherit an outer transaction's characteristics.

-NOTE: The resources attached to the outer transaction will remain bound there while
-the inner transaction acquires its own resources such as a new database connection.
-This may lead to exhaustion of the connection pool and potentially to a deadlock if
-several threads have an active outer transaction and wait to acquire a new connection
-for their inner transaction, with the pool not being able to hand out any such inner
-connection anymore. Do not use `PROPAGATION_REQUIRES_NEW` unless your connection pool
-is appropriately sized, exceeding the number of concurrent threads by at least 1.
-
 [[tx-propagation-nested]]
 ===== Understanding `PROPAGATION_NESTED`

@@ -2813,7 +2812,7 @@ supporting transaction suspension. See the
 {api-spring-framework}/transaction/jta/JtaTransactionManager.html[`JtaTransactionManager`]
 javadoc for details.

-Spring's `JtaTransactionManager` is the standard choice to run on Java EE application
+Spring's `JtaTransactionManager` is the standard choice to run on Jakarta EE application
 servers and is known to work on all common servers. Advanced functionality, such as
 transaction suspension, works on many servers as well (including GlassFish, JBoss and
 Geronimo) without any special configuration required. However, for fully supported
@@ -3028,10 +3027,10 @@ example shows:
 	}
 ----

-The last example we show here is for typical JDBC support. You could have the `DataSource`
-injected into an initialization method or a constructor, where you would create a `JdbcTemplate`
-and other data access support classes (such as `SimpleJdbcCall` and others) by using this
-`DataSource`. The following example autowires a `DataSource`:
+The last example we show here is for typical JDBC support. You could have the
+`DataSource` injected into an initialization method or a constructor, where you would create a
+`JdbcTemplate` and other data access support classes (such as `SimpleJdbcCall` and others) by using
+this `DataSource`. The following example autowires a `DataSource`:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -3161,30 +3160,30 @@ advanced features require a JDBC 3.0 driver.

 The Spring Framework's JDBC abstraction framework consists of four different packages:

-* `core`: The `org.springframework.jdbc.core` package contains the `JdbcTemplate` class
-and its various callback interfaces, plus a variety of related classes. A subpackage
-named `org.springframework.jdbc.core.simple` contains the `SimpleJdbcInsert` and
+* `core`: The `org.springframework.jdbc.core` package contains the `JdbcTemplate` class and its
+various callback interfaces, plus a variety of related classes. A subpackage named
+`org.springframework.jdbc.core.simple` contains the `SimpleJdbcInsert` and
 `SimpleJdbcCall` classes. Another subpackage named
 `org.springframework.jdbc.core.namedparam` contains the `NamedParameterJdbcTemplate`
 class and the related support classes. See <<jdbc-core>>, <<jdbc-advanced-jdbc>>, and
 <<jdbc-simple-jdbc>>.

-* `datasource`: The `org.springframework.jdbc.datasource` package contains a utility class
-for easy `DataSource` access and various simple `DataSource` implementations that you can
-use for testing and running unmodified JDBC code outside of a Java EE container. A subpackage
-named `org.springframework.jdbc.datasource.embedded` provides support for creating
+* `datasource`: The `org.springframework.jdbc.datasource` package contains a utility class for easy
+`DataSource` access and various simple `DataSource` implementations that you can use for
+testing and running unmodified JDBC code outside of a Jakarta EE container. A subpackage
+named `org.springfamework.jdbc.datasource.embedded` provides support for creating
 embedded databases by using Java database engines, such as HSQL, H2, and Derby. See
 <<jdbc-connections>> and <<jdbc-embedded-database-support>>.

-* `object`: The `org.springframework.jdbc.object` package contains classes that represent
-RDBMS queries, updates, and stored procedures as thread-safe, reusable objects. See
+* `object`: The `org.springframework.jdbc.object` package contains classes that represent RDBMS
+queries, updates, and stored procedures as thread-safe, reusable objects. See
 <<jdbc-object>>. This approach is modeled by JDO, although objects returned by queries
 are naturally disconnected from the database. This higher-level of JDBC abstraction
 depends on the lower-level abstraction in the `org.springframework.jdbc.core` package.

-* `support`: The `org.springframework.jdbc.support` package provides `SQLException`
-translation functionality and some utility classes. Exceptions thrown during JDBC processing
-are translated to exceptions defined in the `org.springframework.dao` package. This means
+* `support`: The `org.springframework.jdbc.support` package provides `SQLException` translation
+functionality and some utility classes. Exceptions thrown during JDBC processing are
+translated to exceptions defined in the `org.springframework.dao` package. This means
 that code using the Spring JDBC abstraction layer does not need to implement JDBC or
 RDBMS-specific error handling. All translated exceptions are unchecked, which gives you
 the option of catching the exceptions from which you can recover while letting other
@@ -3641,8 +3640,11 @@ parameters. The following example shows how to use `NamedParameterJdbcTemplate`:
 	}

 	public int countOfActorsByFirstName(String firstName) {
-		String sql = "select count(*) from t_actor where first_name = :first_name";
+
+		String sql = "select count(*) from T_ACTOR where first_name = :first_name";
+
 		SqlParameterSource namedParameters = new MapSqlParameterSource("first_name", firstName);
+
 		return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class);
 	}
 ----
@@ -3653,7 +3655,7 @@ parameters. The following example shows how to use `NamedParameterJdbcTemplate`:
 	private val namedParameterJdbcTemplate = NamedParameterJdbcTemplate(dataSource)

 	fun countOfActorsByFirstName(firstName: String): Int {
-		val sql = "select count(*) from t_actor where first_name = :first_name"
+		val sql = "select count(*) from T_ACTOR where first_name = :first_name"
 		val namedParameters = MapSqlParameterSource("first_name", firstName)
 		return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!!
 	}
@@ -3681,8 +3683,11 @@ The following example shows the use of the `Map`-based style:
 	}

 	public int countOfActorsByFirstName(String firstName) {
-		String sql = "select count(*) from t_actor where first_name = :first_name";
+
+		String sql = "select count(*) from T_ACTOR where first_name = :first_name";
+
 		Map<String, String> namedParameters = Collections.singletonMap("first_name", firstName);
+
 		return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters,  Integer.class);
 	}
 ----
@@ -3693,7 +3698,7 @@ The following example shows the use of the `Map`-based style:
 	private val namedParameterJdbcTemplate = NamedParameterJdbcTemplate(dataSource)

 	fun countOfActorsByFirstName(firstName: String): Int {
-		val sql = "select count(*) from t_actor where first_name = :first_name"
+		val sql = "select count(*) from T_ACTOR where first_name = :first_name"
 		val namedParameters = mapOf("first_name" to firstName)
 		return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!!
 	}
@@ -3760,9 +3765,12 @@ members of the class shown in the preceding example:
 	}

 	public int countOfActors(Actor exampleActor) {
+
 		// notice how the named parameters match the properties of the above 'Actor' class
-		String sql = "select count(*) from t_actor where first_name = :firstName and last_name = :lastName";
+		String sql = "select count(*) from T_ACTOR where first_name = :firstName and last_name = :lastName";
+
 		SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(exampleActor);
+
 		return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.class);
 	}
 ----
@@ -3776,7 +3784,7 @@ members of the class shown in the preceding example:

 	fun countOfActors(exampleActor: Actor): Int {
 		// notice how the named parameters match the properties of the above 'Actor' class
-		val sql = "select count(*) from t_actor where first_name = :firstName and last_name = :lastName"
+		val sql = "select count(*) from T_ACTOR where first_name = :firstName and last_name = :lastName"
 		val namedParameters = BeanPropertySqlParameterSource(exampleActor)
 		return namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Int::class.java)!!
 	}
@@ -3799,9 +3807,7 @@ See also <<jdbc-JdbcTemplate-idioms>> for guidelines on using the
 between ``SQLException``s and Spring's own `org.springframework.dao.DataAccessException`,
 which is agnostic in regard to data access strategy. Implementations can be generic (for
 example, using SQLState codes for JDBC) or proprietary (for example, using Oracle error
-codes) for greater precision. This exception translation mechanism is used behind the
-the common `JdbcTemplate` and `JdbcTransactionManager` entry points which do not
-propagate `SQLException` but rather `DataAccessException`.
+codes) for greater precision.

 `SQLErrorCodeSQLExceptionTranslator` is the implementation of `SQLExceptionTranslator`
 that is used by default. This implementation uses specific vendor codes. It is more
@@ -3827,8 +3833,8 @@ The `SQLErrorCodeSQLExceptionTranslator` applies matching rules in the following
  translator. If this translation is not available, the next fallback translator is
  the `SQLStateSQLExceptionTranslator`.

-NOTE: The `SQLErrorCodesFactory` is used by default to define error codes and custom
-exception translations. They are looked up in a file named `sql-error-codes.xml` from the
+NOTE: The `SQLErrorCodesFactory` is used by default to define `Error` codes and custom exception
+translations. They are looked up in a file named `sql-error-codes.xml` from the
 classpath, and the matching `SQLErrorCodes` instance is located based on the database
 name from the database metadata of the database in use.

@@ -3861,12 +3867,12 @@ You can extend `SQLErrorCodeSQLExceptionTranslator`, as the following example sh
 	}
 ----

-In the preceding example, the specific error code (`-12345`) is translated while
-other errors are left to be translated by the default translator implementation.
-To use this custom translator, you must pass it to the `JdbcTemplate` through the
-method `setExceptionTranslator`, and you must use this `JdbcTemplate` for all of the
-data access processing where this translator is needed. The following example shows
-how you can use this custom translator:
+In the preceding example, the specific error code (`-12345`) is translated, while other errors are
+left to be translated by the default translator implementation. To use this custom
+translator, you must pass it to the `JdbcTemplate` through the method
+`setExceptionTranslator`, and you must use this `JdbcTemplate` for all of the data access
+processing where this translator is needed. The following example shows how you can use this custom
+translator:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -3874,6 +3880,7 @@ how you can use this custom translator:
 	private JdbcTemplate jdbcTemplate;

 	public void setDataSource(DataSource dataSource) {
+
 		// create a JdbcTemplate and set data source
 		this.jdbcTemplate = new JdbcTemplate();
 		this.jdbcTemplate.setDataSource(dataSource);
@@ -3882,6 +3889,7 @@ how you can use this custom translator:
 		CustomSQLErrorCodesTranslator tr = new CustomSQLErrorCodesTranslator();
 		tr.setDataSource(dataSource);
 		this.jdbcTemplate.setExceptionTranslator(tr);
+
 	}

 	public void updateShippingCharge(long orderId, long pct) {
@@ -4255,12 +4263,8 @@ The following example shows C3P0 configuration:
 ==== Using `DataSourceUtils`

 The `DataSourceUtils` class is a convenient and powerful helper class that provides
-`static` methods to obtain connections from JNDI and close connections if necessary.
-It supports a thread-bound JDBC `Connection` with `DataSourceTransactionManager` but
-also with `JtaTransactionManager` and `JpaTransactionManager`.
-
-Note that `JdbcTemplate` implies `DataSourceUtils` connection access, using it
-behind every JDBC operation, implicitly participating in an ongoing transaction.
+`static` methods to obtain connections from JNDI and close connections if necessary. It
+supports thread-bound connections with, for example, `DataSourceTransactionManager`.


 [[jdbc-SmartDataSource]]
@@ -4299,6 +4303,7 @@ In contrast to `DriverManagerDataSource`, it reuses the same connection all the
 avoiding excessive creation of physical connections.


+
 [[jdbc-DriverManagerDataSource]]
 ==== Using `DriverManagerDataSource`

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

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

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

 NOTE: It is rarely desirable to use this class, except when already existing code must be
 called and passed a standard JDBC `DataSource` interface implementation. In this case,
@@ -4334,47 +4339,29 @@ javadoc for more details.


 [[jdbc-DataSourceTransactionManager]]
-==== Using `DataSourceTransactionManager` / `JdbcTransactionManager`
+==== Using `DataSourceTransactionManager`

 The `DataSourceTransactionManager` class is a `PlatformTransactionManager`
-implementation for a single JDBC `DataSource`. It binds a JDBC `Connection`
-from the specified `DataSource` to the currently executing thread, potentially
-allowing for one thread-bound `Connection` per `DataSource`.
+implementation for single JDBC datasources. It binds a JDBC connection from the
+specified data source to the currently executing thread, potentially allowing for one
+thread connection per data source.

-Application code is required to retrieve the JDBC `Connection` through
-`DataSourceUtils.getConnection(DataSource)` instead of Java EE's standard
+Application code is required to retrieve the JDBC connection through
+`DataSourceUtils.getConnection(DataSource)` instead of Jakarta EE's standard
 `DataSource.getConnection`. It throws unchecked `org.springframework.dao` exceptions
-instead of checked `SQLExceptions`. All framework classes (such as `JdbcTemplate`) use
-this strategy implicitly. If not used with a transaction manager, the lookup strategy
-behaves exactly like `DataSource.getConnection` and can therefore be used in any case.
+instead of checked `SQLExceptions`. All framework classes (such as `JdbcTemplate`) use this
+strategy implicitly. If not used with this transaction manager, the lookup strategy
+behaves exactly like the common one. Thus, it can be used in any case.

-The `DataSourceTransactionManager` class supports savepoints (`PROPAGATION_NESTED`),
-custom isolation levels, and timeouts that get applied as appropriate JDBC statement
-query timeouts. To support the latter, application code must either use `JdbcTemplate` or
-call the `DataSourceUtils.applyTransactionTimeout(..)` method for each created statement.
+The `DataSourceTransactionManager` class supports custom isolation levels and timeouts
+that get applied as appropriate JDBC statement query timeouts. To support the latter,
+application code must either use `JdbcTemplate` or call the
+`DataSourceUtils.applyTransactionTimeout(..)` method for each created statement.

-You can use `DataSourceTransactionManager` instead of `JtaTransactionManager` in the
-single-resource case, as it does not require the container to support a JTA transaction
-coordinator. Switching between these transaction managers is just a matter of configuration,
-provided you stick to the required connection lookup pattern. Note that JTA does not support
-savepoints or custom isolation levels and has a different timeout mechanism but otherwise
-exposes similar behavior in terms of JDBC resources and JDBC commit/rollback management.
-
-[NOTE]
-====
-As of 5.3, Spring provides an extended `JdbcTransactionManager` variant which adds
-exception translation capabilities on commit/rollback (aligned with `JdbcTemplate`).
-Where `DataSourceTransactionManager` will only ever throw `TransactionSystemException`
-(analogous to JTA), `JdbcTransactionManager` translates database locking failures etc to
-corresponding `DataAccessException` subclasses. Note that application code needs to be
-prepared for such exceptions, not exclusively expecting `TransactionSystemException`.
-In scenarios where that is the case, `JdbcTransactionManager` is the recommended choice.
-
-In terms of exception behavior, `JdbcTransactionManager` is roughly equivalent to
-`JpaTransactionManager` and also to `R2dbcTransactionManager`, serving as an immediate
-companion/replacement for each other. `DataSourceTransactionManager` on the other hand
-is equivalent to `JtaTransactionManager` and can serve as a direct replacement there.
-====
+You can use this implementation instead of `JtaTransactionManager` in the single-resource
+case, as it does not require the container to support JTA. Switching between
+both is just a matter of configuration, provided you stick to the required connection lookup
+pattern. JTA does not support custom isolation levels.



@@ -4389,13 +4376,13 @@ to the database.
 [[jdbc-batch-classic]]
 ==== Basic Batch Operations with `JdbcTemplate`

-You accomplish `JdbcTemplate` batch processing by implementing two methods of a special interface,
-`BatchPreparedStatementSetter`, and passing that implementation in as the second parameter
+You accomplish `JdbcTemplate` batch processing by implementing two methods of a special
+interface, `BatchPreparedStatementSetter`, and passing that implementation in as the second parameter
 in your `batchUpdate` method call. You can use the `getBatchSize` method to provide the size of
 the current batch. You can use the `setValues` method to set the values for the parameters of
-the prepared statement. This method is called the number of times that you specified in the
-`getBatchSize` call. The following example updates the `t_actor` table based on entries in a list,
-and the entire list is used as the batch:
+the prepared statement. This method is called the number of times that you
+specified in the `getBatchSize` call. The following example updates the `t_actor` table
+based on entries in a list, and the entire list is used as the batch:

 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java
@@ -6032,17 +6019,18 @@ The following example shows how to create and insert a BLOB:
 <2> Using the method `setClobAsCharacterStream` to pass in the contents of the CLOB.
 <3> Using the method `setBlobAsBinaryStream` to pass in the contents of the BLOB.

+
 [NOTE]
 ====
 If you invoke the `setBlobAsBinaryStream`, `setClobAsAsciiStream`, or
 `setClobAsCharacterStream` method on the `LobCreator` returned from
-`DefaultLobHandler.getLobCreator()`, you can optionally specify a negative value
-for the `contentLength` argument. If the specified content length is negative, the
+`DefaultLobHandler.getLobCreator()`, you can optionally specify a negative value for the
+`contentLength` argument. If the specified content length is negative, the
 `DefaultLobHandler` uses the JDBC 4.0 variants of the set-stream methods without a
 length parameter. Otherwise, it passes the specified length on to the driver.

-See the documentation for the JDBC driver you use to verify that it supports streaming
-a LOB without providing the content length.
+See the documentation for the JDBC driver you use to verify that it supports streaming a
+LOB without providing the content length.
 ====

 Now it is time to read the LOB data from the database. Again, you use a `JdbcTemplate`
@@ -6084,24 +6072,24 @@ The following example shows how to do so:
 ==== Passing in Lists of Values for IN Clause

 The SQL standard allows for selecting rows based on an expression that includes a
-variable list of values. A typical example would be `select * from t_actor where id in
+variable list of values. A typical example would be `select * from T_ACTOR where id in
 (1, 2, 3)`. This variable list is not directly supported for prepared statements by the
 JDBC standard. You cannot declare a variable number of placeholders. You need a number
 of variations with the desired number of placeholders prepared, or you need to generate
 the SQL string dynamically once you know how many placeholders are required. The named
-parameter support provided in the `NamedParameterJdbcTemplate` takes the latter approach.
-You can pass in the values as a `java.util.List` (or any `Iterable`) of simple values.
-This list is used to insert the required placeholders into the actual SQL statement
-and pass in the values during statement execution.
+parameter support provided in the `NamedParameterJdbcTemplate` and `JdbcTemplate` takes
+the latter approach. You can pass in the values as a `java.util.List` of primitive objects. This
+list is used to insert the required placeholders and pass in the values during
+statement execution.

-NOTE: Be careful when passing in many values. The JDBC standard does not guarantee that
-you can use more than 100 values for an `IN` expression list. Various databases exceed
-this number, but they usually have a hard limit for how many values are allowed.
-For example, Oracle's limit is 1000.
+NOTE: Be careful when passing in many values. The JDBC standard does not guarantee that you
+can use more than 100 values for an `in` expression list. Various databases exceed this
+number, but they usually have a hard limit for how many values are allowed. For example, Oracle's
+limit is 1000.

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


@@ -7291,16 +7279,19 @@ javadoc for more details.
 ==== Using `R2dbcTransactionManager`

 The `R2dbcTransactionManager` class is a `ReactiveTransactionManager` implementation for
-a single R2DBC `ConnectionFactory`. It binds an R2DBC `Connection` from the specified
-`ConnectionFactory` to the subscriber `Context`, potentially allowing for one subscriber
-`Connection` for each `ConnectionFactory`.
+single R2DBC datasources. It binds an R2DBC connection from the specified connection factory
+to the subscriber `Context`, potentially allowing for one subscriber connection for each
+connection factory.

-Application code is required to retrieve the R2DBC `Connection` through
+Application code is required to retrieve the R2DBC connection through
 `ConnectionFactoryUtils.getConnection(ConnectionFactory)`, instead of R2DBC's standard
-`ConnectionFactory.create()`. All framework classes (such as `DatabaseClient`) use this
-strategy implicitly. If not used with a transaction manager, the lookup strategy behaves
-exactly like `ConnectionFactory.create()` and can therefore be used in any case.
+`ConnectionFactory.create()`.

+All framework classes (such as `DatabaseClient`) use this strategy implicitly.
+If not used with this transaction manager, the lookup strategy behaves exactly like the common one.
+Thus, it can be used in any case.
+
+The `R2dbcTransactionManager` class supports custom isolation levels that get applied to the connection.



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

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

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

 All things considered, if you do not use EJBs, stick with local `SessionFactory` setup
 and Spring's `HibernateTransactionManager` or `JtaTransactionManager`. You get all of
@@ -8035,11 +8017,11 @@ the JPA specification is designed.
 [[orm-jpa-setup-jndi]]
 ===== Obtaining an EntityManagerFactory from JNDI

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

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

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

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

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

-This option may conflict with the built-in JPA capabilities of a Java EE server. In a
-full Java EE environment, consider obtaining your `EntityManagerFactory` from JNDI.
+This option may conflict with the built-in JPA capabilities of a Jakarta EE server. In a
+full Jakarta EE environment, consider obtaining your `EntityManagerFactory` from JNDI.
 Alternatively, specify a custom `persistenceXmlLocation` on your
 `LocalContainerEntityManagerFactoryBean` definition (for example,
 META-INF/my-persistence.xml) and include only a descriptor with that name in your
-application jar files. Because the Java EE server looks only for default
+application jar files. Because the Jakarta EE server looks only for default
 `META-INF/persistence.xml` files, it ignores such custom persistence units and, hence,
 avoids conflicts with a Spring-driven JPA setup upfront. (This applies to Resin 3.1, for
 example.)
@@ -8420,7 +8402,7 @@ protected, or private) does not matter.

 What about class-level annotations?

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

@@ -8469,7 +8451,7 @@ features supported by Spring, usually in a vendor-specific manner:
 * Applying specific transaction semantics (such as custom isolation level or transaction
  timeout)
 * Retrieving the transactional JDBC `Connection` (for exposure to JDBC-based DAOs)
-* Advanced translation of `PersistenceException` to Spring's `DataAccessException`
+* Advanced translation of `PersistenceExceptions` to Spring `DataAccessExceptions`

 This is particularly valuable for special transaction semantics and for advanced
 translation of exception. The default implementation (`DefaultJpaDialect`) does
@@ -8493,13 +8475,13 @@ more details of its operations and how they are used within Spring's JPA support
 ==== Setting up JPA with JTA Transaction Management

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

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




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

 This part of the appendix lists XML schemas for data access, including the following:
@@ -1,33 +1,28 @@
 :noheader:
 = Spring Framework Documentation
+include::attributes.adoc[]

 [horizontal]
 <<overview.adoc#overview, Overview>> :: history, design philosophy, feedback,
 getting started.
 <<core.adoc#spring-core, Core>> :: IoC Container, Events, Resources, i18n,
-Validation, Data Binding, Type Conversion, SpEL, AOP.
+Validation, Data Binding, Type Conversion, SpEL, AOP, AOT.
 <<testing.adoc#testing, Testing>> :: Mock Objects, TestContext Framework,
 Spring MVC Test, WebTestClient.
 <<data-access.adoc#spring-data-tier, Data Access>> :: Transactions, DAO Support,
 JDBC, R2DBC, O/R Mapping, XML Marshalling.
 <<web.adoc#spring-web, Web Servlet>> :: Spring MVC, WebSocket, SockJS,
 STOMP Messaging.
-<<web-reactive.adoc#spring-web-reactive, Web Reactive>> :: Spring WebFlux, WebClient,
+<<web-reactive.adoc#spring-webflux, Web Reactive>> :: Spring WebFlux, WebClient,
 WebSocket, RSocket.
-<<integration.adoc#spring-integration, Integration>> :: Remoting, JMS, JCA, JMX,
+<<integration.adoc#spring-integration, Integration>> :: REST Clients, JMS, JCA, JMX,
 Email, Tasks, Scheduling, Caching.
 <<languages.adoc#languages, Languages>> :: Kotlin, Groovy, Dynamic Languages.
 <<appendix.adoc#appendix, Appendix>> :: Spring properties.
-https://github.com/spring-projects/spring-framework/wiki[*Wiki*] :: What's New, Upgrade Notes, Supported Versions,
-and other cross-version information.
+https://github.com/spring-projects/spring-framework/wiki[*Wiki*] :: What's New,
+Upgrade Notes, Supported Versions, and other cross-version information.

-ifdef::backend-html5[]
-NOTE: This documentation is also available as {docs-spring-framework}/reference/pdf/index.pdf[PDF].
-endif::[]
-
-ifdef::backend-pdf[]
-NOTE: This documentation is also available as {docs-spring-framework}/reference/html/index.html[HTML].
-endif::[]
+NOTE: This documentation is available in {docs-spring-framework}/reference/html/index.html[HTML] and {docs-spring-framework}/reference/pdf/spring-framework.pdf[PDF] formats.

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

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

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




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

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



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

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

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



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

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



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

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


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

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


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

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



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

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



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

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


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

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



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

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



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

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



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

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

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

@@ -686,8 +686,8 @@ by using the Groovy dynamic language:
 	import org.springframework.web.servlet.ModelAndView
 	import org.springframework.web.servlet.mvc.Controller

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

 	class FortuneController implements Controller {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -263,16 +282,20 @@ as the following example shows:
 	}
 ----

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

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

+
+
 === Router DSL

 Spring Framework comes with a Kotlin router DSL available in 3 flavors:
@@ -314,6 +337,8 @@ when you need to register routes depending on dynamic data (for example, from a

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

+
+
 === MockMvc DSL

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

+
+
 === Kotlin Script Templates

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

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

 `KotlinScriptConfiguration.kt`
 [source,kotlin,indent=0]
@@ -386,10 +411,12 @@ class KotlinScriptConfiguration {
 See the https://github.com/sdeleuze/kotlin-script-templating[kotlin-script-templating] example
 project for more details.

+
+
 === Kotlin multiplatform serialization

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

 To enable it, follow https://github.com/Kotlin/kotlinx.serialization#setup[those instructions] to add the related dependency and plugin.
 With Spring MVC and WebFlux, both Kotlin serialization and Jackson will be configured by default if they are in the classpath since
@@ -397,6 +424,9 @@ Kotlin serialization is designed to serialize only Kotlin classes annotated with
 With Spring Messaging (RSocket), make sure that neither Jackson, GSON or JSONB are in the classpath if you want automatic configuration,
 if Jackson is needed configure `KotlinSerializationJsonMessageConverter` manually.

+
+
+
 == Coroutines

 Kotlin https://kotlinlang.org/docs/reference/coroutines-overview.html[Coroutines] are Kotlin
@@ -415,6 +445,8 @@ Spring Framework provides support for Coroutines on the following scope:
 * Suspending function and `Flow` support in RSocket `@MessageMapping` annotated methods
 * Extensions for {docs-spring-framework}/kdoc-api/spring-messaging/org.springframework.messaging.rsocket/index.html[`RSocketRequester`]

+
+
 === Dependencies

 Coroutines support is enabled when `kotlinx-coroutines-core` and `kotlinx-coroutines-reactor`
@@ -432,6 +464,8 @@ dependencies {

 Version `1.4.0` and above are supported.

+
+
 === How Reactive translates to Coroutines?

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

+
+
 === Controllers

 Here is an example of a Coroutines `@RestController`.
@@ -554,6 +590,8 @@ class CoroutinesViewController(banner: Banner) {
 }
 ----

+
+
 === WebFlux.fn

 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.
@@ -587,6 +625,8 @@ class UserHandler(builder: WebClient.Builder) {
 }
 ----

+
+
 === Transactions

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


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

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

+
+
 === Using Immutable Class Instances for Persistence

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

+
+
 === Injecting Dependencies

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

+
+
 === Injecting Configuration Properties

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


+
 === Checked Exceptions

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

+
+
 === Annotation Array Attributes

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

+
+
 === Testing

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

+
 ==== Constructor injection

-As described in the <<testing#testcontext-junit-jupiter-di#spring-web-reactive, dedicated section>>,
+As described in the <<testing#testcontext-junit-jupiter-di, dedicated section>>,
 JUnit 5 allows constructor injection of beans which is pretty useful with Kotlin
 in order to use `val` instead of `lateinit var`. You can use
 {api-spring-framework}/test/context/TestConstructor.html[`@TestConstructor(autowireMode = AutowireMode.ALL)`]
@@ -887,6 +941,7 @@ class OrderServiceIntegrationTests(val orderService: OrderService,
 ----
 ====

+
 ==== `PER_CLASS` Lifecycle

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

+
 ==== Specification-like Tests

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

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

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

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

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

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

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

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

+
+
 === Choosing the Web Flavor

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

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

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

+
+
 === Examples

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

+
+
 === Issues

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

 Spring supports a wide range of application scenarios. In a large enterprise, applications
 often exist for a long time and have to run on a JDK and application server whose upgrade
@@ -56,9 +55,10 @@ Of course, Spring's framework jars keep working fine on the classpath on both JD

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

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

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

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

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

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

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

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

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

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

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

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



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

 The `spring-test` module provides mock implementations of `ServerHttpRequest`,
 `ServerHttpResponse`, and `ServerWebExchange`.
@@ -49,21 +59,15 @@ it helps to express cardinality -- for example, whether a single or multiple asy
 values are expected, and that can be essential for making decisions (for example, when
 encoding or decoding HTTP messages).

-For annotated controllers, WebFlux transparently adapts to the reactive library chosen
-by the application. This is done with the help of the
-{api-spring-framework}/core/ReactiveAdapterRegistry.html[`ReactiveAdapterRegistry`]
-which provides pluggable support for reactive library and other asynchronous types.
-The registry has built-in support for RxJava 3, Kotlin coroutines and SmallRye Mutiny,
-but you can register other third-party adapters as well.
+For annotated controllers, WebFlux transparently adapts to the reactive library chosen by
+the application. This is done with the help of the
+{api-spring-framework}/core/ReactiveAdapterRegistry.html[`ReactiveAdapterRegistry`], which
+provides pluggable support for reactive library and other asynchronous types. The registry
+has built-in support for RxJava 3, Kotlin coroutines and SmallRye Mutiny, but you can
+register others, too.

-[NOTE]
-====
-As of Spring Framework 5.3.11, support for RxJava 1 and 2 is deprecated, following
-RxJava's own EOL advice and the upgrade recommendation towards RxJava 3.
-====
-
-For functional APIs (such as <<webflux-fn>>, the `WebClient`, and others), the general
-rules for WebFlux APIs apply -- `Flux` and `Mono` as return values and a Reactive Streams
+For functional APIs (such as <<webflux-fn>>, the `WebClient`, and others), the general rules
+for WebFlux APIs apply -- `Flux` and `Mono` as return values and a Reactive Streams
 `Publisher` as input. When a `Publisher`, whether custom or from another reactive library,
 is provided, it can be treated only as a stream with unknown semantics (0..N). If, however,
 the semantics are known, you can wrap it with `Flux` or `Mono.from(Publisher)` instead
@@ -1,9 +1,7 @@
 [[spring-web]]
 = Web on Servlet Stack
-:toc: left
-:toclevels: 4
-:tabsize: 4
-:docinfo1:
+include::attributes.adoc[]
+include::page-layout.adoc[]

 This part of the documentation covers support for Servlet-stack web applications built on the
 Servlet API and deployed to Servlet containers. Individual chapters include <<mvc, Spring MVC>>,
@@ -23,21 +23,21 @@ first take a look at common Spring configuration that is not specific to any one
 framework. (This section is equally applicable to Spring's own web framework variants.)

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

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

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

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

 The following example shows how to get the `WebApplicationContext`:
@@ -102,7 +102,7 @@ on its specific integration strategies.
 == JSF

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

 Please note that recent versions of JSF became closely tied to CDI infrastructure
@@ -119,7 +119,7 @@ The key element in Spring's JSF integration is the JSF `ELResolver` mechanism.

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

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


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

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

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




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

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

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

-* The https://www.oracle.com/technetwork/java/javaee/javaserverfaces-139869.html[JSF] homepage
+* The https://www.oracle.com/java/technologies/javaserverfaces.html[JSF] homepage
 * The https://struts.apache.org/[Struts] homepage
 * The https://tapestry.apache.org/[Tapestry] homepage
--- a/Show More
+++ b/Show More