Release v6.1.3

2026-06-08 17:33:33 +00:00 · 2024-01-11 08:59:42 +00:00
1511 changed files with 14268 additions and 23893 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
@@ -18,13 +18,11 @@ jobs:
      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,62 +0,0 @@
-name: Build and deploy snapshot
-on:
-  push:
-    branches:
-      - 6.1.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: 17
-      - 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: |
-            /**/framework-api-*.zip::zip.name=spring-framework,zip.deployed=false
-            /**/framework-api-*-docs.zip::zip.type=docs
-            /**/framework-api-*-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 17', github.ref_name) }}
@@ -1,78 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - 6.1.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: 17
-            toolchain: false
-          - version: 21
-            toolchain: true
-        exclude:
-          - os:
-              name: Linux
-            java:
-              version: 17
-    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 && '17' || '' }}
-      - 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 antora
-      - 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) }}
@@ -1,14 +1,12 @@
 name: Deploy Docs
 on:
  push:
-    branches:
-      - 'main'
-      - '*.x'
-      - '!gh-pages'
-    tags:
-      - 'v*'
+    branches-ignore: [ gh-pages ]
+    tags: '**'
  repository_dispatch:
    types: request-build-reference # legacy
+  schedule:
+  - cron: '0 10 * * *' # Once per day at 10am UTC
  workflow_dispatch:
 permissions:
  actions: write
@@ -17,8 +15,8 @@ jobs:
    runs-on: ubuntu-latest
    if: github.repository_owner == 'spring-projects'
    steps:
-    - name: Check out code
-      uses: actions/checkout@v4
+    - name: Checkout
+      uses: actions/checkout@v3
      with:
        ref: docs-build
        fetch-depth: 1
@@ -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,3 +1,3 @@
 # Enable auto-env through the sdkman_auto_env config
 # Add key=value pairs of SDKs to use below
-java=17.0.11-librca
+java=17.0.9-librca
@@ -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=6.1.x)](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml?query=branch%3A6.1.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-6.1.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.1.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". 

@@ -4,7 +4,7 @@ plugins {
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
 	id 'org.jetbrains.dokka' version '1.8.20'
 	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
-	id 'com.github.ben-manes.versions' version '0.51.0'
+	id 'com.github.ben-manes.versions' version '0.50.0'
 	id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
 	id 'de.undercouch.download' version '5.4.0'
 	id 'me.champeau.jmh' version '0.7.2' apply false
@@ -90,6 +90,7 @@ configure([rootProject] + javaProjects) { project ->
 			"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 and weblogic.* packages
+			"https://www.ibm.com/docs/api/v1/content/SSEQTP_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/", // com.ibm.*
 			"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/", // org.jboss.resource.*
 			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
 			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
@@ -103,7 +104,7 @@ configure([rootProject] + javaProjects) { project ->
 			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
 			// See https://github.com/spring-projects/spring-framework/issues/27497
 			//
-			// "https://junit.org/junit5/docs/5.10.2/api/",
+			// "https://junit.org/junit5/docs/5.10.1/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			//"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
@@ -50,7 +50,7 @@ public class CheckstyleConventions {
 			project.getPlugins().apply(CheckstylePlugin.class);
 			project.getTasks().withType(Checkstyle.class).forEach(checkstyle -> checkstyle.getMaxHeapSize().set("1g"));
 			CheckstyleExtension checkstyle = project.getExtensions().getByType(CheckstyleExtension.class);
-			checkstyle.setToolVersion("10.16.0");
+			checkstyle.setToolVersion("10.12.7");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
@@ -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-6.1.x[Spring Framework 6.1.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-6.1.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.
@@ -1,4 +1,4 @@
-FROM ubuntu:jammy-20240125
+FROM ubuntu:jammy-20231211.1

 ADD setup.sh /setup.sh
 ADD get-jdk-url.sh /get-jdk-url.sh
@@ -7,6 +7,6 @@ RUN ./setup.sh
 ENV JAVA_HOME /opt/openjdk/java17
 ENV JDK17 /opt/openjdk/java17
 ENV JDK21 /opt/openjdk/java21
-ENV JDK23 /opt/openjdk/java23
+ENV JDK22 /opt/openjdk/java22

 ENV PATH $JAVA_HOME/bin:$PATH
@@ -3,13 +3,13 @@ set -e

 case "$1" in
 	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://download.bell-sw.com/java/17.0.9+11/bellsoft-jdk17.0.9+11-linux-amd64.tar.gz"
 	;;
 	java21)
-		echo "https://github.com/bell-sw/Liberica/releases/download/21.0.2%2B14/bellsoft-jdk21.0.2+14-linux-amd64.tar.gz"
+		echo "https://download.bell-sw.com/java/21.0.1+12/bellsoft-jdk21.0.1+12-linux-amd64.tar.gz"
 	;;
-	java23)
-		echo "https://download.java.net/java/early_access/jdk23/17/GPL/openjdk-23-ea+17_linux-x64_bin.tar.gz"
+	java22)
+		echo "https://download.java.net/java/early_access/jdk22/28/GPL/openjdk-22-ea+28_linux-x64_bin.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 java17 java21 java23
+for jdk in java17 java21 java22
 do
  JDK_URL=$( /get-jdk-url.sh $jdk )
  mkdir $jdk
@@ -3,8 +3,9 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "6.1.x"
+branch: "main"
 milestone: "6.1.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
+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,14 @@ anchors:
  docker-resource-source: &docker-resource-source
    username: ((docker-hub-username))
    password: ((docker-hub-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
@@ -54,6 +64,12 @@ resource_types:
    <<: *docker-resource-source
    repository: dpb587/github-status-resource
    tag: master
+- name: slack-notification
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: cfcommunity/slack-notification-resource
+    tag: latest
 resources:
 - name: git-repo
  type: git
@@ -74,6 +90,13 @@ resources:
    <<: *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 +105,35 @@ resources:
    username: ((artifactory-username))
    password: ((artifactory-password))
    build_name: ((build-name))
+- 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-jdk21-build
+  type: github-status-resource
+  icon: eye-check-outline
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: jdk21-build
+- name: repo-status-jdk22-build
+  type: github-status-resource
+  icon: eye-check-outline
+  source:
+    repository: ((github-repo-name))
+    access_token: ((github-ci-status-token))
+    branch: ((branch))
+    context: jdk22-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
@@ -116,6 +168,115 @@ jobs:
    - put: ci-image
      params:
        image: ci-image/image.tar
+- name: build
+  serial: true
+  public: true
+  plan:
+  - get: ci-image
+  - get: git-repo
+    trigger: true
+  - put: repo-status-build
+    params: { state: "pending", commit: "git-repo" }
+  - do:
+    - task: build-project
+      image: ci-image
+      file: git-repo/ci/tasks/build-project.yml
+      privileged: true
+      timeout: ((task-timeout))
+      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-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}"
+      disable_checksum_uploads: true
+      threads: 8
+      artifact_set:
+      - include:
+        - "/**/framework-api-*.zip"
+        properties:
+          "zip.name": "spring-framework"
+          "zip.displayname": "Spring Framework"
+          "zip.deployed": "false"
+      - include:
+        - "/**/framework-api-*-docs.zip"
+        properties:
+          "zip.type": "docs"
+      - include:
+        - "/**/framework-api-*-schema.zip"
+        properties:
+          "zip.type": "schema"
+    get_params:
+      threads: 8
+- name: jdk21-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk21-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: 21
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk21-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk21-build
+      params: { state: "success", commit: "git-repo" }
+- name: jdk22-build
+  serial: true
+  public: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: every-morning
+      trigger: true
+    - put: repo-status-jdk22-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: 22
+            <<: *build-project-task-params
+      on_failure:
+        do:
+          - put: repo-status-jdk22-build
+            params: { state: "failure", commit: "git-repo" }
+          - put: slack-alert
+            params:
+              <<: *slack-fail-params
+    - put: repo-status-jdk22-build
+      params: { state: "success", commit: "git-repo" }
 - name: stage-milestone
  serial: true
  plan:
@@ -129,32 +290,9 @@ jobs:
        RELEASE_TYPE: M
        <<: *gradle-enterprise-task-params
    - put: artifactory-repo
-      params: &artifactory-params
-        signing_key: ((signing-key))
-        signing_passphrase: ((signing-passphrase))
+      params:
+        <<: *artifactory-params
        repo: libs-staging-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}"
-        disable_checksum_uploads: true
-        threads: 8
-        artifact_set:
-          - include:
-              - "/**/framework-api-*.zip"
-            properties:
-              "zip.name": "spring-framework"
-              "zip.displayname": "Spring Framework"
-              "zip.deployed": "false"
-          - include:
-              - "/**/framework-api-*-docs.zip"
-            properties:
-              "zip.type": "docs"
-          - include:
-              - "/**/framework-api-*-schema.zip"
-            properties:
-              "zip.type": "schema"
-      get_params:
-        threads: 8
    - put: git-repo
      params:
        repository: stage-git-repo
@@ -199,6 +337,7 @@ jobs:
    - put: artifactory-repo
      params:
        <<: *artifactory-params
+        repo: libs-staging-local
    - put: git-repo
      params:
        repository: stage-git-repo
@@ -243,6 +382,7 @@ jobs:
    - put: artifactory-repo
      params:
        <<: *artifactory-params
+        repo: libs-staging-local
    - put: git-repo
      params:
        repository: stage-git-repo
@@ -287,6 +427,8 @@ jobs:
        <<: *changelog-task-params

 groups:
+- name: "builds"
+  jobs: ["build", "jdk21-build", "jdk22-build"]
 - name: "releases"
  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
 - name: "ci-images"
@@ -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,JDK21 \
+  --no-daemon --max-workers=4 check
+popd > /dev/null
@@ -0,0 +1,10 @@
+#!/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 -Porg.gradle.java.installations.fromEnv=JDK17,JDK21,JDK22 \
+  --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,JDK21,JDK22 \
+  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check antora
+popd > /dev/null
@@ -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
@@ -18,7 +18,6 @@ asciidoc:
    # FIXME: The package is not renamed
    chomp: 'all'
    fold: 'all'
-    table-stripes: 'odd'
    include-java: 'example$docs-src/main/java/org/springframework/docs'
    spring-site: 'https://spring.io'
    spring-site-blog: '{spring-site}/blog'
@@ -28,8 +28,8 @@ antora {
 			'@antora/atlas-extension': '1.0.0-alpha.1',
 			'@antora/collector-extension': '1.0.0-alpha.3',
 			'@asciidoctor/tabs': '1.0.0-beta.3',
-			'@opendevise/antora-release-line-extension': '1.0.0',
-			'@springio/antora-extensions': '1.8.2',
+			'@opendevise/antora-release-line-extension': '1.0.0-alpha.2',
+			'@springio/antora-extensions': '1.3.0',
 			'@springio/asciidoctor-extensions': '1.0.0-alpha.9'
 	]
 }
@@ -39,8 +39,8 @@
 ** xref:core/resources.adoc[]
 ** xref:core/validation.adoc[]
 *** xref:core/validation/validator.adoc[]
-*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/conversion.adoc[]
+*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/convert.adoc[]
 *** xref:core/validation/format.adoc[]
 *** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
@@ -421,7 +421,7 @@
 *** xref:integration/cache/specific-config.adoc[]
 ** xref:integration/observability.adoc[]
 ** xref:integration/checkpoint-restore.adoc[]
-** xref:integration/cds.adoc[]
+** xref:integration/class-data-sharing.adoc[]
 ** xref:integration/appendix.adoc[]
 * xref:languages.adoc[]
 ** xref:languages/kotlin.adoc[]
@@ -439,5 +439,4 @@
 ** xref:languages/groovy.adoc[]
 ** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
-* {spring-framework-wiki}[Wiki]
-
+* {spring-framework-wiki}[Wiki]
@@ -19,7 +19,7 @@ of the classpath -- for example, deployed within the application's JAR file.
 The following table lists all currently supported Spring properties.

 .Supported Spring Properties
-[cols="1,1"]
+[cols="1,1", stripes=odd]
 |===
 | Name | Description

@@ -19,10 +19,6 @@ you can do so. However, you should consider the following issues:
  since the CGLIB proxy instance is created through Objenesis. Only if your JVM does
  not allow for constructor bypassing, you might see double invocations and
  corresponding debug log entries from Spring's AOP support.
-* Your CGLIB proxy usage may face limitations with the JDK 9+ platform module system.
-  As a typical case, you cannot create a CGLIB proxy for a class from the `java.lang`
-  package when deploying on the module path. Such cases require a JVM bootstrap flag
-  `--add-opens=java.base/java.lang=ALL-UNNAMED` which is not available for modules.

 To force the use of CGLIB proxies, set the value of the `proxy-target-class` attribute
 of the `<aop:config>` element to true, as follows:
@@ -521,8 +521,8 @@ standard AspectJ. The following example shows the `aop.xml` file:
 	<aspectj>

 		<weaver>
-			<!-- only weave classes in our application-specific packages and sub-packages -->
-			<include within="com.xyz..*"/>
+			<!-- only weave classes in our application-specific packages -->
+			<include within="com.xyz.*"/>
 		</weaver>

 		<aspects>
@@ -731,8 +731,8 @@ For example:
 	<aspectj>

 		<weaver>
-			<!-- only weave classes in our application-specific packages and sub-packages -->
-			<include within="com.xyz..*"/>
+			<!-- only weave classes in our application-specific packages -->
+			<include within="com.xyz.*"/>
 		</weaver>

 	</aspectj>
@@ -15,13 +15,10 @@ 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 and is automatically enabled at runtime when AOT is enabled.
+** `@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.
-* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time.
-* Beans registered as singletons (using `registerSingleton`, typically from
-`ConfigurableListableBeanFactory`) cannot be transformed ahead-of-time either.
-* As we cannot rely on the instance, make sure that the bean type is as precise as
-possible.
+* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time (see related {spring-framework-issues}/29555[spring-framework#29555] issue).
+* Make sure that the bean type is as precise as possible.

 TIP: See also the xref:core/aot.adoc#aot.bestpractices[] section.

@@ -30,7 +27,7 @@ A Spring AOT processed application typically generates:

 * Java source code
 * Bytecode (usually for dynamic proxies)
-* {spring-framework-api}/aot/hint/RuntimeHints.html[`RuntimeHints`] for the use of reflection, resource loading, serialization, and JDK proxies
+* {spring-framework-api}/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.
@@ -38,7 +35,7 @@ We intend to support more JVM-based use cases in future generations.
 [[aot.basics]]
 == AOT engine overview

-The entry point of the AOT engine for processing an `ApplicationContext` is `ApplicationContextAotGenerator`. It takes care of the following steps, based on a `GenericApplicationContext` that represents the application to optimize and a {spring-framework-api}/aot/generate/GenerationContext.html[`GenerationContext`]:
+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 {spring-framework-api}/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`.
@@ -70,14 +67,7 @@ include-code::./AotProcessingSample[tag=aotcontext]
 In this mode, xref:core/beans/factory-extension.adoc#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 evaluated,
-and bean definitions that don't match their conditions are discarded at this stage.
-
-If custom code needs to register extra beans programmatically, make sure that custom
-registration code uses `BeanDefinitionRegistry` instead of `BeanFactory` as only bean
-definitions are taken into account. A good pattern is to implement
-`ImportBeanDefinitionRegistrar` and register it via an `@Import` on one of your
-configuration classes.
+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:
@@ -94,12 +84,12 @@ Once this part completes, the `BeanFactory` contains the bean definitions that a
 Components that want to participate in this step can implement the {spring-framework-api}/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 which reproduces a particular behavior.
+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` implementation can be registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.

-The `BeanFactoryInitializationAotProcessor` interface can also be implemented directly by a bean.
+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.

@@ -121,7 +111,7 @@ This interface is used as follows:

 * Implemented by a `BeanPostProcessor` bean, to replace its runtime behavior.
 For instance xref:core/beans/factory-extension.adoc#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.
+* 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]
@@ -152,23 +142,8 @@ Java::

 	}
 ----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	@Configuration(proxyBeanMethods = false)
-	class DataSourceConfiguration {
-
-		@Bean
-		fun dataSource() = SimpleDataSource()
-
-	}
----
 ======

-WARNING: Kotlin class names with backticks that use invalid Java identifiers (not starting with a letter, containing spaces, etc.) are not supported.
-
 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:

@@ -224,17 +199,6 @@ There is a bean definition for `dataSourceConfiguration` and one for `dataSource
 When a `datasource` instance is required, a `BeanInstanceSupplier` is called.
 This supplier invokes the `dataSource()` method on the `dataSourceConfiguration` bean.

-[[aot.running]]
-== Running with AOT optimizations
-
-AOT is a mandatory step to transform a Spring application to a native executable, so it
-is automatically enabled when running in this mode. It is possible to use those optimizations
-on the JVM by setting the `spring.aot.enabled` System property to `true`.
-
-NOTE: When AOT optimizations are included, some decisions that have been taken at build-time
-are hard-coded in the application setup. For instance, profiles that have been enabled at
-build-time are automatically enabled at runtime as well.
-
 [[aot.bestpractices]]
 == Best Practices

@@ -243,33 +207,11 @@ However, keep in mind that some optimizations are made at build time based on a

 This section lists the best practices that make sure your application is ready for AOT.

-[[aot.bestpractices.bean-registration]]
-== Programmatic bean registration
-
-The AOT engine takes care of the `@Configuration` model and any callback that might be
-invoked as part of processing your configuration. If you need to register additional
-beans programmatically, make sure to use a `BeanDefinitionRegistry` to register
-bean definitions.
-
-This can typically be done via a `BeanDefinitionRegistryPostProcessor`. Note that, if it
-is registered itself as a bean, it will be invoked again at runtime unless you make
-sure to implement `BeanFactoryInitializationAotProcessor` as well. A more idiomatic
-way is to implement `ImportBeanDefinitionRegistrar` and register it using `@Import` on
-one of your configuration classes. This invokes your custom code as part of configuration
-class parsing.
-
-If you declare additional beans programmatically using a different callback, they are
-likely not going to be handled by the AOT engine, and therefore no hints are going to be
-generated for them. Depending on the environment, those beans may not be registered at
-all. For instance, classpath scanning does not work in a native image as there is no
-notion of a classpath. For cases like this, it is crucial that the scanning happens at
-build time.
-
 [[aot.bestpractices.bean-type]]
 === Expose The Most Precise Bean Type

 While your application may interact with an interface that a bean implements, it is still very important to declare the most precise type.
-The AOT engine performs additional checks on the bean type, such as detecting the presence of `@Autowired` members or lifecycle callback methods.
+The AOT engine performs additional checks on the bean type, such as detecting the presence of `@Autowired` members, or lifecycle callback methods.

 For `@Configuration` classes, make sure that the return type of the factory `@Bean` method is as precise as possible.
 Consider the following example:
@@ -320,24 +262,10 @@ If you are registering bean definitions programmatically, consider using `RootBe

 [[aot.bestpractices.constructors]]
 === Avoid Multiple Constructors
-
 The container is able to choose the most appropriate constructor to use based on several candidates.
 However, this is not a best practice and flagging the preferred constructor with `@Autowired` if necessary is preferred.

-In case you are working on a code base that you cannot modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.
-
-[[aot.bestpractices.custom-arguments]]
-=== Avoid Creating Bean with Custom Arguments
-
-Spring AOT detects what needs to be done to create a bean and translates that in generated code using an instance supplier.
-The container also supports creating a bean with {spring-framework-api}++/beans/factory/BeanFactory.html#getBean(java.lang.String,java.lang.Object...)++[custom arguments] that leads to several issues with AOT:
-
-. The custom arguments require dynamic introspection of a matching constructor or factory method.
-Those arguments cannot be detected by AOT, so the necessary reflection hints will have to be provided manually.
-. By-passing the instance supplier means that all other optimizations after creation are skipped as well.
-For instance, autowiring on fields and methods will be skipped as they are handled in the instance supplier.
-
-Rather than having prototype-scoped beans created with custom arguments, we recommend a manual factory pattern where a bean is responsible for the creation of the instance.
+In case you are working on a code base that you can't modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.

 [[aot.bestpractices.factory-bean]]
 === FactoryBean
@@ -355,7 +283,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	public class ClientFactoryBean<T extends AbstractClient> implements FactoryBean<T> {
-		// ...
+
 	}
 ----
 ======
@@ -452,7 +380,7 @@ Java::

 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 included in a native image unless specified explicitly.
+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 {spring-framework-api}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxies at runtime.
@@ -487,7 +415,7 @@ 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.
+It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the `RuntimeHintsRegistrar` interface.


 [[aot.hints.reflective]]
@@ -496,7 +424,7 @@ It is also possible to register an implementation statically by adding an entry
 {spring-framework-api}/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.
+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.

@@ -1,16 +1,33 @@
 [[beans-annotation-config]]
 = Annotation-based Container Configuration

-Spring provides comprehensive support for annotation-based configuration, operating on
-metadata in the component class itself by using annotations on the relevant class,
-method, or field declaration. As mentioned in
-xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp-examples-aabpp[Example: The `AutowiredAnnotationBeanPostProcessor`],
-Spring uses `BeanPostProcessors` in conjunction with annotations to make the core IOC
-container aware of specific annotations.
+.Are annotations better than XML for configuring Spring?
+****
+The introduction of annotation-based configuration raised the question of whether this
+approach is "`better`" than XML. The short answer is "`it depends.`" The long answer is
+that each approach has its pros and cons, and, usually, it is up to the developer to
+decide which strategy suits them better. Due to the way they are defined, annotations
+provide a lot of context in their declaration, leading to shorter and more concise
+configuration. However, XML excels at wiring up components without touching their source
+code or recompiling them. Some developers prefer having the wiring close to the source
+while others argue that annotated classes are no longer POJOs and, furthermore, that the
+configuration becomes decentralized and harder to control.

-For example, the xref:core/beans/annotation-config/autowired.adoc[`@Autowired`]
-annotation provides the same capabilities as described in
-xref:core/beans/dependencies/factory-autowire.adoc[Autowiring Collaborators] but
+No matter the choice, Spring can accommodate both styles and even mix them together.
+It is worth pointing out that through its xref:core/beans/java.adoc[JavaConfig] option, Spring lets
+annotations be used in a non-invasive way, without touching the target components'
+source code and that, in terms of tooling, all configuration styles are supported by
+{spring-site-tools}[Spring Tools] for Eclipse, Visual Studio Code, and Theia.
+****
+
+An alternative to XML setup is provided by annotation-based configuration, which relies
+on bytecode metadata for wiring up components instead of XML declarations. Instead of
+using XML to describe a bean wiring, the developer moves the configuration into the
+component class itself by using annotations on the relevant class, method, or field
+declaration. As mentioned in xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp-examples-aabpp[Example: The `AutowiredAnnotationBeanPostProcessor`], using a
+`BeanPostProcessor` in conjunction with annotations is a common means of extending the
+Spring IoC container. For example, the xref:core/beans/annotation-config/autowired.adoc[`@Autowired`]
+annotation provides the same capabilities as described in xref:core/beans/dependencies/factory-autowire.adoc[Autowiring Collaborators] but
 with more fine-grained control and wider applicability. In addition, Spring provides
 support for JSR-250 annotations, such as `@PostConstruct` and `@PreDestroy`, as well as
 support for JSR-330 (Dependency Injection for Java) annotations contained in the
@@ -19,16 +36,13 @@ can be found in the xref:core/beans/standard-annotations.adoc[relevant section].

 [NOTE]
 ====
-Annotation injection is performed before external property injection. Thus, external
-configuration (e.g. XML-specified bean properties) effectively overrides the annotations
-for properties when wired through mixed approaches.
+Annotation injection is performed before XML injection. Thus, the XML configuration
+overrides the annotations for properties wired through both approaches.
 ====

-Technically, you can register the post-processors as individual bean definitions, but they
-are implicitly registered in an `AnnotationConfigApplicationContext` already.
-
-In an XML-based Spring setup, you may include the following configuration tag to enable
-mixing and matching with annotation-based configuration:
+As always, you can register the post-processors as individual bean definitions, but they
+can also be implicitly registered by including the following tag in an XML-based Spring
+configuration (notice the inclusion of the `context` namespace):

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -186,15 +186,6 @@ implementation type, consider declaring the most specific return type on your fa
 method (at least as specific as required by the injection points referring to your bean).
 ====

-[NOTE]
-====
-As of 4.3, `@Autowired` also considers self references for injection (that is, references
-back to the bean that is currently injected). Note that self injection is a fallback.
-In practice, you should use self references as a last resort only (for example, for
-calling other methods on the same instance through the bean's transactional proxy).
-Consider factoring out the affected methods to a separate delegate bean in such a scenario.
-====
-
 You can also instruct Spring to provide all beans of a particular type from the
 `ApplicationContext` by adding the `@Autowired` annotation to a field or method that
 expects an array of that type, as the following example shows:
@@ -277,12 +268,6 @@ use the same bean class). `@Order` values may influence priorities at injection
 but be aware that they do not influence singleton startup order, which is an
 orthogonal concern determined by dependency relationships and `@DependsOn` declarations.

-Note that `@Order` annotations on configuration classes just influence the evaluation
-order within the overall set of configuration classes on startup. Such configuration-level
-order values do not affect the contained `@Bean` methods at all. For bean-level ordering,
-each `@Bean` method needs to have its own `@Order` annotation which applies within a
-set of multiple matches for the specific bean type (as returned by the factory method).
-
 Note that the standard `jakarta.annotation.Priority` annotation is not available at the
 `@Bean` level, since it cannot be declared on methods. Its semantics can be modeled
 through `@Order` values in combination with `@Primary` on a single bean for each type.
@@ -2,28 +2,36 @@
 = Container Overview

 The `org.springframework.context.ApplicationContext` interface represents the Spring IoC
-container and is responsible for instantiating, configuring, and assembling the beans.
-The container gets its instructions on the components to instantiate, configure, and
-assemble by reading configuration metadata. The configuration metadata can be represented
-as annotated component classes, configuration classes with factory methods, or external
-XML files or Groovy scripts. With either format, you may compose your application and the
-rich interdependencies between those components.
+container and is responsible for instantiating, configuring, and assembling the
+beans. The container gets its instructions on what objects to
+instantiate, configure, and assemble by reading configuration metadata. The
+configuration metadata is represented in XML, Java annotations, or Java code. It lets
+you express the objects that compose your application and the rich interdependencies
+between those objects.

-Several implementations of the `ApplicationContext` interface are part of core Spring.
-In stand-alone applications, it is common to create an instance of
-{spring-framework-api}/context/annotation/AnnotationConfigApplicationContext.html[`AnnotationConfigApplicationContext`]
-or {spring-framework-api}/context/support/ClassPathXmlApplicationContext.html[`ClassPathXmlApplicationContext`].
+Several implementations of the `ApplicationContext` interface are supplied
+with Spring. In stand-alone applications, it is common to create an
+instance of
+{spring-framework-api}/context/support/ClassPathXmlApplicationContext.html[`ClassPathXmlApplicationContext`]
+or {spring-framework-api}/context/support/FileSystemXmlApplicationContext.html[`FileSystemXmlApplicationContext`].
+While XML has been the traditional format for defining configuration metadata, you can
+instruct the container to use Java annotations or code as the metadata format by
+providing a small amount of XML configuration to declaratively enable support for these
+additional metadata formats.

 In most application scenarios, explicit user code is not required to instantiate one or
-more instances of a Spring IoC container. For example, in a plain web application scenario,
-a simple boilerplate web descriptor XML in the `web.xml` file of the application suffices (see
+more instances of a Spring IoC container. For example, in a web application scenario, a
+simple eight (or so) lines of boilerplate web descriptor XML in the `web.xml` file
+of the application typically suffices (see
 xref:core/beans/context-introduction.adoc#context-create[Convenient ApplicationContext Instantiation for Web Applications]).
-In a Spring Boot scenario, the application context is implicitly bootstrapped for you
-based on common setup conventions.
+If you use the {spring-site-tools}[Spring Tools for Eclipse] (an Eclipse-powered
+development environment), you can easily create this boilerplate configuration with a
+few mouse clicks or keystrokes.

 The following diagram shows a high-level view of how Spring works. Your application classes
 are combined with configuration metadata so that, after the `ApplicationContext` is
-created and initialized, you have a fully configured and executable system or application.
+created and initialized, you have a fully configured and executable system or
+application.

 .The Spring IoC container
 image::container-magic.png[]
@@ -35,25 +43,33 @@ image::container-magic.png[]

 As the preceding diagram shows, the Spring IoC container consumes a form of
 configuration metadata. This configuration metadata represents how you, as an
-application developer, tell the Spring container to instantiate, configure,
-and assemble the components in your application.
+application developer, tell the Spring container to instantiate, configure, and assemble
+the objects in your application.

+Configuration metadata is traditionally supplied in a simple and intuitive XML format,
+which is what most of this chapter uses to convey key concepts and features of the
+Spring IoC container.
+
+NOTE: XML-based metadata is not the only allowed form of configuration metadata.
 The Spring IoC container itself is totally decoupled from the format in which this
 configuration metadata is actually written. These days, many developers choose
-xref:core/beans/java.adoc[Java-based configuration] for their Spring applications:
+xref:core/beans/java.adoc[Java-based configuration] for their Spring applications.
+
+For information about using other forms of metadata with the Spring container, see:

 * xref:core/beans/annotation-config.adoc[Annotation-based configuration]: define beans using
-  annotation-based configuration metadata on your application's component classes.
+  annotation-based configuration metadata.
 * xref:core/beans/java.adoc[Java-based configuration]: define beans external to your application
-  classes by using Java-based configuration classes. To use these features, see the
+  classes by using Java rather than XML files. To use these features, see the
  {spring-framework-api}/context/annotation/Configuration.html[`@Configuration`],
  {spring-framework-api}/context/annotation/Bean.html[`@Bean`],
  {spring-framework-api}/context/annotation/Import.html[`@Import`],
  and {spring-framework-api}/context/annotation/DependsOn.html[`@DependsOn`] annotations.

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

 These bean definitions correspond to the actual objects that make up your application.
 Typically, you define service layer objects, persistence layer objects such as
@@ -63,14 +79,7 @@ Typically, one does not configure fine-grained domain objects in the container,
 it is usually the responsibility of repositories and business logic to create and load
 domain objects.

-
-
-[[beans-factory-xml]]
-=== XML as an External Configuration DSL
-
-XML-based configuration metadata configures these beans as `<bean/>` elements inside
-a top-level `<beans/>` element. The following example shows the basic structure of
-XML-based configuration metadata:
+The following example shows the basic structure of XML-based configuration metadata:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -101,9 +110,14 @@ The value of the `id` attribute can be used to refer to collaborating objects. T
 for referring to collaborating objects is not shown in this example. See
 xref:core/beans/dependencies.adoc[Dependencies] for more information.

-For instantiating a container, the location path or paths to the XML resource files
-need to be supplied to a `ClassPathXmlApplicationContext` constructor that let the
-container load configuration metadata from a variety of external resources, such
+
+
+[[beans-factory-instantiation]]
+== Instantiating a Container
+
+The location path or paths
+supplied to an `ApplicationContext` constructor are resource strings that let
+the container load configuration metadata from a variety of external resources, such
 as the local file system, the Java `CLASSPATH`, and so on.

 [tabs]
@@ -127,7 +141,7 @@ Kotlin::
 ====
 After you learn about Spring's IoC container, you may want to know more about Spring's
 `Resource` abstraction (as described in
-xref:core/resources.adoc[Resources])
+xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources])
 which provides a convenient mechanism for reading an InputStream from locations defined
 in a URI syntax. In particular, `Resource` paths are used to construct applications contexts,
 as described in xref:core/resources.adoc#resources-app-ctx[Application Contexts and Resource Paths].
@@ -195,9 +209,9 @@ xref:core/beans/dependencies.adoc[Dependencies].
 It can be useful to have bean definitions span multiple XML files. Often, each individual
 XML configuration file represents a logical layer or module in your architecture.

-You can use the `ClassPathXmlApplicationContext` constructor to load bean definitions from
+You can use the application context constructor to load bean definitions from all these
 XML fragments. This constructor takes multiple `Resource` locations, as was shown in the
-xref:core/beans/basics.adoc#beans-factory-xml[previous section]. Alternatively,
+xref:core/beans/basics.adoc#beans-factory-instantiation[previous section]. Alternatively,
 use one or more occurrences of the `<import/>` element to load bean definitions from
 another file or files. The following example shows how to do so:

@@ -245,7 +259,7 @@ configuration features beyond plain bean definitions are available in a selectio
 of XML namespaces provided by Spring -- for example, the `context` and `util` namespaces.


-[[beans-factory-groovy]]
+[[groovy-bean-definition-dsl]]
 === The Groovy Bean Definition DSL

 As a further example for externalized configuration metadata, bean definitions can also
@@ -406,3 +420,4 @@ a dependency on a specific bean through metadata (such as an autowiring annotati



+
@@ -234,10 +234,6 @@ For details about the mechanism for supplying arguments to the constructor (if r
 and setting object instance properties after the object is constructed, see
 xref:core/beans/dependencies/factory-collaborators.adoc[Injecting Dependencies].

-NOTE: In the case of constructor arguments, the container can select a corresponding
-constructor among several overloaded constructors. That said, to avoid ambiguities,
-it is recommended to keep your constructor signatures as straightforward as possible.
-

 [[beans-factory-class-static-factory-method]]
 === Instantiation with a Static Factory Method
@@ -298,24 +294,6 @@ For details about the mechanism for supplying (optional) arguments to the factor
 and setting object instance properties after the object is returned from the factory,
 see xref:core/beans/dependencies/factory-properties-detailed.adoc[Dependencies and Configuration in Detail].

-NOTE: In the case of factory method arguments, the container can select a corresponding
-method among several overloaded methods of the same name. That said, to avoid ambiguities,
-it is recommended to keep your factory method signatures as straightforward as possible.
-
-[TIP]
-====
-A typical problematic case with factory method overloading is Mockito with its many
-overloads of the `mock` method. Choose the most specific variant of `mock` possible:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
----
-	<bean id="clientService" class="org.mockito.Mockito" factory-method="mock">
-		<constructor-arg type="java.lang.Class" value="examples.ClientService"/>
-		<constructor-arg type="java.lang.String" value="clientService"/>
-	</bean>
----
-====
-

 [[beans-factory-class-instance-factory-method]]
 === Instantiation by Using an Instance Factory Method
@@ -438,8 +416,8 @@ Kotlin::
 ======

 This approach shows that the factory bean itself can be managed and configured through
-dependency injection (DI).
-See xref:core/beans/dependencies/factory-properties-detailed.adoc[Dependencies and Configuration in Detail].
+dependency injection (DI). See xref:core/beans/dependencies/factory-properties-detailed.adoc[Dependencies and Configuration in Detail]
+.

 NOTE: In Spring documentation, "factory bean" refers to a bean that is configured in the
 Spring container and that creates objects through an
@@ -466,3 +444,5 @@ cases into account and returns the type of object that a `BeanFactory.getBean` c
 going to return for the same bean name.


+
+
@@ -55,34 +55,33 @@ The preceding `AppConfig` class is equivalent to the following Spring `<beans/>`
 	</beans>
 ----

-.@Configuration classes with or without local calls between @Bean methods?
+.Full @Configuration vs "`lite`" @Bean mode?
 ****
-In common scenarios, `@Bean` methods are to be declared within `@Configuration` classes,
-ensuring that full configuration class processing applies and that cross-method
-references therefore get redirected to the container's lifecycle management.
-This prevents the same `@Bean` method from accidentally being invoked through a regular
-Java method call, which helps to reduce subtle bugs that can be hard to track down.
-
 When `@Bean` methods are declared within classes that are not annotated with
-`@Configuration` - or when `@Configuration(proxyBeanMethods=false)` is declared -,
-they are referred to as being processed in a "lite" mode. In such scenarios,
-`@Bean` methods are effectively a general-purpose factory method mechanism without
-special runtime processing (that is, without generating a CGLIB subclass for it).
-A custom Java call to such a method will not get intercepted by the container and
-therefore behaves just like a regular method call, creating a new instance every time
-rather than reusing an existing singleton (or scoped) instance for the given bean.
+`@Configuration`, they are referred to as being processed in a "`lite`" mode. Bean methods
+declared on a bean that is not annotated with `@Configuration` are considered to be "`lite`",
+with a different primary purpose of the containing class and a `@Bean` method
+being a sort of bonus there. For example, service components may expose management views
+to the container through an additional `@Bean` method on each applicable component class.
+In such scenarios, `@Bean` methods are a general-purpose factory method mechanism.

-As a consequence, `@Bean` methods on classes without runtime proxying are not meant to
-declare inter-bean dependencies at all. Instead, they are expected to operate on their
-containing component's fields and, optionally, on arguments that a factory method may
-declare in order to receive autowired collaborators. Such a `@Bean` method therefore
-never needs to invoke other `@Bean` methods; every such call can be expressed through
-a factory method argument instead. The positive side-effect here is that no CGLIB
-subclassing has to be applied at runtime, reducing the overhead and the footprint.
+Unlike full `@Configuration`, lite `@Bean` methods cannot declare inter-bean dependencies.
+Instead, they operate on their containing component's internal state and, optionally, on
+arguments that they may declare. Such a `@Bean` method should therefore not invoke other
+`@Bean` methods. Each such method is literally only a factory method for a particular
+bean reference, without any special runtime semantics. The positive side-effect here is
+that no CGLIB subclassing has to be applied at runtime, so there are no limitations in
+terms of class design (that is, the containing class may be `final` and so forth).
+
+In common scenarios, `@Bean` methods are to be declared within `@Configuration` classes,
+ensuring that "`full`" mode is always used and that cross-method references therefore
+get redirected to the container's lifecycle management. This prevents the same
+`@Bean` method from accidentally being invoked through a regular Java call, which helps
+to reduce subtle bugs that can be hard to track down when operating in "`lite`" mode.
 ****

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


@@ -1,11 +1,10 @@
 [[expressions]]
 = Spring Expression Language (SpEL)

-The Spring Expression Language ("SpEL" for short) is a powerful expression language that
+The Spring Expression Language ("`SpEL`" for short) is a powerful expression language that
 supports querying and manipulating an object graph at runtime. The language syntax is
-similar to the https://jakarta.ee/specifications/expression-language/[Jakarta Expression
-Language] but offers additional features, most notably method invocation and basic string
-templating functionality.
+similar to Unified EL but offers additional features, most notably method invocation and
+basic string templating functionality.

 While there are several other Java expression languages available -- OGNL, MVEL, and JBoss
 EL, to name a few -- the Spring Expression Language was created to provide the Spring
@@ -34,24 +33,26 @@ populate them are listed at the end of the chapter.
 The expression language supports the following functionality:

 * Literal expressions
+* Boolean and relational operators
+* Regular expressions
+* Class expressions
 * Accessing properties, arrays, lists, and maps
+* Method invocation
+* Assignment
+* Calling constructors
+* Bean references
+* Array construction
 * Inline lists
 * Inline maps
-* Array construction
-* Relational operators
-* Regular expressions
-* Logical operators
-* String operators
-* Mathematical operators
-* Assignment
-* Type expressions
-* Method invocation
-* Constructor invocation
+* Ternary operator
 * Variables
-* User-defined functions
-* Bean references
-* Ternary, Elvis, and safe-navigation operators
+* User-defined functions added to the context
+  * reflective invocation of `Method`
+  * various cases of `MethodHandle`
 * Collection projection
 * Collection selection
 * Templated expressions

+
+
+
@@ -517,8 +517,6 @@ following kinds of expressions cannot be compiled.
 * Expressions involving assignment
 * Expressions relying on the conversion service
 * Expressions using custom resolvers or accessors
-* Expressions using overloaded operators
-* Expressions using array construction syntax
 * Expressions using selection or projection

 Compilation of additional kinds of expressions may be supported in the future.
@@ -3,11 +3,9 @@

 This section lists the classes used in the examples throughout this chapter.

-== `Inventor`
-
 [tabs]
 ======
-Java::
+Inventor.Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
 ----
@@ -82,7 +80,7 @@ Java::
 	}
 ----

-Kotlin::
+Inventor.kt::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
 ----
@@ -97,11 +95,9 @@ Kotlin::
 ----
 ======

-== `PlaceOfBirth`
-
 [tabs]
 ======
-Java::
+PlaceOfBirth.java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
 ----
@@ -139,7 +135,7 @@ Java::
 	}
 ----

-Kotlin::
+PlaceOfBirth.kt::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
 ----
@@ -149,11 +145,9 @@ Kotlin::
 ----
 ======

-== `Society`
-
 [tabs]
 ======
-Java::
+Society.java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary",chomp="-packages"]
 ----
@@ -198,7 +192,7 @@ Java::
 	}
 ----

-Kotlin::
+Society.kt::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary",chomp="-packages"]
 ----
@@ -13,7 +13,7 @@ Java::
 	int[] numbers1 = (int[]) parser.parseExpression("new int[4]").getValue(context);

 	// Array with initializer
-	int[] numbers2 = (int[]) parser.parseExpression("new int[] {1, 2, 3}").getValue(context);
+	int[] numbers2 = (int[]) parser.parseExpression("new int[]{1,2,3}").getValue(context);

 	// Multi dimensional array
 	int[][] numbers3 = (int[][]) parser.parseExpression("new int[4][5]").getValue(context);
@@ -26,22 +26,14 @@ Kotlin::
 	val numbers1 = parser.parseExpression("new int[4]").getValue(context) as IntArray

 	// Array with initializer
-	val numbers2 = parser.parseExpression("new int[] {1, 2, 3}").getValue(context) as IntArray
+	val numbers2 = parser.parseExpression("new int[]{1,2,3}").getValue(context) as IntArray

 	// Multi dimensional array
 	val numbers3 = parser.parseExpression("new int[4][5]").getValue(context) as Array<IntArray>
 ----
 ======

-[NOTE]
-====
 You cannot currently supply an initializer when you construct a multi-dimensional array.
-====

-[CAUTION]
-====
-Any expression that constructs an array – for example, via `new int[4]` or
-`new int[] {1, 2, 3}` – cannot be compiled. See
-xref:core/expressions/evaluation.adoc#expressions-compiler-limitations[Compiler Limitations]
-for details.
-====
+
+
@@ -13,18 +13,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	// evaluates to ["Smiljan", "Idvor"]
-	List placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
-			.getValue(societyContext, List.class);
+	// returns ['Smiljan', 'Idvor' ]
+	List placesOfBirth = (List)parser.parseExpression("members.![placeOfBirth.city]");
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	// evaluates to ["Smiljan", "Idvor"]
-	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
-	 		.getValue(societyContext) as List<*>
+	// returns ['Smiljan', 'Idvor' ]
+	val placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]") as List<*>
 ----
 ======

@@ -34,12 +32,5 @@ evaluated against each entry in the map (represented as a Java `Map.Entry`). The
 of a projection across a map is a list that consists of the evaluation of the projection
 expression against each map entry.

-[NOTE]
-====
-The Spring Expression Language also supports safe navigation for collection projection.

-See
-xref:core/expressions/language-ref/operator-safe-navigation.adoc#expressions-operator-safe-navigation-selection-and-projection[Safe Collection Selection and Projection]
-for details.
-====

@@ -28,14 +28,13 @@ Kotlin::
 ======

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

-Given a `Map` stored in a variable named `#map`, the following expression returns a new
-map that consists of those elements of the original map where the entry's value is less
-than 27:
+The following expression returns a new map that consists of those elements of the
+original map where the entry's value is less than 27:

 [tabs]
 ======
@@ -43,28 +42,21 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	Map newMap = parser.parseExpression("#map.?[value < 27]").getValue(Map.class);
+	Map newMap = parser.parseExpression("map.?[value<27]").getValue();
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	val newMap = parser.parseExpression("#map.?[value < 27]").getValue() as Map
+	val newMap = parser.parseExpression("map.?[value<27]").getValue()
 ----
 ======

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

-[NOTE]
-====
-The Spring Expression Language also supports safe navigation for collection selection.

-See
-xref:core/expressions/language-ref/operator-safe-navigation.adoc#expressions-operator-safe-navigation-selection-and-projection[Safe Collection Selection and Projection]
-for details.
-====

@@ -1,26 +1,10 @@
 [[expressions-ref-functions]]
 = Functions

-You can extend SpEL by registering user-defined functions that can be called within
-expressions by using the `#functionName(...)` syntax. Functions can be registered as
-variables in `EvaluationContext` implementations via the `setVariable()` method.
-
-[TIP]
-====
-`StandardEvaluationContext` also defines `registerFunction(...)` methods that provide a
-convenient way to register a function as a `java.lang.reflect.Method` or a
-`java.lang.invoke.MethodHandle`.
-====
-
-[WARNING]
-====
-Since functions share a common namespace with
-xref:core/expressions/language-ref/variables.adoc[variables] in the evaluation context,
-care must be taken to ensure that function names and variable names do not overlap.
-====
-
-The following example shows how to register a user-defined function to be invoked via
-reflection using a `java.lang.reflect.Method`:
+You can extend SpEL by registering user-defined functions that can be called within the
+expression string. The function is registered through the `EvaluationContext`. The
+following example shows how to register a user-defined function to be invoked via reflection
+(i.e. a `Method`):

 [tabs]
 ======
@@ -56,7 +40,11 @@ Java::
 	public abstract class StringUtils {

 		public static String reverseString(String input) {
-			return new StringBuilder(input).reverse().toString();
+			StringBuilder backwards = new StringBuilder(input.length());
+			for (int i = 0; i < input.length(); i++) {
+				backwards.append(input.charAt(input.length() - 1 - i));
+			}
+			return backwards.toString();
 		}
 	}
 ----
@@ -66,12 +54,16 @@ Kotlin::
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
 	fun reverseString(input: String): String {
-		return StringBuilder(input).reverse().toString()
+		val backwards = StringBuilder(input.length)
+		for (i in 0 until input.length) {
+			backwards.append(input[input.length - 1 - i])
+		}
+		return backwards.toString()
 	}
 ----
 ======

-You can register and use the preceding method, as the following example shows:
+You can then register and use the preceding method, as the following example shows:

 [tabs]
 ======
@@ -83,9 +75,8 @@ Java::

 	EvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build();
 	context.setVariable("reverseString",
-			StringUtils.class.getMethod("reverseString", String.class));
+			StringUtils.class.getDeclaredMethod("reverseString", String.class));

-	// evaluates to "olleh"
 	String helloWorldReversed = parser.parseExpression(
 			"#reverseString('hello')").getValue(context, String.class);
 ----
@@ -97,18 +88,16 @@ Kotlin::
 	val parser = SpelExpressionParser()

 	val context = SimpleEvaluationContext.forReadOnlyDataBinding().build()
-	context.setVariable("reverseString", ::reverseString.javaMethod)
+	context.setVariable("reverseString", ::reverseString::javaMethod)

-	// evaluates to "olleh"
 	val helloWorldReversed = parser.parseExpression(
 			"#reverseString('hello')").getValue(context, String::class.java)
 ----
 ======

-A function can also be registered as a `java.lang.invoke.MethodHandle`. This enables
-potentially more efficient use cases if the `MethodHandle` target and parameters have
-been fully bound prior to registration; however, partially bound handles are also
-supported.
+The use of `MethodHandle` is also supported. This enables potentially more efficient use
+cases if the `MethodHandle` target and parameters have been fully bound prior to
+registration, but partially bound handles are also supported.

 Consider the `String#formatted(String, Object...)` instance method, which produces a
 message according to a template and a variable number of arguments.
@@ -129,9 +118,9 @@ Java::
 			MethodType.methodType(String.class, Object[].class));
 	context.setVariable("message", mh);

-	// evaluates to "Simple message: <Hello World>"
 	String message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
 			.getValue(context, String.class);
+	//returns "Simple message: <Hello World>"
 ----

 Kotlin::
@@ -145,7 +134,6 @@ Kotlin::
 			MethodType.methodType(String::class.java, Array<Any>::class.java))
 	context.setVariable("message", mh)

-	// evaluates to "Simple message: <Hello World>"
 	val message = parser.parseExpression("#message('Simple message: <%s>', 'Hello World', 'ignored')")
 			.getValue(context, String::class.java)
 ----
@@ -173,9 +161,9 @@ Java::
 			.bindTo(varargs); //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh);

-	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
 	String message = parser.parseExpression("#message()")
 			.getValue(context, String.class);
+	//returns "This is a prerecorded message with 3 words: <Oh Hello World!>"
 ----

 Kotlin::
@@ -194,7 +182,6 @@ Kotlin::
 			.bindTo(varargs) //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh)

-	// evaluates to "This is a prerecorded message with 3 words: <Oh Hello World!>"
 	val message = parser.parseExpression("#message()")
 			.getValue(context, String::class.java)
 ----
@@ -3,46 +3,20 @@

 SpEL supports the following types of literal expressions.

-String ::
-  Strings can be 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.
-Number ::
-  Numbers support the use of the negative sign, exponential notation, and decimal points.
-  * Integer: `int` or `long`
-  * Hexadecimal: `int` or `long`
-  * Real: `float` or `double`
-  ** By default, real numbers are parsed using `Double.parseDouble()`.
-Boolean ::
-  `true` or `false`
-Null ::
-  `null`
+- strings
+- numeric values: integer (`int` or `long`), hexadecimal (`int` or `long`), real (`float`
+  or `double`)
+- boolean values: `true` or `false`
+- null

-[NOTE]
-====
-Due to the design and implementation of the Spring Expression Language, literal numbers
-are always stored internally as positive numbers.
+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.

-For example, `-2` is stored internally as a positive `2` which is then negated while
-evaluating the expression (by calculating the value of `0 - 2`).
-
-This means that it is not possible to represent a negative literal number equal to the
-minimum value of that type of number in Java. For example, the minimum supported value
-for an `int` in Java is `Integer.MIN_VALUE` which has a value of `-2147483648`. However,
-if you include `-2147483648` in a SpEL expression, an exception will be thrown informing
-you that the value `2147483648` cannot be parsed as an `int` (because it exceeds the
-value of `Integer.MAX_VALUE` which is `2147483647`).
-
-If you need to use the minimum value for a particular type of number within a SpEL
-expression, you can either reference the `MIN_VALUE` constant for the respective wrapper
-type (such as `Integer.MIN_VALUE`, `Long.MIN_VALUE`, etc.) or calculate the minimum
-value. For example, to use the minimum integer value:
-
- `T(Integer).MIN_VALUE` -- requires a `StandardEvaluationContext`
- `-2^31` -- can be used with any type of `EvaluationContext`
-====
+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,
@@ -1,27 +1,12 @@
 [[expressions-operator-safe-navigation]]
 = Safe Navigation Operator

-The safe navigation operator (`?`) is used to avoid a `NullPointerException` and comes
-from the https://www.groovy-lang.org/operators.html#_safe_navigation_operator[Groovy]
-language. Typically, when you have a reference to an object, you might need to verify
-that it is not `null` before accessing methods or properties of the object. To avoid
-this, the safe navigation operator returns `null` for the particular null-safe operation
-instead of throwing an exception.
-
-[WARNING]
-====
-When the safe navigation operator evaluates to `null` for a particular null-safe
-operation within a compound expression, the remainder of the compound expression will
-still be evaluated.
-
-See <<expressions-operator-safe-navigation-compound-expressions>> for details.
-====
-
-[[expressions-operator-safe-navigation-property-access]]
-== Safe Property and Method Access
-
-The following example shows how to use the safe navigation operator for property access
-(`?.`).
+The safe navigation operator is used to avoid a `NullPointerException` and comes from
+the https://www.groovy-lang.org/operators.html#_safe_navigation_operator[Groovy]
+language. Typically, when you have a reference to an object, you might need to verify that
+it is not null before accessing methods or properties of the object. To avoid this, the
+safe navigation operator returns null instead of throwing an exception. The following
+example shows how to use the safe navigation operator:

 [tabs]
 ======
@@ -35,18 +20,13 @@ Java::
 	Inventor tesla = new Inventor("Nikola Tesla", "Serbian");
 	tesla.setPlaceOfBirth(new PlaceOfBirth("Smiljan"));

-	// evaluates to "Smiljan"
-	String city = parser.parseExpression("placeOfBirth?.city") // <1>
-			.getValue(context, tesla, String.class);
+	String city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String.class);
+	System.out.println(city);  // Smiljan

 	tesla.setPlaceOfBirth(null);
-
-	// evaluates to null - does not throw NullPointerException
-	city = parser.parseExpression("placeOfBirth?.city") // <2>
-			.getValue(context, tesla, String.class);	
+	city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String.class);
+	System.out.println(city);  // null - does not throw NullPointerException!!!
 ----
-<1> Use safe navigation operator on non-null `placeOfBirth` property
-<2> Use safe navigation operator on null `placeOfBirth` property

 Kotlin::
 +
@@ -58,306 +38,14 @@ Kotlin::
 	val tesla = Inventor("Nikola Tesla", "Serbian")
 	tesla.setPlaceOfBirth(PlaceOfBirth("Smiljan"))

-	// evaluates to "Smiljan"
-	var city = parser.parseExpression("placeOfBirth?.city") // <1>
-			.getValue(context, tesla, String::class.java)
+	var city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String::class.java)
+	println(city)  // Smiljan

 	tesla.setPlaceOfBirth(null)
-
-	// evaluates to null - does not throw NullPointerException
-	city = parser.parseExpression("placeOfBirth?.city") // <2>
-			.getValue(context, tesla, String::class.java)
+	city = parser.parseExpression("placeOfBirth?.city").getValue(context, tesla, String::class.java)
+	println(city)  // null - does not throw NullPointerException!!!
 ----
-<1> Use safe navigation operator on non-null `placeOfBirth` property
-<2> Use safe navigation operator on null `placeOfBirth` property
-======
-
-[NOTE]
-====
-The safe navigation operator also applies to method invocations on an object.
-
-For example, the expression `#calculator?.max(4, 2)` evaluates to `null` if the
-`#calculator` variable has not been configured in the context. Otherwise, the
-`max(int, int)` method will be invoked on the `#calculator`.
-====
-
-
-[[expressions-operator-safe-navigation-selection-and-projection]]
-== Safe Collection Selection and Projection
-
-The Spring Expression Language supports safe navigation for
-xref:core/expressions/language-ref/collection-selection.adoc[collection selection] and
-xref:core/expressions/language-ref/collection-projection.adoc[collection projection] via
-the following operators.
-
-* null-safe selection: `?.?`
-* null-safe select first: `?.^`
-* null-safe select last: `?.$`
-* null-safe projection: `?.!`
-
-The following example shows how to use the safe navigation operator for collection
-selection (`?.?`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression = "members?.?[nationality == 'Serbian']"; // <1>
-
-	// evaluates to [Inventor("Nikola Tesla")]
-	List<Inventor> list = (List<Inventor>) parser.parseExpression(expression)
-			.getValue(context);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	list = (List<Inventor>) parser.parseExpression(expression)
-			.getValue(context);
----
-<1> Use null-safe selection operator on potentially null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression = "members?.?[nationality == 'Serbian']" // <1>
-
-	// evaluates to [Inventor("Nikola Tesla")]
-	var list = parser.parseExpression(expression)
-			.getValue(context) as List<Inventor>
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	list = parser.parseExpression(expression)
-			.getValue(context) as List<Inventor>
----
-<1> Use null-safe selection operator on potentially null `members` list
-======
-
-The following example shows how to use the "null-safe select first" operator for
-collections (`?.^`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression =
-		"members?.^[nationality == 'Serbian' || nationality == 'Idvor']"; // <1>
-
-	// evaluates to Inventor("Nikola Tesla")
-	Inventor inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
----
-<1> Use "null-safe select first" operator on potentially null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression =
-		"members?.^[nationality == 'Serbian' || nationality == 'Idvor']" // <1>
-
-	// evaluates to Inventor("Nikola Tesla")
-	var inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
----
-<1> Use "null-safe select first" operator on potentially null `members` list
 ======


-The following example shows how to use the "null-safe select last" operator for
-collections (`?.$`).

-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression =
-		"members?.$[nationality == 'Serbian' || nationality == 'Idvor']"; // <1>
-
-	// evaluates to Inventor("Pupin")
-	Inventor inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor.class);
----
-<1> Use "null-safe select last" operator on potentially null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression =
-		"members?.$[nationality == 'Serbian' || nationality == 'Idvor']" // <1>
-
-	// evaluates to Inventor("Pupin")
-	var inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	inventor = parser.parseExpression(expression)
-			.getValue(context, Inventor::class.java)
----
-<1> Use "null-safe select last" operator on potentially null `members` list
-======
-
-The following example shows how to use the safe navigation operator for collection
-projection (`?.!`).
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-
-	// evaluates to ["Smiljan", "Idvor"]
-	List placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <1>
-			.getValue(context, List.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <2>
-			.getValue(context, List.class);
----
-<1> Use null-safe projection operator on non-null `members` list
-<2> Use null-safe projection operator on null `members` list
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-
-	// evaluates to ["Smiljan", "Idvor"]
-	var placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <1>
-			.getValue(context, List::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	placesOfBirth = parser.parseExpression("members?.![placeOfBirth.city]") // <2>
-			.getValue(context, List::class.java)
----
-<1> Use null-safe projection operator on non-null `members` list
-<2> Use null-safe projection operator on null `members` list
-======
-
-
-[[expressions-operator-safe-navigation-compound-expressions]]
-== Null-safe Operations in Compound Expressions
-
-As mentioned at the beginning of this section, when the safe navigation operator
-evaluates to `null` for a particular null-safe operation within a compound expression,
-the remainder of the compound expression will still be evaluated. This means that the
-safe navigation operator must be applied throughout a compound expression in order to
-avoid any unwanted `NullPointerException`.
-
-Given the expression `#person?.address.city`, if `#person` is `null` the safe navigation
-operator (`?.`) ensures that no exception will be thrown when attempting to access the
-`address` property of `#person`. However, since `#person?.address` evaluates to `null`, a
-`NullPointerException` will be thrown when attempting to access the `city` property of
-`null`. To address that, you can apply null-safe navigation throughout the compound
-expression as in `#person?.address?.city`. That expression will safely evaluate to `null`
-if either `#person` or `#person?.address` evaluates to `null`.
-
-The following example demonstrates how to use the "null-safe select first" operator
-(`?.^`) on a collection combined with null-safe property access (`?.`) within a compound
-expression. If `members` is `null`, the result of the "null-safe select first" operator
-(`members?.^[nationality == 'Serbian']`) evaluates to `null`, and the additional use of
-the safe navigation operator (`?.name`) ensures that the entire compound expression
-evaluates to `null` instead of throwing an exception.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ExpressionParser parser = new SpelExpressionParser();
-	IEEE society = new IEEE();
-	StandardEvaluationContext context = new StandardEvaluationContext(society);
-	String expression = "members?.^[nationality == 'Serbian']?.name"; // <1>
-
-	// evaluates to "Nikola Tesla"
-	String name = parser.parseExpression(expression)
-			.getValue(context, String.class);
-
-	society.members = null;
-
-	// evaluates to null - does not throw a NullPointerException
-	name = parser.parseExpression(expression)
-			.getValue(context, String.class);
----
-<1> Use "null-safe select first" and null-safe property access operators within compound expression.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val parser = SpelExpressionParser()
-	val society = IEEE()
-	val context = StandardEvaluationContext(society)
-	val expression = "members?.^[nationality == 'Serbian']?.name" // <1>
-
-	// evaluates to "Nikola Tesla"
-	String name = parser.parseExpression(expression)
-			.getValue(context, String::class.java)
-
-	society.members = null
-
-	// evaluates to null - does not throw a NullPointerException
-	name = parser.parseExpression(expression)
-			.getValue(context, String::class.java)
----
-<1> Use "null-safe select first" and null-safe property access operators within compound expression.
-======
@@ -5,11 +5,8 @@ The Spring Expression Language supports the following kinds of operators:

 * xref:core/expressions/language-ref/operators.adoc#expressions-operators-relational[Relational Operators]
 * xref:core/expressions/language-ref/operators.adoc#expressions-operators-logical[Logical Operators]
-* xref:core/expressions/language-ref/operators.adoc#expressions-operators-string[String Operators]
 * xref:core/expressions/language-ref/operators.adoc#expressions-operators-mathematical[Mathematical Operators]
 * xref:core/expressions/language-ref/operators.adoc#expressions-assignment[The Assignment Operator]
-* xref:core/expressions/language-ref/operators.adoc#expressions-operators-overloaded[Overloaded Operators]
-


 [[expressions-operators-relational]]
@@ -18,7 +15,7 @@ The Spring Expression Language supports the following kinds of 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.
 These operators work on `Number` types as well as types implementing `Comparable`.
-The following listing shows a few examples of relational operators:
+The following listing shows a few examples of operators:

 [tabs]
 ======
@@ -68,22 +65,8 @@ If you prefer numeric comparisons instead, avoid number-based `null` comparisons
 in favor of comparisons against zero (for example, `X > 0` or `X < 0`).
 ====

-Each symbolic operator can also be specified as a purely textual equivalent. This avoids
-problems where the symbols used have special meaning for the document type in which the
-expression is embedded (such as in an XML document). The textual equivalents are:
-
-* `lt` (`<`)
-* `gt` (`>`)
-* `le` (`\<=`)
-* `ge` (`>=`)
-* `eq` (`==`)
-* `ne` (`!=`)
-
-All of the textual operators are case-insensitive.
-
-In addition to the standard relational operators, SpEL supports the `between`,
-`instanceof`, and regular expression-based `matches` operators. The following listing
-shows examples of all three:
+In addition to the standard relational operators, SpEL supports the `instanceof` and regular
+expression-based `matches` operator. The following listing shows examples of both:

 [tabs]
 ======
@@ -91,38 +74,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	boolean result;
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"1 between {1, 5}").getValue(Boolean.class);
-
 	// evaluates to false
-	result = parser.parseExpression(
-			"1 between {10, 15}").getValue(Boolean.class);
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'zebra'}").getValue(Boolean.class);
-
-	// evaluates to false
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'cobra'}").getValue(Boolean.class);
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"123 instanceof T(Integer)").getValue(Boolean.class);
-
-	// evaluates to false
-	result = parser.parseExpression(
+	boolean falseValue = parser.parseExpression(
 			"'xyz' instanceof T(Integer)").getValue(Boolean.class);

 	// evaluates to true
-	result = parser.parseExpression(
+	boolean trueValue = parser.parseExpression(
 			"'5.00' matches '^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.class);

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

@@ -130,65 +91,50 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	// evaluates to true
-	var result = parser.parseExpression(
-			"1 between {1, 5}").getValue(Boolean::class.java)
-
 	// evaluates to false
-	result = parser.parseExpression(
-			"1 between {10, 15}").getValue(Boolean::class.java)
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'zebra'}").getValue(Boolean::class.java)
-
-	// evaluates to false
-	result = parser.parseExpression(
-			"'elephant' between {'aardvark', 'cobra'}").getValue(Boolean::class.java)
-
-	// evaluates to true
-	result = parser.parseExpression(
-			"123 instanceof T(Integer)").getValue(Boolean::class.java)
-
-	// evaluates to false
-	result = parser.parseExpression(
+	val falseValue = parser.parseExpression(
 			"'xyz' instanceof T(Integer)").getValue(Boolean::class.java)

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

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

-[CAUTION]
-====
-The syntax for the `between` operator is `<input> between {<range_begin>, <range_end>}`,
-which is effectively a shortcut for `<input> >= <range_begin> && <input> \<= <range_end>}`.
-
-Consequently, `1 between {1, 5}` evaluates to `true`, while `1 between {5, 1}` evaluates
-to `false`.
-====
-
 CAUTION: Be careful with primitive types, as they are immediately boxed up to their
 wrapper types. For example, `1 instanceof T(int)` evaluates to `false`, while
-`1 instanceof T(Integer)` evaluates to `true`.
+`1 instanceof T(Integer)` evaluates to `true`, as expected.
+
+Each symbolic operator can also be specified as a purely alphabetic equivalent. This
+avoids problems where the symbols used have special meaning for the document type in
+which the expression is embedded (such as in an XML document). The textual equivalents are:
+
+* `lt` (`<`)
+* `gt` (`>`)
+* `le` (`\<=`)
+* `ge` (`>=`)
+* `eq` (`==`)
+* `ne` (`!=`)
+* `div` (`/`)
+* `mod` (`%`)
+* `not` (`!`).
+
+All of the textual operators are case-insensitive.


 [[expressions-operators-logical]]
 == Logical Operators

-SpEL supports the following logical (`boolean`) operators:
+SpEL supports the following logical operators:

 * `and` (`&&`)
 * `or` (`||`)
 * `not` (`!`)

-All of the textual operators are case-insensitive.
-
 The following example shows how to use the logical operators:

 [tabs]
@@ -221,7 +167,6 @@ Java::
 	boolean falseValue = parser.parseExpression("!true").getValue(Boolean.class);

 	// -- AND and NOT --
-
 	String expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')";
 	boolean falseValue = parser.parseExpression(expression).getValue(societyContext, Boolean.class);
 ----
@@ -254,105 +199,20 @@ Kotlin::
 	val falseValue = parser.parseExpression("!true").getValue(Boolean::class.java)

 	// -- AND and NOT --
-
 	val expression = "isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')"
 	val falseValue = parser.parseExpression(expression).getValue(societyContext, Boolean::class.java)
 ----
 ======


-[[expressions-operators-string]]
-== String Operators
-
-You can use the following operators on strings.
-
-* concatenation (`+`)
-* subtraction (`-`)
-  - for use with a string containing a single character
-* repeat (`*`)
-
-The following example shows the `String` operators in use:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	// -- Concatenation --
-
-	// evaluates to "hello world"
-	String helloWorld = parser.parseExpression("'hello' + ' ' + 'world'")
-			.getValue(String.class);
-
-	// -- Character Subtraction --
-
-	// evaluates to 'a'
-	char ch = parser.parseExpression("'d' - 3")
-			.getValue(char.class);
-
-	// -- Repeat --
-
-	// evaluates to "abcabc"
-	String repeated = parser.parseExpression("'abc' * 2")
-			.getValue(String.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	// -- Concatenation --
-
-	// evaluates to "hello world"
-	val helloWorld = parser.parseExpression("'hello' + ' ' + 'world'")
-			.getValue(String::class.java)
-
-	// -- Character Subtraction --
-
-	// evaluates to 'a'
-	val ch = parser.parseExpression("'d' - 3")
-			.getValue(Character::class.java);
-
-	// -- Repeat --
-
-	// evaluates to "abcabc"
-	val repeated = parser.parseExpression("'abc' * 2")
-			.getValue(String::class.java);
----
-======
-
 [[expressions-operators-mathematical]]
 == Mathematical Operators

-You can use the following operators on numbers, and standard operator precedence is enforced.
-
-* addition (`+`)
-* subtraction (`-`)
-* increment (`{pp}`)
-* decrement (`--`)
-* multiplication (`*`)
-* division (`/`)
-* modulus (`%`)
-* exponential power (`^`)
-
-The division and modulus operators can also be specified as a purely textual equivalent.
-This avoids problems where the symbols used have special meaning for the document type in
-which the expression is embedded (such as in an XML document). The textual equivalents
-are:
-
-* `div` (`/`)
-* `mod` (`%`)
-
-All of the textual operators are case-insensitive.
-
-[NOTE]
-====
-The increment and decrement operators can be used with either prefix (`{pp}A`, `--A`) or
-postfix (`A{pp}`, `A--`) notation with variables or properties that can be written to.
-====
-
-The following example shows the mathematical operators in use:
+You can use the addition operator (`+`) on both numbers and strings. You can use the
+subtraction (`-`), multiplication (`*`), and division (`/`) operators only on numbers.
+You can also use the modulus (`%`) and exponential power (`^`) operators on numbers.
+Standard operator precedence is enforced. The following example shows the mathematical
+operators in use:

 [tabs]
 ======
@@ -360,131 +220,67 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	Inventor inventor = new Inventor();
-	EvaluationContext context = SimpleEvaluationContext.forReadWriteDataBinding().build();
+	// Addition
+	int two = parser.parseExpression("1 + 1").getValue(Integer.class);  // 2

-	// -- Addition --
+	String testString = parser.parseExpression(
+			"'test' + ' ' + 'string'").getValue(String.class);  // 'test string'

-	int two = parser.parseExpression("1 + 1").getValue(int.class);  // 2
+	// Subtraction
+	int four = parser.parseExpression("1 - -3").getValue(Integer.class);  // 4

-	// -- Subtraction --
+	double d = parser.parseExpression("1000.00 - 1e4").getValue(Double.class);  // -9000

-	int four = parser.parseExpression("1 - -3").getValue(int.class);  // 4
+	// Multiplication
+	int six = parser.parseExpression("-2 * -3").getValue(Integer.class);  // 6

-	double d = parser.parseExpression("1000.00 - 1e4").getValue(double.class);  // -9000
+	double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double.class);  // 24.0

-	// -- Increment --
+	// Division
+	int minusTwo = parser.parseExpression("6 / -3").getValue(Integer.class);  // -2

-	// The counter property in Inventor has an initial value of 0.
+	double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double.class);  // 1.0

-	// evaluates to 2; counter is now 1
-	two = parser.parseExpression("counter++ + 2").getValue(context, inventor, int.class);
+	// Modulus
+	int three = parser.parseExpression("7 % 4").getValue(Integer.class);  // 3

-	// evaluates to 5; counter is now 2
-	int five = parser.parseExpression("3 + ++counter").getValue(context, inventor, int.class);
+	int one = parser.parseExpression("8 / 5 % 2").getValue(Integer.class);  // 1

-	// -- Decrement --
-
-	// The counter property in Inventor has a value of 2.
-
-	// evaluates to 6; counter is now 1
-	int six = parser.parseExpression("counter-- + 4").getValue(context, inventor, int.class);
-
-	// evaluates to 5; counter is now 0
-	five = parser.parseExpression("5 + --counter").getValue(context, inventor, int.class);
-
-	// -- Multiplication --
-
-	six = parser.parseExpression("-2 * -3").getValue(int.class);  // 6
-
-	double twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(double.class);  // 24.0
-
-	// -- Division --
-
-	int minusTwo = parser.parseExpression("6 / -3").getValue(int.class);  // -2
-
-	double one = parser.parseExpression("8.0 / 4e0 / 2").getValue(double.class);  // 1.0
-
-	// -- Modulus --
-
-	int three = parser.parseExpression("7 % 4").getValue(int.class);  // 3
-
-	int oneInt = parser.parseExpression("8 / 5 % 2").getValue(int.class);  // 1
-
-	// -- Exponential power --
-
-	int maxInt = parser.parseExpression("(2^31) - 1").getValue(int.class);  // Integer.MAX_VALUE
-
-	int minInt = parser.parseExpression("-2^31").getValue(int.class);  // Integer.MIN_VALUE
-
-	// -- Operator precedence --
-
-	int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(int.class);  // -21
+	// Operator precedence
+	int minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Integer.class);  // -21
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	val inventor = Inventor()
-	val context = SimpleEvaluationContext.forReadWriteDataBinding().build()
+	// Addition
+	val two = parser.parseExpression("1 + 1").getValue(Int::class.java)  // 2

-	// -- Addition --
-
-	var two = parser.parseExpression("1 + 1").getValue(Int::class.java)  // 2
-
-	// -- Subtraction --
+	val testString = parser.parseExpression(
+			"'test' + ' ' + 'string'").getValue(String::class.java)  // 'test string'

+	// Subtraction
 	val four = parser.parseExpression("1 - -3").getValue(Int::class.java)  // 4

 	val d = parser.parseExpression("1000.00 - 1e4").getValue(Double::class.java)  // -9000

-	// -- Increment --
-
-	// The counter property in Inventor has an initial value of 0.
-
-	// evaluates to 2; counter is now 1
-	two = parser.parseExpression("counter++ + 2").getValue(context, inventor, Int::class.java)
-
-	// evaluates to 5; counter is now 2
-	var five = parser.parseExpression("3 + ++counter").getValue(context, inventor, Int::class.java)
-
-	// -- Decrement --
-
-	// The counter property in Inventor has a value of 2.
-
-	// evaluates to 6; counter is now 1
-	var six = parser.parseExpression("counter-- + 4").getValue(context, inventor, Int::class.java)
-
-	// evaluates to 5; counter is now 0
-	five = parser.parseExpression("5 + --counter").getValue(context, inventor, Int::class.java)
-
-	// -- Multiplication --
-
-	six = parser.parseExpression("-2 * -3").getValue(Int::class.java)  // 6
+	// Multiplication
+	val six = parser.parseExpression("-2 * -3").getValue(Int::class.java)  // 6

 	val twentyFour = parser.parseExpression("2.0 * 3e0 * 4").getValue(Double::class.java)  // 24.0

-	// -- Division --
-
+	// Division
 	val minusTwo = parser.parseExpression("6 / -3").getValue(Int::class.java)  // -2

 	val one = parser.parseExpression("8.0 / 4e0 / 2").getValue(Double::class.java)  // 1.0

-	// -- Modulus --
-
+	// Modulus
 	val three = parser.parseExpression("7 % 4").getValue(Int::class.java)  // 3

-	val oneInt = parser.parseExpression("8 / 5 % 2").getValue(Int::class.java)  // 1
-
-	// -- Exponential power --
-
-	val maxInt = parser.parseExpression("(2^31) - 1").getValue(Int::class.java)  // Integer.MAX_VALUE
-
-	val minInt = parser.parseExpression("-2^31").getValue(Int::class.java)  // Integer.MIN_VALUE
-
-	// -- Operator precedence --
+	val one = parser.parseExpression("8 / 5 % 2").getValue(Int::class.java)  // 1

+	// Operator precedence
 	val minusTwentyOne = parser.parseExpression("1+2-3*8").getValue(Int::class.java)  // -21	
 ----
 ======
@@ -529,83 +325,3 @@ Kotlin::
 ======


-[[expressions-operators-overloaded]]
-== Overloaded Operators
-
-By default, the mathematical operations defined in SpEL's `Operation` enum (`ADD`,
-`SUBTRACT`, `DIVIDE`, `MULTIPLY`, `MODULUS`, and `POWER`) support simple types like
-numbers. By providing an implementation of `OperatorOverloader`, the expression language
-can support these operations on other types.
-
-For example, if we want to overload the `ADD` operator to allow two lists to be
-concatenated using the `+` sign, we can implement a custom `OperatorOverloader` as
-follows.
-
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	pubic class ListConcatenation implements OperatorOverloader {
-
-		@Override
-		public boolean overridesOperation(Operation operation, Object left, Object right) {
-			return (operation == Operation.ADD &&
-					left instanceof List && right instanceof List);
-		}
-
-		@Override
-		@SuppressWarnings("unchecked")
-		public Object operate(Operation operation, Object left, Object right) {
-			if (operation == Operation.ADD &&
-					left instanceof List list1 && right instanceof List list2) {
-
-				List result = new ArrayList(list1);
-				result.addAll(list2);
-				return result;
-			}
-			throw new UnsupportedOperationException(
-				"No overload for operation %s and operands [%s] and [%s]"
-					.formatted(operation, left, right));
-		}
-	}
----
-
-If we register `ListConcatenation` as the `OperatorOverloader` in a
-`StandardEvaluationContext`, we can then evaluate expressions like `{1, 2, 3} + {4, 5}`
-as demonstrated in the following example.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	StandardEvaluationContext context = new StandardEvaluationContext();
-	context.setOperatorOverloader(new ListConcatenation());
-
-	// evaluates to a new list: [1, 2, 3, 4, 5]
-	parser.parseExpression("{1, 2, 3} + {2 + 2, 5}").getValue(context, List.class);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	StandardEvaluationContext context = StandardEvaluationContext()
-	context.setOperatorOverloader(ListConcatenation())
-
-	// evaluates to a new list: [1, 2, 3, 4, 5]
-	parser.parseExpression("{1, 2, 3} + {2 + 2, 5}").getValue(context, List::class.java)
----
-======
-
-[NOTE]
-====
-An `OperatorOverloader` does not change the default semantics for an operator. For
-example, `2 + 2` in the above example still evaluates to `4`.
-====
-
-[CAUTION]
-====
-Any expression that uses an overloaded operator cannot be compiled. See
-xref:core/expressions/evaluation.adoc#expressions-compiler-limitations[Compiler Limitations]
-for details.
-====
@@ -1,5 +1,5 @@
 [[expressions-templating]]
-= Expression Templating
+= Expression templating

 Expression templates allow mixing literal text with one or more evaluation blocks.
 Each evaluation block is delimited with prefix and suffix characters that you can
@@ -32,13 +32,53 @@ Kotlin::
 ======

 The string is evaluated by concatenating the literal text `'random number is '` with the
-result of evaluating the expression inside the `#{ }` delimiters (in this case, the
-result of calling that `random()` method). The second argument to the `parseExpression()`
-method is of the type `ParserContext`. The `ParserContext` interface is used to influence
-how the expression is parsed in order to support the expression templating functionality.
-The `TemplateParserContext` used in the previous example resides in the
-`org.springframework.expression.common` package and is an implementation of the
-`ParserContext` which by default configures the prefix and suffix to `#{` and `}`,
-respectively.
+result of evaluating the expression inside the `#{ }` delimiter (in this case, the result
+of calling that `random()` method). The second argument to the `parseExpression()` method
+is of the type `ParserContext`. The `ParserContext` interface is used to influence how
+the expression is parsed in order to support the expression templating functionality.
+The definition of `TemplateParserContext` follows:
+
+[tabs]
+======
+Java::
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	public class TemplateParserContext implements ParserContext {
+
+		public String getExpressionPrefix() {
+			return "#{";
+		}
+
+		public String getExpressionSuffix() {
+			return "}";
+		}
+
+		public boolean isTemplate() {
+			return true;
+		}
+	}
+----
+
+Kotlin::
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	class TemplateParserContext : ParserContext {
+
+		override fun getExpressionPrefix(): String {
+			return "#{"
+		}
+
+		override fun getExpressionSuffix(): String {
+			return "}"
+		}
+
+		override fun isTemplate(): Boolean {
+			return true
+		}
+	}
+----
+======


@@ -6,36 +6,15 @@ are set by using the `setVariable()` method in `EvaluationContext` implementatio

 [NOTE]
 ====
-Variable names must be begin with a letter (as defined below), an underscore, or a dollar
-sign.
-
-Variable names must be composed of one or more of the following supported types of
+Valid variable names must be composed of one or more of the following supported
 characters.

-* letter: any character for which `java.lang.Character.isLetter(char)` returns `true`
-  - This includes letters such as `A` to `Z`, `a` to `z`, `ü`, `ñ`, and `é` as well as
-    letters from other character sets such as Chinese, Japanese, Cyrillic, etc.
-* digit: `0` to `9`
+* letters: `A` to `Z` and `a` to `z`
+* digits: `0` to `9`
 * underscore: `_`
 * dollar sign: `$`
 ====

-[TIP]
-====
-When setting a variable or root context object in the `EvaluationContext`, it is advised
-that the type of the variable or root context object be `public`.
-
-Otherwise, certain types of SpEL expressions involving a variable or root context object
-with a non-public type may fail to evaluate or compile.
-====
-
-[WARNING]
-====
-Since variables share a common namespace with
-xref:core/expressions/language-ref/functions.adoc[functions] in the evaluation context,
-care must be taken to ensure that variable names and functions names do not overlap.
-====
-
 The following example shows how to use variables.

 [tabs]
@@ -429,7 +429,7 @@ Kotlin::
 ----
 ======

-A `ConstraintViolation` on `Person.name()` is adapted to a `FieldError` with the following:
+A `ConstraintViolation` on `Person.name()` is adapted to a `FieldErrro` with the following:

 - Error codes `"Size.student.name"`, `"Size.name"`, `"Size.java.lang.String"`, and `"Size"`
 - Message arguments `"name"`, `10`, and `1` (the field name and the constraint attributes)
@@ -717,7 +717,7 @@ For example, with positional parameters:

 	public int countOfActorsByFirstName(String firstName) {
 		return this.jdbcClient.sql("select count(*) from t_actor where first_name = ?")
-				.param(firstName)
+				.param(firstName);
 				.query(Integer.class).single();
 	}
 ----
@@ -730,7 +730,7 @@ For example, with named parameters:

 	public int countOfActorsByFirstName(String firstName) {
 		return this.jdbcClient.sql("select count(*) from t_actor where first_name = :firstName")
-				.param("firstName", firstName)
+				.param("firstName", firstName);
 				.query(Integer.class).single();
 	}
 ----
@@ -759,8 +759,8 @@ With a required single object result:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	Actor actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?")
-			.param(1212L)
+	Actor actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
+			.param(1212L);
 			.query(Actor.class)
 			.single();
 ----
@@ -769,8 +769,8 @@ With a `java.util.Optional` result:

 [source,java,indent=0,subs="verbatim,quotes"]
 ----
-	Optional<Actor> actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?")
-			.param(1212L)
+	Optional<Actor> actor = this.jdbcClient.sql("select first_name, last_name from t_actor where id = ?",
+			.param(1212L);
 			.query(Actor.class)
 			.optional();
 ----
@@ -780,7 +780,7 @@ And for an update statement:
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (?, ?)")
-			.param("Leonor").param("Watling")
+			.param("Leonor").param("Watling");
 			.update();
 ----

@@ -789,7 +789,7 @@ Or an update statement with named parameters:
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.param("firstName", "Leonor").param("lastName", "Watling")
+			.param("firstName", "Leonor").param("lastName", "Watling");
 			.update();
 ----

@@ -800,7 +800,7 @@ provides `firstName` and `lastName` properties, such as the `Actor` class from a
 [source,java,indent=0,subs="verbatim,quotes"]
 ----
 	this.jdbcClient.sql("insert into t_actor (first_name, last_name) values (:firstName, :lastName)")
-			.paramSource(new Actor("Leonor", "Watling")
+			.paramSource(new Actor("Leonor", "Watling");
 			.update();
 ----

@@ -268,8 +268,8 @@ The actual JPA provider bootstrapping is handed off to the specified executor an
 running in parallel, to the application bootstrap thread. The exposed `EntityManagerFactory`
 proxy can be injected into other application components and is even able to respond to
 `EntityManagerFactoryInfo` configuration inspection. However, once the actual JPA provider
-is being accessed by other components (for example, calling `createEntityManager`), those
-calls block until the background bootstrapping has completed. In particular, when you use
+is being accessed by other components (for example, calling `createEntityManager`), those calls
+block until the background bootstrapping has completed. In particular, when you use
 Spring Data JPA, make sure to set up deferred bootstrapping for its repositories as well.


@@ -284,9 +284,9 @@ to a newly created `EntityManager` per operation, in effect making its usage thr

 It is possible to write code against the plain JPA without any Spring dependencies, by
 using an injected `EntityManagerFactory` or `EntityManager`. Spring can understand the
-`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method
-level if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example
-shows a plain JPA DAO implementation that uses the `@PersistenceUnit` annotation:
+`@PersistenceUnit` and `@PersistenceContext` annotations both at the field and the method level
+if a `PersistenceAnnotationBeanPostProcessor` is enabled. The following example shows a plain
+JPA DAO implementation that uses the `@PersistenceUnit` annotation:

 [tabs]
 ======
@@ -74,11 +74,10 @@ Kotlin::
 ----
 ======

-Used at the class level as above, the annotation indicates a default for all methods
-of the declaring class (as well as its subclasses). Alternatively, each method can be
-annotated individually. See
-xref:data-access/transaction/declarative/annotations.adoc#transaction-declarative-annotations-method-visibility[method visibility]
-for further details on which methods Spring considers transactional. Note that a class-level
+Used at the class level as above, the annotation indicates a default for all methods of
+the declaring class (as well as its subclasses). Alternatively, each method can be
+annotated individually. See xref:data-access/transaction/declarative/annotations.adoc#transaction-declarative-annotations-method-visibility[method visibility] for
+further details on which methods Spring considers transactional. Note that a class-level
 annotation does not apply to ancestor classes up the class hierarchy; in such a scenario,
 inherited methods need to be locally redeclared in order to participate in a
 subclass-level annotation.
@@ -437,10 +436,9 @@ properties of the `@Transactional` annotation:
 | Optional array of exception name patterns that must not cause rollback.
 |===

-TIP: See
-xref:data-access/transaction/declarative/rolling-back.adoc#transaction-declarative-rollback-rules[Rollback rules]
-for further details on rollback rule semantics, patterns, and warnings
-regarding possible unintentional matches for pattern-based rollback rules.
+TIP: See xref:data-access/transaction/declarative/rolling-back.adoc#transaction-declarative-rollback-rules[Rollback rules] for further details
+on rollback rule semantics, patterns, and warnings regarding possible unintentional
+matches for pattern-based rollback rules.

 Currently, you cannot have explicit control over the name of a transaction, where 'name'
 means the transaction name that appears in a transaction monitor and in logging output.
@@ -23,9 +23,9 @@ As of Spring Framework 5.2, the default configuration also provides support for
 Vavr's `Try` method to trigger transaction rollbacks when it returns a 'Failure'.
 This allows you to handle functional-style errors using Try and have the transaction
 automatically rolled back in case of a failure. For more information on Vavr's Try,
-refer to the https://docs.vavr.io/#_try[official Vavr documentation].
-Here's an example of how to use Vavr's Try with a transactional method:
+refer to the [official Vavr documentation](https://www.vavr.io/vavr-docs/#_try).

+Here's an example of how to use Vavr's Try with a transactional method:
 [tabs]
 ======
 Java::
@@ -42,32 +42,6 @@ Java::
 ----
 ======

-As of Spring Framework 6.1, there is also special treatment of `CompletableFuture`
-(and general `Future`) return values, triggering a rollback for such a handle if it
-was exceptionally completed at the time of being returned from the original method.
-This is intended for `@Async` methods where the actual method implementation may
-need to comply with a `CompletableFuture` signature (auto-adapted to an actual
-asynchronous handle for a call to the proxy by `@Async` processing at runtime),
-preferring exposure in the returned handle rather than rethrowing an exception:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	@Transactional @Async
-	public CompletableFuture<String> myTransactionalMethod() {
-		try {
-			return CompletableFuture.completedFuture(delegate.myDataAccessOperation());
-		}
-		catch (DataAccessException ex) {
-			return CompletableFuture.failedFuture(ex);
-		}
-	}
----
-======
-
 Checked exceptions that are thrown from a transactional method do not result in a rollback
 in the default configuration. You can configure exactly which `Exception` types mark a
 transaction for rollback, including checked exceptions by specifying _rollback rules_.
@@ -18,7 +18,7 @@ WebSocket, RSocket.
 xref:integration.adoc[Integration] :: REST Clients, JMS, JCA, JMX,
 Email, Tasks, Scheduling, Caching, Observability, JVM Checkpoint Restore.
 xref:languages.adoc[Languages] :: Kotlin, Groovy, Dynamic Languages.
-xref:appendix.adoc[Appendix] :: Spring properties.
+xref:testing/appendix.adoc[Appendix] :: Spring properties.
 {spring-framework-wiki}[Wiki] :: What's New,
 Upgrade Notes, Supported Versions, additional cross-version information.

@@ -1,6 +1,5 @@
-[[cds]]
-= CDS
-:page-aliases: integration/class-data-sharing.adoc
+[[class-data-sharing]]
+= Class Data Sharing

 Class Data Sharing (CDS) is a https://docs.oracle.com/en/java/javase/17/vm/class-data-sharing.html[JVM feature]
 that can help reduce the startup time and memory footprint of Java applications.
@@ -13,12 +13,12 @@ The Spring Framework provides the following choices for making calls to REST end
 == `RestClient`

 The `RestClient` is a synchronous HTTP client that offers a modern, fluent API.
-It offers an abstraction over HTTP libraries that allows for convenient conversion from a Java object to an HTTP request, and the creation of objects from an HTTP response.
+It offers an abstraction over HTTP libraries that allows for convenient conversion from Java object to HTTP request, and creation of objects from the HTTP response.

 === Creating a `RestClient`

 The `RestClient` is created using one of the static `create` methods.
-You can also use `builder()` to get a builder with further options, such as specifying which HTTP library to use (see <<rest-request-factories>>) and which message converters to use (see <<rest-message-conversion>>), setting a default URI, default path variables, default request headers, or `uriBuilderFactory`, or registering interceptors and initializers.
+You can also use `builder` to get a builder with further options, such as specifying which HTTP library to use (see <<rest-request-factories>>) and which message converters to use (see <<rest-message-conversion>>), setting a default URI, default path variables, a default request headers, or `uriBuilderFactory`, or registering interceptors and initializers.

 Once created (or built), the `RestClient` can be used safely by multiple threads.

@@ -51,9 +51,9 @@ val defaultClient = RestClient.create()

 val customClient = RestClient.builder()
  .requestFactory(HttpComponentsClientHttpRequestFactory())
-  .messageConverters { converters -> converters.add(MyCustomMessageConverter()) }
+  .messageConverters(converters -> converters.add(MyCustomMessageConverter()))
  .baseUrl("https://example.com")
-  .defaultUriVariables(mapOf("variable" to "foo"))
+  .defaultUriVariables(Map.of("variable", "foo"))
  .defaultHeader("My-Header", "Foo")
  .requestInterceptor(myCustomInterceptor)
  .requestInitializer(myCustomInitializer)
@@ -64,62 +64,35 @@ val customClient = RestClient.builder()
 === Using the `RestClient`

 When making an HTTP request with the `RestClient`, the first thing to specify is which HTTP method to use.
-This can be done with `method(HttpMethod)` or with the convenience methods `get()`, `head()`, `post()`, and so on.
+This can be done with `method(HttpMethod)`, or with the convenience methods `get()`, `head()`, `post()`, and so on.

 ==== Request URL

 Next, the request URI can be specified with the `uri` methods.
-This step is optional and can be skipped if the `RestClient` is configured with a default URI.
-The URL is typically specified as a `String`, with optional URI template variables.
-The following example configures a GET request to `https://example.com/orders/42`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-int id = 42;
-restClient.get()
-  .uri("https://example.com/orders/{id}", id)
-  ....
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-val id = 42
-restClient.get()
-  .uri("https://example.com/orders/{id}", id)
-  ...
----
-======
-
-A function can also be used for more controls, such as specifying xref:web/webmvc/mvc-uri-building.adoc[request parameters].
-
+This step is optional, and can be skipped if the `RestClient` is configured with a default URI.
+The URL is typically specified as `String`, with optional URI template variables.
 String URLs are encoded by default, but this can be changed by building a client with a custom `uriBuilderFactory`.
-The URL can also be provided with a function or as a `java.net.URI`, both of which are not encoded.
+
+The URL can also be provided with a function, or as `java.net.URI`, both of which are not encoded.
 For more details on working with and encoding URIs, see xref:web/webmvc/mvc-uri-building.adoc[URI Links].

 ==== Request headers and body

-If necessary, the HTTP request can be manipulated by adding request headers with `header(String, String)`, `headers(Consumer<HttpHeaders>`, or with the convenience methods `accept(MediaType...)`, `acceptCharset(Charset...)` and so on.
-For HTTP requests that can contain a body (`POST`, `PUT`, and `PATCH`), additional methods are available: `contentType(MediaType)`, and `contentLength(long)`.
+If necessary, the HTTP request can be manipulated, by adding request headers with `header(String, String)`, `headers(Consumer<HttpHeaders>`, or with the convenience methods `accept(MediaType...)`, `acceptCharset(Charset...)` and so on.
+For HTTP request that can contain a body (`POST`, `PUT`, and `PATCH`), additional methods are available: `contentType(MediaType)`, and `contentLength(long)`.

 The request body itself can be set by `body(Object)`, which internally uses <<rest-message-conversion>>.
 Alternatively, the request body can be set using a `ParameterizedTypeReference`, allowing you to use generics.
 Finally, the body can be set to a callback function that writes to an `OutputStream`.

 ==== Retrieving the response
-
 Once the request has been set up, the HTTP response is accessed by invoking `retrieve()`.
-The response body can be accessed by using `body(Class)` or `body(ParameterizedTypeReference)` for parameterized types like lists.
-The `body` method converts the response contents into various types – for instance, bytes can be converted into a `String`, JSON can be converted into objects using Jackson, and so on (see <<rest-message-conversion>>).
+The response body can be accessed by using `body(Class)`, or `body(ParameterizedTypeReference)` for parameterized types like lists.
+The `body` method converts the response contents into various types, for instance bytes can be converted into a `String`, JSON into objects using Jackson, and so on (see <<rest-message-conversion>>).

 The response can also be converted into a `ResponseEntity`, giving access to the response headers as well as the body.

-This sample shows how `RestClient` can be used to perform a simple `GET` request.
+This sample shows how `RestClient` can be used to perform a simple GET request.

 [tabs]
 ======
@@ -198,7 +171,7 @@ println("Contents: " + result.body) <3>
 ======

 `RestClient` can convert JSON to objects, using the Jackson library.
-Note the usage of URI variables in this sample and that the `Accept` header is set to JSON.
+Note the usage of uri variables in this sample, and that the `Accept` header is set to JSON.

 [tabs]
 ======
@@ -275,9 +248,8 @@ val response = restClient.post() <2>
 ======

 ==== Error handling
-
 By default, `RestClient` throws a subclass of `RestClientException` when retrieving a response with a 4xx or 5xx status code.
-This behavior can be overridden using `onStatus`.
+This behavior can be overriden using `onStatus`.

 [tabs]
 ======
@@ -314,9 +286,8 @@ val result = restClient.get() <1>
 ======

 ==== Exchange
-
-For more advanced scenarios, the `RestClient` gives access to the underlying HTTP request and response through the `exchange()` method, which can be used instead of `retrieve()`.
-Status handlers are not applied when use `exchange()`, because the exchange function already provides access to the full response, allowing you to perform any error handling necessary.
+For more advanced scenarios, the `RestClient` gives access to the underlying HTTP request and response through the `exchange` method, which can be used instead of `retrieve()`.
+Status handlers are not applied when you exchange, because the exchange function already provides access to the full response, allowing you to perform any error handling necessary.

 [tabs]
 ======
@@ -365,7 +336,6 @@ val result = restClient.get()

 [[rest-message-conversion]]
 === HTTP Message Conversion
-
 [.small]#xref:web/webflux/reactive-spring.adoc#webflux-codecs[See equivalent in the Reactive stack]#

 The `spring-web` module contains the `HttpMessageConverter` interface for reading and writing the body of HTTP requests and responses through `InputStream` and `OutputStream`.
@@ -427,7 +397,7 @@ By default, this converter supports `text/xml` and `application/xml`.
 |===

 By default, `RestClient` and `RestTemplate` register all built-in message converters, depending on the availability of underlying libraries on the classpath.
-You can also set the message converters to use explicitly, by using the `messageConverters()` method on the `RestClient` builder, or via the `messageConverters` property of `RestTemplate`.
+You can also set the message converters to use explicitly, by using `messageConverters` on the `RestClient` builder, or via the `messageConverters` property of `RestTemplate`.

 ==== Jackson JSON Views

@@ -467,13 +437,13 @@ parts.add("xmlPart", new HttpEntity<>(myBean, headers));
 ----

 In most cases, you do not have to specify the `Content-Type` for each part.
-The content type is determined automatically based on the `HttpMessageConverter` chosen to serialize it or, in the case of a `Resource`, based on the file extension.
+The content type is determined automatically based on the `HttpMessageConverter` chosen to serialize it or, in the case of a `Resource` based on the file extension.
 If necessary, you can explicitly provide the `MediaType` with an `HttpEntity` wrapper.

-Once the `MultiValueMap` is ready, you can use it as the body of a `POST` request, using  `RestClient.post().body(parts)` (or `RestTemplate.postForObject`).
+Once the `MultiValueMap` is ready, you can use it as the body of a POST request, using  `RestClient.post().body(parts)` (or `RestTemplate.postForObject`).

 If the `MultiValueMap` contains at least one non-`String` value, the `Content-Type` is set to `multipart/form-data` by the `FormHttpMessageConverter`.
-If the `MultiValueMap` has `String` values, the `Content-Type` defaults to `application/x-www-form-urlencoded`.
+If the `MultiValueMap` has `String` values the `Content-Type` defaults to `application/x-www-form-urlencoded`.
 If necessary the `Content-Type` may also be set explicitly.

 [[rest-request-factories]]
@@ -483,20 +453,17 @@ To execute the HTTP request, `RestClient` uses a client HTTP library.
 These libraries are adapted via the `ClientRequestFactory` interface.
 Various implementations are available:

-* `JdkClientHttpRequestFactory` for Java's `HttpClient`
-* `HttpComponentsClientHttpRequestFactory` for use with Apache HTTP Components `HttpClient`
-* `JettyClientHttpRequestFactory` for Jetty's `HttpClient`
-* `ReactorNettyClientRequestFactory` for Reactor Netty's `HttpClient`
-* `SimpleClientHttpRequestFactory` as a simple default
+* `JdkClientHttpRequestFactory` for Java's `HttpClient`,
+* `HttpComponentsClientHttpRequestFactory` for use with Apache HTTP Components `HttpClient`,
+* `JettyClientHttpRequestFactory` for Jetty's `HttpClient`,
+* `ReactorNettyClientRequestFactory` for Reactor Netty's `HttpClient`,
+* `SimpleClientHttpRequestFactory` as a simple default.


 If no request factory is specified when the `RestClient` was built, it will use the Apache or Jetty `HttpClient` if they are available on the classpath.
 Otherwise, if the `java.net.http` module is loaded, it will use Java's `HttpClient`.
 Finally, it will resort to the simple default.

-TIP: Note that the `SimpleClientHttpRequestFactory` may raise an exception when accessing the status of a response that represents an error (e.g. 401).
-If this is an issue, use any of the alternative request factories.
-
 [[rest-webclient]]
 == `WebClient`

@@ -506,12 +473,12 @@ synchronous, asynchronous, and streaming scenarios.

 `WebClient` supports the following:

-* Non-blocking I/O
-* Reactive Streams back pressure
-* High concurrency with fewer hardware resources
-* Functional-style, fluent API that takes advantage of Java 8 lambdas
-* Synchronous and asynchronous interactions
-* Streaming up to or streaming down from a server
+* Non-blocking I/O.
+* Reactive Streams back pressure.
+* High concurrency with fewer hardware resources.
+* Functional-style, fluent API that takes advantage of Java 8 lambdas.
+* Synchronous and asynchronous interactions.
+* Streaming up to or streaming down from a server.

 See xref:web/webflux-webclient.adoc[WebClient] for more details.

@@ -881,17 +848,17 @@ It can be used to migrate from the latter to the former.
 .toEntity(ParameterizedTypeReference)` footnote:request-entity[]


-| `execute(String, HttpMethod, RequestCallback, ResponseExtractor, Object...)`
+| `execute(String, HttpMethod method, RequestCallback, ResponseExtractor, Object...)`
 | `method(HttpMethod)
 .uri(String, Object...)
 .exchange(ExchangeFunction)`

-| `execute(String, HttpMethod, RequestCallback, ResponseExtractor, Map)`
+| `execute(String, HttpMethod method, RequestCallback, ResponseExtractor, Map)`
 | `method(HttpMethod)
 .uri(String, Map)
 .exchange(ExchangeFunction)`

-| `execute(URI, HttpMethod, RequestCallback, ResponseExtractor)`
+| `execute(URI, HttpMethod method, RequestCallback, ResponseExtractor)`
 | `method(HttpMethod)
 .uri(URI)
 .exchange(ExchangeFunction)`
@@ -1006,9 +973,6 @@ method parameters:
  `Map<String, ?>` with multiple variables, or an individual value. Type conversion
  is supported for non-String values.

-| `@RequestAttribute`
-| Provide an `Object` to add as a request attribute. Only supported by `WebClient`.
-
 | `@RequestBody`
 | Provide the body of the request either as an Object to be serialized, or a
  Reactive Streams `Publisher` such as `Mono`, `Flux`, or any other async type supported
@@ -8,7 +8,7 @@ existing Java application.

 The Spring Framework provides a dedicated `ApplicationContext` that supports a Groovy-based
 Bean Definition DSL. For more details, see
-xref:core/beans/basics.adoc#beans-factory-groovy[The Groovy Bean Definition DSL].
+xref:core/beans/basics.adoc#groovy-bean-definition-dsl[The Groovy Bean Definition DSL].

 Further support for Groovy, including beans written in Groovy, refreshable script beans,
 and more is available in xref:languages/dynamic.adoc[Dynamic Language Support].
@@ -9,7 +9,7 @@ in Kotlin.
 [[final-by-default]]
 == Final by Default

-By default, https://discuss.kotlinlang.org/t/classes-final-by-default/166[all classes and member functions in Kotlin are `final`].
+By default, https://discuss.kotlinlang.org/t/classes-final-by-default/166[all classes in Kotlin are `final`].
 The `open` modifier on a class is the opposite of Java's `final`: It allows others to inherit from this
 class. This also applies to member functions, in that they need to be marked as `open` to be overridden.

@@ -38,12 +38,6 @@ Meta-annotation support means that types annotated with `@Configuration`, `@Cont
 `@RestController`, `@Service`, or `@Repository` are automatically opened since these
 annotations are meta-annotated with `@Component`.

-WARNING: Some use cases involving proxies and automatic generation of final methods by the Kotlin compiler require extra
-care. For example, a Kotlin class with properties will generate related `final` getters and setters. In order
-to be able to proxy related methods, a type level `@Component` annotation should be preferred to method level `@Bean` in
-order to have those methods opened by the `kotlin-spring` plugin. A typical use case is `@Scope` and its popular
-`@RequestScope` specialization.
-
 https://start.spring.io/#!language=kotlin&type=gradle-project[start.spring.io] enables
 the `kotlin-spring` plugin by default. So, in practice, you can write your Kotlin beans
 without any additional `open` keyword, as in Java.
@@ -166,14 +160,14 @@ public class SampleConfiguration {
 	@Bean
 	@NotNull
 	public SampleBean sampleBean$demo_kotlin_internal_test() {
-		return new SampleBean();
+        return new SampleBean();
 	}
 }
 ----

 As a consequence, the related bean name represented as a Kotlin string is `"sampleBean\$demo_kotlin_internal_test"`,
 instead of `"sampleBean"` for the regular `public` function use-case. Make sure to use the mangled name when injecting
-such bean by name, or add `@JvmName("sampleBean")` to disable name mangling.
+such bean by name.

 [[injecting-configuration-properties]]
 == Injecting Configuration Properties
@@ -111,8 +111,7 @@ a mock service with Mockito:
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
 	<bean id="accountService" class="org.mockito.Mockito" factory-method="mock">
-		<constructor-arg type="java.lang.Class" value="org.example.AccountService"/>
-		<constructor-arg type="java.lang.String" value="accountService"/>
+		<constructor-arg value="org.example.AccountService"/>
 	</bean>
 ----

@@ -153,7 +152,7 @@ Kotlin::
 		@Autowired
 		lateinit var accountService: AccountService

-		lateinit var mockMvc: MockMvc
+		lateinit mockMvc: MockMvc

 		@BeforeEach
 		fun setup(wac: WebApplicationContext) {
@@ -1,7 +1,7 @@
 [[spring-mvc-test-vs-end-to-end-integration-tests]]
 = MockMvc vs End-to-End Tests

-MockMvc is built on Servlet API mock implementations from the
+MockMVc is built on Servlet API mock implementations from the
 `spring-test` module and does not rely on a running container. Therefore, there are
 some differences when compared to full end-to-end integration tests with an actual
 client and a live server running.
@@ -1,16 +1,38 @@
 [[spring-mvc-test-vs-streaming-response]]
 = Streaming Responses

-You can use `WebTestClient` to test xref:testing/webtestclient.adoc#webtestclient-stream[streaming responses]
-such as Server-Sent Events. However, `MockMvcWebTestClient` doesn't support infinite
-streams because there is no way to cancel the server stream from the client side.
-To test infinite streams, you'll need to
-xref:testing/webtestclient.adoc#webtestclient-server-config[bind to] a running server,
-or when using Spring Boot,
-{spring-boot-docs}/spring-boot-features.html#boot-features-testing-spring-boot-applications-testing-with-running-server[test with a running server].
+The best way to test streaming responses such as Server-Sent Events is through the
+<<WebTestClient>> which can be used as a test client to connect to a `MockMvc` instance
+to perform tests on Spring MVC controllers without a running server. For example:

-`MockMvcWebTestClient` does support asynchronous responses, and even streaming responses.
-The limitation is that it can't influence the server to stop, and therefore the server
-must finish writing the response on its own.
+[tabs]
+======
+Java::
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	WebTestClient client = MockMvcWebTestClient.bindToController(new SseController()).build();
+
+	FluxExchangeResult<Person> exchangeResult = client.get()
+			.uri("/persons")
+			.exchange()
+			.expectStatus().isOk()
+			.expectHeader().contentType("text/event-stream")
+			.returnResult(Person.class);
+
+	// Use StepVerifier from Project Reactor to test the streaming response
+
+	StepVerifier.create(exchangeResult.getResponseBody())
+			.expectNext(new Person("N0"), new Person("N1"), new Person("N2"))
+			.expectNextCount(4)
+			.consumeNextWith(person -> assertThat(person.getName()).endsWith("7"))
+			.thenCancel()
+			.verify();
+----
+======
+
+`WebTestClient` can also connect to a live server and perform full end-to-end integration
+tests. This is also supported in Spring Boot where you can
+{spring-boot-docs}/spring-boot-features.html#boot-features-testing-spring-boot-applications-testing-with-running-server[test a running server].


@@ -2,7 +2,7 @@
 = Context Configuration with Groovy Scripts

 To load an `ApplicationContext` for your tests by using Groovy scripts that use the
-xref:core/beans/basics.adoc#beans-factory-groovy[Groovy Bean Definition DSL], you can annotate
+xref:core/beans/basics.adoc#groovy-bean-definition-dsl[Groovy Bean Definition DSL], you can annotate
 your test class with `@ContextConfiguration` and configure the `locations` or `value`
 attribute with an array that contains the resource locations of Groovy scripts. Resource
 lookup semantics for Groovy scripts are the same as those described for
@@ -672,13 +672,13 @@ Kotlin::
 	val result = client.get().uri("/persons/1")
 			.exchange()
 			.expectStatus().isOk()
-			.expectBody<Person>()
-			.returnResult()
+			.expectBody(Person.class)
+			.returnResult();

 	// For a response without a body
 	val result = client.get().uri("/path")
 			.exchange()
-			.expectBody().isEmpty()
+			.expectBody().isEmpty();
 ----
 ======

@@ -782,73 +782,6 @@ Kotlin::
 ======


-[[webflux-fn-serving-resources]]
-== Serving Resources
-
-WebFlux.fn provides built-in support for serving resources.
-
-NOTE: In addition to the capabilities described below, it is possible to implement even more flexible resource handling thanks to
-{spring-framework-api}++/web/reactive/function/server/RouterFunctions.html#resources(java.util.function.Function)++[`RouterFunctions#resource(java.util.function.Function)`].
-
-[[webflux-fn-resource]]
-=== Redirecting to a resource
-
-It is possible to redirect requests matching a specified predicate to a resource. This can be useful, for example,
-for handling redirects in Single Page Applications.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-	ClassPathResource index = new ClassPathResource("static/index.html");
-	List<String> extensions = Arrays.asList("js", "css", "ico", "png", "jpg", "gif");
-	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
-	RouterFunction<ServerResponse> redirectToIndex = route()
-		.resource(spaPredicate, index)
-		.build();
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-	val redirectToIndex = router {
-		val index = ClassPathResource("static/index.html")
-		val extensions = listOf("js", "css", "ico", "png", "jpg", "gif")
-		val spaPredicate = !(path("/api/**") or path("/error") or
-			pathExtension(extensions::contains))
-		resource(spaPredicate, index)
-	}
----
-======
-
-[[webflux-fn-resources]]
-=== Serving resources from a root location
-
-It is also possible to route requests that match a given pattern to resources relative to a given root location.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-    Resource location = new FileSystemResource("public-resources/");
-    RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-    val location = FileSystemResource("public-resources/")
-    val resources = router { resources("/resources/**", location) }
----
-======
-
-
 [[webflux-fn-running]]
 == Running a Server
 [.small]#xref:web/webmvc-functional.adoc#webmvc-fn-running[See equivalent in the Servlet stack]#
@@ -4,13 +4,10 @@
 `spring-webflux` depends on `reactor-core` and uses it internally to compose asynchronous
 logic and to provide Reactive Streams support. Generally, WebFlux APIs return `Flux` or
 `Mono` (since those are used internally) and leniently accept any Reactive Streams
-`Publisher` implementation as input.
-When a `Publisher` is provided, it can be treated only as a stream with unknown semantics (0..N).
-If, however, the semantics are known, you should wrap it with `Flux` or `Mono.from(Publisher)` instead
-of passing the raw `Publisher`.
-The use of `Flux` versus `Mono` is important, because it helps to express cardinality --
-for example, whether a single or multiple asynchronous values are expected,
-and that can be essential for making decisions (for example, when encoding or decoding HTTP messages).
+`Publisher` implementation as input. The use of `Flux` versus `Mono` is important, because
+it helps to express cardinality -- for example, whether a single or multiple asynchronous
+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
@@ -18,3 +15,15 @@ the application. This is done with the help of the
 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.
+
+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
+of passing the raw `Publisher`.
+
+For example, given a `Publisher` that is not a `Mono`, the Jackson JSON message writer
+expects multiple values. If the media type implies an infinite stream (for example,
+`application/json+stream`), values are written and flushed individually. Otherwise,
+values are buffered into a list and rendered as a JSON array.
@@ -5,14 +5,14 @@

 A common requirement for REST services is to include details in the body of error
 responses. The Spring Framework supports the "Problem Details for HTTP APIs"
-specification, {rfc-site}/rfc9457.html[RFC 9457].
+specification, {rfc-site}/rfc7807.html[RFC 7807].

 The following are the main abstractions for this support:

- `ProblemDetail` -- representation for an RFC 9457 problem detail; a simple container
+- `ProblemDetail` -- representation for an RFC 7807 problem detail; a simple container
 for both standard fields defined in the spec, and for non-standard ones.
 - `ErrorResponse` -- contract to expose HTTP error response details including HTTP
-status, response headers, and a body in the format of RFC 9457; this allows exceptions to
+status, response headers, and a body in the format of RFC 7807; this allows exceptions to
 encapsulate and expose the details of how they map to an HTTP response. All Spring WebFlux
 exceptions implement this.
 - `ErrorResponseException` -- basic `ErrorResponse` implementation that others
@@ -28,7 +28,7 @@ and any `ErrorResponseException`, and renders an error response with a body.
 [.small]#xref:web/webmvc/mvc-ann-rest-exceptions.adoc#mvc-ann-rest-exceptions-render[See equivalent in the Servlet stack]#

 You can return `ProblemDetail` or `ErrorResponse` from any `@ExceptionHandler` or from
-any `@RequestMapping` method to render an RFC 9457 response. This is processed as follows:
+any `@RequestMapping` method to render an RFC 7807 response. This is processed as follows:

 - The `status` property of `ProblemDetail` determines the HTTP status.
 - The `instance` property of `ProblemDetail` is set from the current URL path, if not
@@ -37,7 +37,7 @@ already set.
 "application/problem+json" over "application/json" when rendering a `ProblemDetail`,
 and also falls back on it if no compatible media type is found.

-To enable RFC 9457 responses for Spring WebFlux exceptions and for any
+To enable RFC 7807 responses for Spring WebFlux exceptions and for any
 `ErrorResponseException`, extend `ResponseEntityExceptionHandler` and declare it as an
 xref:web/webflux/controller/ann-advice.adoc[@ControllerAdvice] in Spring configuration. The handler
 has an `@ExceptionHandler` method that handles any `ErrorResponse` exception, which
@@ -50,7 +50,7 @@ use a protected method to map any exception to a `ProblemDetail`.
 == Non-Standard Fields
 [.small]#xref:web/webmvc/mvc-ann-rest-exceptions.adoc#mvc-ann-rest-exceptions-non-standard[See equivalent in the Servlet stack]#

-You can extend an RFC 9457 response with non-standard fields in one of two ways.
+You can extend an RFC 7807 response with non-standard fields in one of two ways.

 One, insert into the "properties" `Map` of `ProblemDetail`. When using the Jackson
 library, the Spring Framework registers `ProblemDetailJacksonMixin` that ensures this
@@ -81,7 +81,7 @@ Kotlin::
 ----
 ======

-NOTE: `@JsonView` allows an array of view classes but you can specify only one per
+NOTE: `@JsonView` allows an array of view classes but you can only specify only one per
 controller method. Use a composite interface if you need to activate multiple views.


@@ -4,20 +4,9 @@
 [.small]#xref:web/webmvc/mvc-controller/ann-methods/return-types.adoc[See equivalent in the Servlet stack]#

 The following table shows the supported controller method return values. Note that reactive
-types from libraries such as Reactor, RxJava, xref:web/webflux-reactive-libraries.adoc[or other] are
+types from libraries such as Reactor, RxJava, xref:web-reactive.adoc#webflux-reactive-libraries[or other] are
 generally supported for all return values.

-For return types like `Flux`, when multiple values are expected, elements are streamed as they come
-and are not buffered. This is the default behavior, as keeping a potentially large amount of elements in memory
-is not efficient. If the media type implies an infinite stream (for example,
-`application/json+stream`), values are written and flushed individually. Otherwise,
-values are written individually and the flushing happens separately.
-
-NOTE: If an error happens while an element is encoded to JSON, the response might have been written to and committed already
-and it is impossible at that point to render a proper error response.
-In some cases, applications can choose to trade memory efficiency for better handling such errors by buffering elements and encoding them all at once.
-Controllers can then return a `Flux<List<B>>`; Reactor provides a dedicated operator for that, `Flux#collectList()`.
-
 [cols="1,2", options="header"]
 |===
 | Controller method return value | Description
@@ -35,11 +24,11 @@ Controllers can then return a `Flux<List<B>>`; Reactor provides a dedicated oper
 | For returning a response with headers and no body.

 | `ErrorResponse`
-| To render an RFC 9457 error response with details in the body,
+| To render an RFC 7807 error response with details in the body,
  see xref:web/webflux/ann-rest-exceptions.adoc[Error Responses]

 | `ProblemDetail`
-| To render an RFC 9457 error response with details in the body,
+| To render an RFC 7807 error response with details in the body,
  see xref:web/webflux/ann-rest-exceptions.adoc[Error Responses]

 | `String`
@@ -28,12 +28,6 @@ because, arguably, most controller methods should be mapped to a specific HTTP m
 using `@RequestMapping`, which, by default, matches to all HTTP methods. At the same time, a
 `@RequestMapping` is still needed at the class level to express shared mappings.

-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
-
 The following example uses type and method level mappings:

 [tabs]
@@ -442,14 +436,8 @@ attributes with a narrower, more specific purpose.
 `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`, and `@PatchMapping` are
 examples of composed annotations. They are provided, because, arguably, most
 controller methods should be mapped to a specific HTTP method versus using `@RequestMapping`,
-which, by default, matches to all HTTP methods. If you need an example of how to implement
-a composed annotation, look at how those are declared.
-
-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
+which, by default, matches to all HTTP methods. If you need an example of composed
+annotations, look at how those are declared.

 Spring WebFlux also supports custom request mapping attributes with custom request matching
 logic. This is a more advanced option that requires sub-classing
@@ -523,17 +511,10 @@ Kotlin::
 == `@HttpExchange`
 [.small]#xref:web/webmvc/mvc-controller/ann-requestmapping.adoc#mvc-ann-httpexchange-annotation[See equivalent in the Servlet stack]#

-While the main purpose of `@HttpExchange` is to abstract HTTP client code with a
-generated proxy, the
-xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] on which
-such annotations are placed is a contract neutral to client vs server use.
-In addition to simplifying client code, there are also cases where an HTTP Interface
-may be a convenient way for servers to expose their API for client access. This leads
-to increased coupling between client and server and is often not a good choice,
-especially for public API's, but may be exactly the goal for an internal API.
-It is an approach commonly used in Spring Cloud, and it is why `@HttpExchange` is
-supported as an alternative to `@RequestMapping` for server side handling in
-controller classes.
+As an alternative to  `@RequestMapping`, you can also handle requests with `@HttpExchange`
+methods. Such methods are declared on an
+xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] and can be used as
+a client via `HttpServiceProxyFactory` or implemented by a server `@Controller`.

 For example:

@@ -543,23 +524,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		Person getPerson(@PathVariable Long id);
-
-		@PostExchange
-		void add(@RequestBody Person person);
-	}
-
-	@RestController
-	class PersonController implements PersonService {
-
 		public Person getPerson(@PathVariable Long id) {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
 		public void add(@RequestBody Person person) {
 			// ...
@@ -571,38 +545,30 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		fun getPerson(@PathVariable id: Long): Person
-
-		@PostExchange
-		fun add(@RequestBody person: Person)
-	}
-
-	@RestController
-	class PersonController : PersonService {
-
-		override fun getPerson(@PathVariable id: Long): Person {
+		fun getPerson(@PathVariable id: Long): Person {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
-		override fun add(@RequestBody person: Person) {
+		fun add(@RequestBody person: Person) {
 			// ...
 		}
 	}
 ----
 ======

-`@HttpExchange` and `@RequestMapping` have differences.
-`@RequestMapping` can map to any number of requests by path patterns, HTTP methods,
-and more, while `@HttpExchange` declares a single endpoint with a concrete HTTP method,
-path, and content types.
-
-For method parameters and returns values, generally, `@HttpExchange` supports a
-subset of the method parameters that `@RequestMapping` does. Notably, it excludes any
-server-side specific parameter types. For details, see the list for
-xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[@HttpExchange] and
+There some differences between `@HttpExchange` and `@RequestMapping` since the
+former needs to remain suitable for client and server use. For example, while
+`@RequestMapping` can be declared to handle any number of paths and each path can
+be a pattern, `@HttpExchange` must be declared with a single, concrete path. There are
+also differences in the supported method parameters. Generally, `@HttpExchange` supports
+a subset of method parameters that `@RequestMapping` does, excluding any parameters that
+are server side only. For details see the list of supported method parameters for
+xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[HTTP interface] and for
 xref:web/webflux/controller/ann-methods/arguments.adoc[@RequestMapping].
@@ -8,23 +8,22 @@ Spring WebFlux has built-in xref:core/validation/validator.adoc[Validation] supp
 xref:core/validation/beanvalidation.adoc[Java Bean Validation].
 The validation support works on two levels.

-First, resolvers for
+First, method parameters such as
 xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
 xref:web/webflux/controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] method
-parameters perform validation if the parameter has Jakarta's `@Valid` or Spring's
-`@Validated` annotation, and raise `MethodArgumentNotValidException` if necessary.
-Alternatively, you can handle the errors in the controller method by adding an
-`Errors` or `BindingResult` method parameter immediately after the validated one.
+xref:web/webflux/controller/ann-methods/multipart-forms.adoc[@RequestPart] do perform
+validation if annotated with Jakarta's `@Valid` or Spring's `@Validated` annotation, and
+raise `MethodArgumentNotValidException` in case of validation errors. If you want to handle
+the errors in the controller method instead, you can declare an `Errors` or `BindingResult`
+method parameter immediately after the validated parameter.

-Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ any method
-parameter has `@Constraint` annotations, then method validation is applied instead,
-raising `HandlerMethodValidationException` if necessary. For this case you can still add
-an `Errors` or `BindingResult` method parameter to handle validation errors within the
-controller method, but if other method arguments have validation errors then
-`HandlerMethodValidationException` is raised instead. Method validation can apply
-to the return value if the method is annotated with `@Valid` or with `@Constraint`
-annotations.
+Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ other method
+parameters, e.g. `@RequestHeader`, `@RequestParam`, `@PathVariable` have `@Constraint`
+annotations, then method validation is applied to all method arguments, raising
+`HandlerMethodValidationException` in case of validation errors. You can still declare an
+`Errors` or `BindingResult` after an `@Valid` method parameter, and handle validation
+errors within the controller method, as long as there are no validation errors on other
+method arguments.

 You can configure a `Validator` globally through the
 xref:web/webflux/config.adoc#webflux-config-validation[WebMvc config], or locally
@@ -760,73 +760,6 @@ Kotlin::
 ======


-[[webmvc-fn-serving-resources]]
-== Serving Resources
-
-WebMvc.fn provides built-in support for serving resources.
-
-NOTE: In addition to the capabilities described below, it is possible to implement even more flexible resource handling thanks to
-{spring-framework-api}++/web/servlet/function/RouterFunctions.html#resources(java.util.function.Function)++[`RouterFunctions#resource(java.util.function.Function)`].
-
-[[webmvc-fn-resource]]
-=== Redirecting to a resource
-
-It is possible to redirect requests matching a specified predicate to a resource. This can be useful, for example,
-for handling redirects in Single Page Applications.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-    ClassPathResource index = new ClassPathResource("static/index.html");
-	List<String> extensions = Arrays.asList("js", "css", "ico", "png", "jpg", "gif");
-	RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
-	RouterFunction<ServerResponse> redirectToIndex = route()
-		.resource(spaPredicate, index)
-		.build();
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-    val redirectToIndex = router {
-		val index = ClassPathResource("static/index.html")
-		val extensions = listOf("js", "css", "ico", "png", "jpg", "gif")
-		val spaPredicate = !(path("/api/**") or path("/error") or
-			pathExtension(extensions::contains))
-		resource(spaPredicate, index)
-	}
----
-======
-
-[[webmvc-fn-resources]]
-=== Serving resources from a root location
-
-It is also possible to route requests that match a given pattern to resources relative to a given root location.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
----
-    Resource location = new FileSystemResource("public-resources/");
-    RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
----
-    val location = FileSystemResource("public-resources/")
-    val resources = router { resources("/resources/**", location) }
----
-======
-
-
 [[webmvc-fn-running]]
 == Running a Server
 [.small]#xref:web/webflux-functional.adoc#webflux-fn-running[See equivalent in the Reactive stack]#
@@ -36,7 +36,7 @@ to render the response content as XML. If the model contains multiple entries, y
 explicitly set the object to be serialized by using the `modelKey` bean property. If the
 model contains a single entry, it is serialized automatically.

-You can customize XML mapping as needed by using JAXB or Jackson's provided
+You can customized XML mapping as needed by using JAXB or Jackson's provided
 annotations. When you need further control, you can inject a custom `XmlMapper`
 through the `ObjectMapper` property, for cases where custom XML
 you need to provide serializers and deserializers for specific types.
@@ -683,7 +683,7 @@ the HTML would be as follows:
 ----

 What if we want to display the entire list of errors for a given page? The next example
-shows that the `errors` tag also supports some basic wildcard functionality.
+shows that the `errors` tag also supports some basic wildcarding functionality.

 * `path="{asterisk}"`: Displays all errors.
 * `path="lastName"`: Displays all errors associated with the `lastName` field.
@@ -500,8 +500,8 @@ The MVC configuration exposes the following options for asynchronous request pro

 You can configure the following:

-* The default timeout value for async requests depends
-on the underlying Servlet container, unless it is set explicitly.
+* Default timeout value for async requests, which if not set, depends
+on the underlying Servlet container.
 * `AsyncTaskExecutor` to use for blocking writes when streaming with
 xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-reactive-types[Reactive Types] and for
 executing `Callable` instances returned from controller methods.
@@ -5,14 +5,14 @@

 A common requirement for REST services is to include details in the body of error
 responses. The Spring Framework supports the "Problem Details for HTTP APIs"
-specification, {rfc-site}/rfc9457[RFC 9457].
+specification, {rfc-site}/rfc7807[RFC 7807].

 The following are the main abstractions for this support:

- `ProblemDetail` -- representation for an RFC 9457 problem detail; a simple container
+- `ProblemDetail` -- representation for an RFC 7807 problem detail; a simple container
 for both standard fields defined in the spec, and for non-standard ones.
 - `ErrorResponse` -- contract to expose HTTP error response details including HTTP
-status, response headers, and a body in the format of RFC 9457; this allows exceptions to
+status, response headers, and a body in the format of RFC 7807; this allows exceptions to
 encapsulate and expose the details of how they map to an HTTP response. All Spring MVC
 exceptions implement this.
 - `ErrorResponseException` -- basic `ErrorResponse` implementation that others
@@ -28,7 +28,7 @@ and any `ErrorResponseException`, and renders an error response with a body.
 [.small]#xref:web/webflux/ann-rest-exceptions.adoc#webflux-ann-rest-exceptions-render[See equivalent in the Reactive stack]#

 You can return `ProblemDetail` or `ErrorResponse` from any `@ExceptionHandler` or from
-any `@RequestMapping` method to render an RFC 9457 response. This is processed as follows:
+any `@RequestMapping` method to render an RFC 7807 response. This is processed as follows:

 - The `status` property of `ProblemDetail` determines the HTTP status.
 - The `instance` property of `ProblemDetail` is set from the current URL path, if not
@@ -37,7 +37,7 @@ already set.
 "application/problem+json" over "application/json" when rendering a `ProblemDetail`,
 and also falls back on it if no compatible media type is found.

-To enable RFC 9457 responses for Spring WebFlux exceptions and for any
+To enable RFC 7807 responses for Spring WebFlux exceptions and for any
 `ErrorResponseException`, extend `ResponseEntityExceptionHandler` and declare it as an
 xref:web/webmvc/mvc-controller/ann-advice.adoc[@ControllerAdvice] in Spring configuration. The handler
 has an `@ExceptionHandler` method that handles any `ErrorResponse` exception, which
@@ -50,7 +50,7 @@ use a protected method to map any exception to a `ProblemDetail`.
 == Non-Standard Fields
 [.small]#xref:web/webflux/ann-rest-exceptions.adoc#webflux-ann-rest-exceptions-non-standard[See equivalent in the Reactive stack]#

-You can extend an RFC 9457 response with non-standard fields in one of two ways.
+You can extend an RFC 7807 response with non-standard fields in one of two ways.

 One, insert into the "properties" `Map` of `ProblemDetail`. When using the Jackson
 library, the Spring Framework registers `ProblemDetailJacksonMixin` that ensures this
@@ -79,11 +79,9 @@ message code arguments for the "detail" field. `ResponseEntityExceptionHandler`
 these through a xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
 and updates the corresponding `ProblemDetail` fields accordingly.

-The default strategy for message codes is as follows:
+The default strategy for message codes follows the pattern:

-* "type": `problemDetail.type.[fully qualified exception class name]`
-* "title": `problemDetail.title.[fully qualified exception class name]`
-* "detail": `problemDetail.[fully qualified exception class name][suffix]`
+`problemDetail.[type|title|detail].[fully qualified exception class name]`

 An `ErrorResponse` may expose more than one message code, typically adding a suffix
 to the default message code. The table below lists message codes, and arguments for
@@ -138,7 +136,7 @@ Message codes and arguments for each error are also resolved via `MessageSource`
 | `MethodArgumentNotValidException`
 | (default)
 | `+{0}+` the list of global errors, `+{1}+` the list of field errors.
-  Message codes and arguments for each error are also resolved via `MessageSource`.
+  Message codes and arguments for each error are also resolvedvia `MessageSource`.

 | `MissingRequestHeaderException`
 | (default)
@@ -52,10 +52,14 @@ The following example shows how to achieve the same configuration in XML:
 	</mvc:interceptors>
 ----

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

 NOTE: The XML config declares interceptors as `MappedInterceptor` beans, and those are in
 turn detected by any `HandlerMapping` bean, including those from other frameworks.
@@ -228,11 +228,11 @@ level, xref:web/webmvc/mvc-servlet/exceptionhandlers.adoc[HandlerExceptionResolv
  See xref:web/webmvc/mvc-controller/ann-methods/responseentity.adoc[ResponseEntity].

 | `ErrorResponse`
-| To render an RFC 9457 error response with details in the body,
+| To render an RFC 7807 error response with details in the body,
 see xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses]

 | `ProblemDetail`
-| To render an RFC 9457 error response with details in the body,
+| To render an RFC 7807 error response with details in the body,
 see xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses]

 | `String`
@@ -37,13 +37,6 @@ Kotlin::
 all controller methods. This is the effect of `@RestController`, which is nothing more
 than a meta-annotation marked with `@Controller` and `@ResponseBody`.

-A `Resource` object can be returned for file content, copying the `InputStream`
-content of the provided resource to the response `OutputStream`. Note that the
-`InputStream` should be lazily retrieved by the `Resource` handle in order to reliably
-close it after it has been copied to the response. If you are using `InputStreamResource`
-for such a purpose, make sure to construct it with an on-demand `InputStreamSource`
-(e.g. through a lambda expression that retrieves the actual `InputStream`).
-
 You can use `@ResponseBody` with reactive types.
 See xref:web/webmvc/mvc-ann-async.adoc[Asynchronous Requests] and xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-reactive-types[Reactive Types] for more details.

@@ -32,16 +32,6 @@ Kotlin::
 ----
 ======

-The body will usually be provided as a value object to be rendered to a corresponding
-response representation (e.g. JSON) by one of the registered `HttpMessageConverters`.
-
-A `ResponseEntity<Resource>` can be returned for file content, copying the `InputStream`
-content of the provided resource to the response `OutputStream`. Note that the
-`InputStream` should be lazily retrieved by the `Resource` handle in order to reliably
-close it after it has been copied to the response. If you are using `InputStreamResource`
-for such a purpose, make sure to construct it with an on-demand `InputStreamSource`
-(e.g. through a lambda expression that retrieves the actual `InputStream`).
-
 Spring MVC supports using a single value xref:web/webmvc/mvc-ann-async.adoc#mvc-ann-async-reactive-types[reactive type]
 to produce the `ResponseEntity` asynchronously, and/or single and multi-value reactive
 types for the body. This allows the following types of async responses:
@@ -23,11 +23,11 @@ supported for all return values.
 | For returning a response with headers and no body.

 | `ErrorResponse`
-| To render an RFC 9457 error response with details in the body,
+| To render an RFC 7807 error response with details in the body,
  see xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses]

 | `ProblemDetail`
-| To render an RFC 9457 error response with details in the body,
+| To render an RFC 7807 error response with details in the body,
  see xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses]

 | `String`
@@ -30,12 +30,6 @@ arguably, most controller methods should be mapped to a specific HTTP method ver
 using `@RequestMapping`, which, by default, matches to all HTTP methods.
 A `@RequestMapping` is still needed at the class level to express shared mappings.

-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
-
 The following example has type and method level mappings:

 [tabs]
@@ -468,6 +462,11 @@ transparently for request mapping. Controller methods do not need to change.
 A response wrapper, applied in `jakarta.servlet.http.HttpServlet`, ensures a `Content-Length`
 header is set to the number of bytes written (without actually writing to the response).

+`@GetMapping` (and `@RequestMapping(method=HttpMethod.GET)`) are implicitly mapped to
+and support HTTP HEAD. An HTTP HEAD request is processed as if it were HTTP GET except
+that, instead of writing the body, the number of bytes are counted and the `Content-Length`
+header is set.
+
 By default, HTTP OPTIONS is handled by setting the `Allow` response header to the list of HTTP
 methods listed in all `@RequestMapping` methods that have matching URL patterns.

@@ -492,14 +491,8 @@ attributes with a narrower, more specific purpose.
 `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`, and `@PatchMapping` are
 examples of composed annotations. They are provided because, arguably, most
 controller methods should be mapped to a specific HTTP method versus using `@RequestMapping`,
-which, by default, matches to all HTTP methods. If you need an example of how to implement
-a composed annotation, look at how those are declared.
-
-NOTE: `@RequestMapping` cannot be used in conjunction with other `@RequestMapping`
-annotations that are declared on the same element (class, interface, or method). If
-multiple `@RequestMapping` annotations are detected on the same element, a warning will
-be logged, and only the first mapping will be used. This also applies to composed
-`@RequestMapping` annotations such as `@GetMapping`, `@PostMapping`, etc.
+which, by default, matches to all HTTP methods. If you need an example of composed
+annotations, look at how those are declared.

 Spring MVC also supports custom request-mapping attributes with custom request-matching
 logic. This is a more advanced option that requires subclassing
@@ -569,17 +562,10 @@ Kotlin::
 == `@HttpExchange`
 [.small]#xref:web/webflux/controller/ann-requestmapping.adoc#webflux-ann-httpexchange-annotation[See equivalent in the Reactive stack]#

-While the main purpose of `@HttpExchange` is to abstract HTTP client code with a
-generated proxy, the
-xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] on which
-such annotations are placed is a contract neutral to client vs server use.
-In addition to simplifying client code, there are also cases where an HTTP Interface
-may be a convenient way for servers to expose their API for client access. This leads
-to increased coupling between client and server and is often not a good choice,
-especially for public API's, but may be exactly the goal for an internal API.
-It is an approach commonly used in Spring Cloud, and it is why `@HttpExchange` is
-supported as an alternative to `@RequestMapping` for server side handling in
-controller classes.
+As an alternative to  `@RequestMapping`, you can also handle requests with `@HttpExchange`
+methods. Such methods are declared on an
+xref:integration/rest-clients.adoc#rest-http-interface[HTTP Interface] and can be used as
+a client via `HttpServiceProxyFactory` or implemented by a server `@Controller`.

 For example:

@@ -589,23 +575,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		Person getPerson(@PathVariable Long id);
-
-		@PostExchange
-		void add(@RequestBody Person person);
-	}
-
-	@RestController
-	class PersonController implements PersonService {
-
 		public Person getPerson(@PathVariable Long id) {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
 		public void add(@RequestBody Person person) {
 			// ...
@@ -617,38 +596,30 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
+	@RestController
 	@HttpExchange("/persons")
-	interface PersonService {
+	class PersonController {

 		@GetExchange("/{id}")
-		fun getPerson(@PathVariable id: Long): Person
-
-		@PostExchange
-		fun add(@RequestBody person: Person)
-	}
-
-	@RestController
-	class PersonController : PersonService {
-
-		override fun getPerson(@PathVariable id: Long): Person {
+		fun getPerson(@PathVariable id: Long): Person {
 			// ...
 		}

+		@PostExchange
 		@ResponseStatus(HttpStatus.CREATED)
-		override fun add(@RequestBody person: Person) {
+		fun add(@RequestBody person: Person) {
 			// ...
 		}
 	}
 ----
 ======

-`@HttpExchange` and `@RequestMapping` have differences.
-`@RequestMapping` can map to any number of requests by path patterns, HTTP methods,
-and more, while `@HttpExchange` declares a single endpoint with a concrete HTTP method,
-path, and content types.
-
-For method parameters and returns values, generally, `@HttpExchange` supports a
-subset of the method parameters that `@RequestMapping` does. Notably, it excludes any
-server-side specific parameter types. For details, see the list for
-xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[@HttpExchange] and
+There some differences between `@HttpExchange` and `@RequestMapping` since the
+former needs to remain suitable for client and server use. For example, while
+`@RequestMapping` can be declared to handle any number of paths and each path can
+be a pattern, `@HttpExchange` must be declared with a single, concrete path. There are
+also differences in the supported method parameters. Generally, `@HttpExchange` supports
+a subset of method parameters that `@RequestMapping` does, excluding any parameters that
+are server side only. For details see the list of supported method parameters for
+xref:integration/rest-clients.adoc#rest-http-interface-method-parameters[HTTP interface] and for
 xref:web/webmvc/mvc-controller/ann-methods/arguments.adoc[@RequestMapping].
@@ -8,23 +8,23 @@ Spring MVC has built-in xref:core/validation/validator.adoc[Validation] support
 xref:core/validation/beanvalidation.adoc[Java Bean Validation].
 The validation support works on two levels.

-First, resolvers for
+First, method parameters such as
 xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
 xref:web/webmvc/mvc-controller/ann-methods/requestbody.adoc[@RequestBody], and
-xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[@RequestPart] method
-parameters perform validation if the parameter has Jakarta's `@Valid` or Spring's
-`@Validated` annotation, and raise `MethodArgumentNotValidException` if necessary.
-Alternatively, you can handle the errors in the controller method by adding an
-`Errors` or `BindingResult` method parameter immediately after the validated one.
+xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[@RequestPart] do perform
+validation if annotated with Jakarta's `@Valid` or Spring's `@Validated` annotation, and
+raise `MethodArgumentNotValidException` in case of validation errors. If you want to handle
+the errors in the controller method instead, you can declare an `Errors` or `BindingResult`
+method parameter immediately after the validated parameter.

-Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ any method
-parameter has `@Constraint` annotations, then method validation is applied instead,
-raising `HandlerMethodValidationException` if necessary. For this case you can still add
-an `Errors` or `BindingResult` method parameter to handle validation errors within the
-controller method, but if other method arguments have validation errors then
-`HandlerMethodValidationException` is raised instead. Method validation can apply
-to the return value if the method is annotated with `@Valid` or with `@Constraint`
-annotations.
+Second, if {bean-validation-site}[Java Bean Validation] is present _AND_ other method
+parameters, e.g. `@RequestHeader`, `@RequestParam`, `@PathVariable` have `@Constraint`
+annotations, then method validation is applied to all method arguments, raising
+`HandlerMethodValidationException` in case of validation errors. You can still declare an
+`Errors` or `BindingResult` after an `@Valid` method parameter, and handle validation
+errors within the controller method, as long as there are no validation errors on other
+method arguments. Method validation is also applied to the return value if the method
+is annotated with `@Valid` or has other `@Constraint` annotations.

 You can configure a `Validator` globally through the
 xref:web/webmvc/mvc-config/validation.adoc[WebMvc config], or locally through an
@@ -109,4 +109,4 @@ Kotlin::
        }
 	})
 ----
-======
+======
@@ -1,29 +1,34 @@
 [[mvc-handlermapping-interceptor]]
 = Interception

-All `HandlerMapping` implementations support handler interception which is useful when
-you want to apply functionality across requests. A `HandlerInterceptor` can implement the
-following:
+All `HandlerMapping` implementations support handler interceptors that are useful when
+you want to apply specific functionality to certain requests -- for example, checking for
+a principal. Interceptors must implement `HandlerInterceptor` from the
+`org.springframework.web.servlet` package with three methods that should provide enough
+flexibility to do all kinds of pre-processing and post-processing:

-* `preHandle(..)` -- callback before the actual handler is run that returns a boolean.
-If the method returns `true`, execution continues; if it returns `false`, the rest of the
-execution chain is bypassed and the handler is not called.
-* `postHandle(..)` -- callback after the handler is run.
-* `afterCompletion(..)` -- callback after the complete request has finished.
+* `preHandle(..)`: Before the actual handler is run
+* `postHandle(..)`: After the handler is run
+* `afterCompletion(..)`: After the complete request has finished

-NOTE: For `@ResponseBody` and `ResponseEntity` controller methods, the response is written
-and committed within the `HandlerAdapter`, before `postHandle` is called. That means it is
-too late to change the response, such as to add an extra header. You can implement
-`ResponseBodyAdvice` and declare it as an
-xref:web/webmvc/mvc-controller/ann-advice.adoc[Controller Advice] bean or configure it
-directly on `RequestMappingHandlerAdapter`.
+The `preHandle(..)` method returns a boolean value. You can use this method to break or
+continue the processing of the execution chain. When this method returns `true`, the
+handler execution chain continues. When it returns false, the `DispatcherServlet`
+assumes the interceptor itself has taken care of requests (and, for example, rendered an
+appropriate view) and does not continue executing the other interceptors and the actual
+handler in the execution chain.

 See xref:web/webmvc/mvc-config/interceptors.adoc[Interceptors] in the section on MVC configuration for examples of how to
 configure interceptors. You can also register them directly by using setters on individual
 `HandlerMapping` implementations.

-WARNING: Interceptors are not ideally suited as a security layer due to the potential for
-a mismatch with annotated controller path matching. Generally, we recommend using Spring
-Security, or alternatively a similar approach integrated with the Servlet filter chain,
-and applied as early as possible.
+`postHandle` method is less useful with `@ResponseBody` and `ResponseEntity` methods for
+which the response is written and committed within the `HandlerAdapter` and before
+`postHandle`. That means it is too late to make any changes to the response, such as adding
+an extra header. For such scenarios, you can implement `ResponseBodyAdvice` and either
+declare it as an xref:web/webmvc/mvc-controller/ann-advice.adoc[Controller Advice] bean or configure it directly on
+`RequestMappingHandlerAdapter`.
+
+
+

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -24,7 +24,7 @@ import org.springframework.aot.hint.predicate.RuntimeHintsPredicates;

 import static org.assertj.core.api.Assertions.assertThat;

-class SpellCheckServiceTests {
+public class SpellCheckServiceTests {

 	// tag::hintspredicates[]
 	@Test
@@ -7,33 +7,33 @@ javaPlatform {
 }

 dependencies {
-	api(platform("com.fasterxml.jackson:jackson-bom:2.15.4"))
-	api(platform("io.micrometer:micrometer-bom:1.12.6"))
-	api(platform("io.netty:netty-bom:4.1.109.Final"))
+	api(platform("com.fasterxml.jackson:jackson-bom:2.15.3"))
+	api(platform("io.micrometer:micrometer-bom:1.12.2"))
+	api(platform("io.netty:netty-bom:4.1.104.Final"))
 	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2023.0.6"))
+	api(platform("io.projectreactor:reactor-bom:2023.0.2"))
 	api(platform("io.rsocket:rsocket-bom:1.1.3"))
-	api(platform("org.apache.groovy:groovy-bom:4.0.21"))
+	api(platform("org.apache.groovy:groovy-bom:4.0.17"))
 	api(platform("org.apache.logging.log4j:log4j-bom:2.21.1"))
-	api(platform("org.assertj:assertj-bom:3.25.3"))
-	api(platform("org.eclipse.jetty:jetty-bom:12.0.9"))
-	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.9"))
+	api(platform("org.assertj:assertj-bom:3.25.1"))
+	api(platform("org.eclipse.jetty:jetty-bom:12.0.5"))
+	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.5"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-coroutines-bom:1.7.3"))
 	api(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:1.6.0"))
-	api(platform("org.junit:junit-bom:5.10.2"))
-	api(platform("org.mockito:mockito-bom:5.12.0"))
+	api(platform("org.junit:junit-bom:5.10.1"))
+	api(platform("org.mockito:mockito-bom:5.8.0"))

 	constraints {
 		api("com.fasterxml:aalto-xml:1.3.2")
-		api("com.fasterxml.woodstox:woodstox-core:6.6.2")
+		api("com.fasterxml.woodstox:woodstox-core:6.5.1")
 		api("com.github.ben-manes.caffeine:caffeine:3.1.8")
-		api("com.github.librepdf:openpdf:1.3.43")
+		api("com.github.librepdf:openpdf:1.3.36")
 		api("com.google.code.findbugs:findbugs:3.0.1")
 		api("com.google.code.findbugs:jsr305:3.0.2")
 		api("com.google.code.gson:gson:2.10.1")
-		api("com.google.protobuf:protobuf-java-util:3.25.3")
+		api("com.google.protobuf:protobuf-java-util:3.25.1")
 		api("com.h2database:h2:2.2.224")
-		api("com.jayway.jsonpath:json-path:2.9.0")
+		api("com.jayway.jsonpath:json-path:2.8.0")
 		api("com.rometools:rome:1.19.0")
 		api("com.squareup.okhttp3:mockwebserver:3.14.9")
 		api("com.squareup.okhttp3:okhttp:3.14.9")
@@ -42,11 +42,11 @@ dependencies {
 		api("com.sun.xml.bind:jaxb-core:3.0.2")
 		api("com.sun.xml.bind:jaxb-impl:3.0.2")
 		api("com.sun.xml.bind:jaxb-xjc:3.0.2")
-		api("com.thoughtworks.qdox:qdox:2.1.0")
+		api("com.thoughtworks.qdox:qdox:2.0.3")
 		api("com.thoughtworks.xstream:xstream:1.4.20")
 		api("commons-io:commons-io:2.15.0")
 		api("de.bechte.junit:junit-hierarchicalcontextrunner:4.12.2")
-		api("io.micrometer:context-propagation:1.1.1")
+		api("io.micrometer:context-propagation:1.1.0")
 		api("io.mockk:mockk:1.13.4")
 		api("io.projectreactor.netty:reactor-netty5-http:2.0.0-M3")
 		api("io.projectreactor.tools:blockhound:1.0.8.RELEASE")
@@ -55,9 +55,9 @@ dependencies {
 		api("io.r2dbc:r2dbc-spi:1.0.0.RELEASE")
 		api("io.reactivex.rxjava3:rxjava:3.1.8")
 		api("io.smallrye.reactive:mutiny:1.10.0")
-		api("io.undertow:undertow-core:2.3.13.Final")
-		api("io.undertow:undertow-servlet:2.3.13.Final")
-		api("io.undertow:undertow-websockets-jsr:2.3.13.Final")
+		api("io.undertow:undertow-core:2.3.10.Final")
+		api("io.undertow:undertow-servlet:2.3.10.Final")
+		api("io.undertow:undertow-websockets-jsr:2.3.10.Final")
 		api("io.vavr:vavr:0.10.4")
 		api("jakarta.activation:jakarta.activation-api:2.0.1")
 		api("jakarta.annotation:jakarta.annotation-api:2.0.0")
@@ -100,22 +100,22 @@ dependencies {
 		api("org.apache.derby:derby:10.16.1.1")
 		api("org.apache.derby:derbyclient:10.16.1.1")
 		api("org.apache.derby:derbytools:10.16.1.1")
-		api("org.apache.httpcomponents.client5:httpclient5:5.3.1")
+		api("org.apache.httpcomponents.client5:httpclient5:5.3")
 		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.2.4")
 		api("org.apache.poi:poi-ooxml:5.2.5")
-		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.24")
-		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.24")
-		api("org.apache.tomcat:tomcat-util:10.1.24")
-		api("org.apache.tomcat:tomcat-websocket:10.1.24")
-		api("org.aspectj:aspectjrt:1.9.22.1")
-		api("org.aspectj:aspectjtools:1.9.22.1")
-		api("org.aspectj:aspectjweaver:1.9.22.1")
+		api("org.apache.tomcat.embed:tomcat-embed-core:10.1.18")
+		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.18")
+		api("org.apache.tomcat:tomcat-util:10.1.18")
+		api("org.apache.tomcat:tomcat-websocket:10.1.18")
+		api("org.aspectj:aspectjrt:1.9.21")
+		api("org.aspectj:aspectjtools:1.9.21")
+		api("org.aspectj:aspectjweaver:1.9.21")
 		api("org.awaitility:awaitility:4.2.0")
 		api("org.bouncycastle:bcpkix-jdk18on:1.72")
 		api("org.codehaus.jettison:jettison:1.5.4")
 		api("org.crac:crac:1.4.0")
 		api("org.dom4j:dom4j:2.1.4")
-		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.3")
+		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.1")
 		api("org.eclipse.persistence:org.eclipse.persistence.jpa:3.0.4")
 		api("org.eclipse:yasson:2.0.4")
 		api("org.ehcache:ehcache:3.10.8")
@@ -130,7 +130,7 @@ dependencies {
 		api("org.hibernate:hibernate-validator:7.0.5.Final")
 		api("org.hsqldb:hsqldb:2.7.2")
 		api("org.javamoney:moneta:1.4.2")
-		api("org.jruby:jruby:9.4.6.0")
+		api("org.jruby:jruby:9.4.5.0")
 		api("org.junit.support:testng-engine:1.0.5")
 		api("org.mozilla:rhino:1.7.14")
 		api("org.ogce:xpp3:1.1.6")
@@ -139,7 +139,7 @@ dependencies {
 		api("org.seleniumhq.selenium:htmlunit-driver:2.70.0")
 		api("org.seleniumhq.selenium:selenium-java:3.141.59")
 		api("org.skyscreamer:jsonassert:1.5.1")
-		api("org.slf4j:slf4j-api:2.0.12")
+		api("org.slf4j:slf4j-api:2.0.11")
 		api("org.testng:testng:7.9.0")
 		api("org.webjars:underscorejs:1.8.3")
 		api("org.webjars:webjars-locator-core:0.55")
@@ -1,4 +1,4 @@
-version=6.1.7
+version=6.1.3

 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m
@@ -6,7 +6,6 @@ tasks.findByName("dokkaHtmlPartial")?.configure {
 			classpath.from(sourceSets["main"].runtimeClasspath)
 			externalDocumentationLink {
 				url.set(new URL("https://docs.spring.io/spring-framework/docs/current/javadoc-api/"))
-				packageListUrl.set(new URL("https://docs.spring.io/spring-framework/docs/current/javadoc-api/element-list"))
 			}
 			externalDocumentationLink {
 				url.set(new URL("https://projectreactor.io/docs/core/release/api/"))
@@ -22,7 +21,6 @@ tasks.findByName("dokkaHtmlPartial")?.configure {
 			}
 			externalDocumentationLink {
 				url.set(new URL("https://javadoc.io/doc/jakarta.servlet/jakarta.servlet-api/latest/"))
-				packageListUrl.set(new URL("https://javadoc.io/doc/jakarta.servlet/jakarta.servlet-api/latest/element-list"))
 			}
 			externalDocumentationLink {
 				url.set(new URL("https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/"))
@@ -8,9 +8,8 @@ apply plugin: 'me.champeau.jmh'
 apply from: "$rootDir/gradle/publications.gradle"

 dependencies {
-	jmh 'org.openjdk.jmh:jmh-core:1.37'
-	jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37'
-	jmh 'org.openjdk.jmh:jmh-generator-bytecode:1.37'
+	jmh 'org.openjdk.jmh:jmh-core:1.36'
+	jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.36'
 	jmh 'net.sf.jopt-simple:jopt-simple'
 }

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
@@ -43,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute

-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.

 goto fail

@@ -57,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe

 if exist "%JAVA_EXE%" goto execute

-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.

 goto fail

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -75,7 +75,7 @@ class AopNamespaceHandlerScopeIntegrationTests {
 	}

 	@Test
-	void testRequestScoping() {
+	void testRequestScoping() throws Exception {
 		MockHttpServletRequest oldRequest = new MockHttpServletRequest();
 		MockHttpServletRequest newRequest = new MockHttpServletRequest();

@@ -103,7 +103,7 @@ class AopNamespaceHandlerScopeIntegrationTests {
 	}

 	@Test
-	void testSessionScoping() {
+	void testSessionScoping() throws Exception {
 		MockHttpSession oldSession = new MockHttpSession();
 		MockHttpSession newSession = new MockHttpSession();

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -16,6 +16,7 @@

 package org.springframework.aop.framework.autoproxy;

+import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.List;

@@ -60,12 +61,12 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	/**
 	 * Return a bean factory with attributes and EnterpriseServices configured.
 	 */
-	protected BeanFactory getBeanFactory() {
+	protected BeanFactory getBeanFactory() throws IOException {
 		return new ClassPathXmlApplicationContext(DEFAULT_CONTEXT, CLASS);
 	}

 	@Test
-	void testDefaultExclusionPrefix() {
+	void testDefaultExclusionPrefix() throws Exception {
 		DefaultAdvisorAutoProxyCreator aapc = (DefaultAdvisorAutoProxyCreator) getBeanFactory().getBean(ADVISOR_APC_BEAN_NAME);
 		assertThat(aapc.getAdvisorBeanNamePrefix()).isEqualTo((ADVISOR_APC_BEAN_NAME + DefaultAdvisorAutoProxyCreator.SEPARATOR));
 		assertThat(aapc.isUsePrefix()).isFalse();
@@ -75,21 +76,21 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	 * If no pointcuts match (no attrs) there should be proxying.
 	 */
 	@Test
-	void testNoProxy() {
+	void testNoProxy() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		Object o = bf.getBean("noSetters");
 		assertThat(AopUtils.isAopProxy(o)).isFalse();
 	}

 	@Test
-	void testTxIsProxied() {
+	void testTxIsProxied() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		ITestBean test = (ITestBean) bf.getBean("test");
 		assertThat(AopUtils.isAopProxy(test)).isTrue();
 	}

 	@Test
-	void testRegexpApplied() {
+	void testRegexpApplied() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		ITestBean test = (ITestBean) bf.getBean("test");
 		MethodCounter counter = (MethodCounter) bf.getBean("countingAdvice");
@@ -99,7 +100,7 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	}

 	@Test
-	void testTransactionAttributeOnMethod() {
+	void testTransactionAttributeOnMethod() throws Exception {
 		BeanFactory bf = getBeanFactory();
 		ITestBean test = (ITestBean) bf.getBean("test");

@@ -165,7 +166,7 @@ class AdvisorAutoProxyCreatorIntegrationTests {
 	}

 	@Test
-	void testProgrammaticRollback() {
+	void testProgrammaticRollback() throws Exception {
 		BeanFactory bf = getBeanFactory();

 		Object bean = bf.getBean(TXMANAGER_BEAN_NAME);
@@ -249,7 +250,7 @@ class OrderedTxCheckAdvisor extends StaticMethodMatcherPointcutAdvisor implement
 	}

 	@Override
-	public void afterPropertiesSet() {
+	public void afterPropertiesSet() throws Exception {
 		setAdvice(new TxCountingBeforeAdvice());
 	}

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -46,7 +46,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 * @author Brian Clozel
 */
@EnabledIfRuntimeHintsAgent
-class RuntimeHintsAgentTests {
+public class RuntimeHintsAgentTests {

 	private static final ClassLoader classLoader = ClassLoader.getSystemClassLoader();

@@ -58,7 +58,7 @@ class RuntimeHintsAgentTests {


 	@BeforeAll
-	static void classSetup() throws NoSuchMethodException {
+	public static void classSetup() throws NoSuchMethodException {
 		defaultConstructor = String.class.getConstructor();
 		toStringMethod = String.class.getMethod("toString");
 		privateGreetMethod = PrivateClass.class.getDeclaredMethod("greet");
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -39,7 +39,7 @@ class ComponentBeanDefinitionParserTests {


 	@BeforeAll
-	void setUp() {
+	void setUp() throws Exception {
 		new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
 			new ClassPathResource("component-config.xml", ComponentBeanDefinitionParserTests.class));
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -34,7 +34,7 @@ public class ComponentFactoryBean implements FactoryBean<Component> {
 	}

 	@Override
-	public Component getObject() {
+	public Component getObject() throws Exception {
 		if (this.children != null && this.children.size() > 0) {
 			for (Component child : children) {
 				this.parent.addComponent(child);
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -42,6 +42,7 @@ import static org.assertj.core.api.Assertions.assertThatException;
 * @author Chris Beams
 * @since 3.1
 */
+@SuppressWarnings("resource")
 class EnableCachingIntegrationTests {

 	@Test
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -87,6 +87,7 @@ import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Con
 * @author Sam Brannen
 * @see org.springframework.context.support.EnvironmentIntegrationTests
 */
+@SuppressWarnings("resource")
 public class EnvironmentSystemIntegrationTests {

 	private final ConfigurableEnvironment prodEnv = new StandardEnvironment();
@@ -617,7 +618,7 @@ public class EnvironmentSystemIntegrationTests {
 	@Import({DevConfig.class, ProdConfig.class})
 	static class Config {
 		@Bean
-		EnvironmentAwareBean envAwareBean() {
+		public EnvironmentAwareBean envAwareBean() {
 			return new EnvironmentAwareBean();
 		}
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2012 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.
@@ -27,7 +27,6 @@ import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.expression.TypeConverter;
-import org.springframework.util.ClassUtils;

 /**
 * Copied from Spring Integration for purposes of reproducing
@@ -60,9 +59,11 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {

 	@Override
 	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
-		if (beanFactory instanceof ConfigurableBeanFactory cbf &&
-				cbf.getTypeConverter() instanceof SimpleTypeConverter simpleTypeConverter) {
-			this.delegate = simpleTypeConverter;
+		if (beanFactory instanceof ConfigurableBeanFactory) {
+			Object typeConverter = ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
+			if (typeConverter instanceof SimpleTypeConverter) {
+				delegate = (SimpleTypeConverter) typeConverter;
+			}
 		}
 	}

@@ -85,6 +86,7 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {
 		if (conversionService.canConvert(sourceTypeDescriptor, targetTypeDescriptor)) {
 			return true;
 		}
+		// TODO: what does this mean? This method is not used in SpEL so probably ignorable?
 		Class<?> sourceType = sourceTypeDescriptor.getObjectType();
 		Class<?> targetType = targetTypeDescriptor.getObjectType();
 		return canConvert(sourceType, targetType);
@@ -92,7 +94,7 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {

 	@Override
 	public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) {
-		if (ClassUtils.isVoidType(targetType.getType())) {
+		if (targetType.getType() == Void.class || targetType.getType() == Void.TYPE) {
 			return null;
 		}
 		if (conversionService.canConvert(sourceType, targetType)) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -51,6 +51,7 @@ import static org.springframework.core.testfixture.TestGroup.LONG_RUNNING;
 * @author Juergen Hoeller
 * @since 3.1
 */
+@SuppressWarnings("resource")
@EnabledForTestGroups(LONG_RUNNING)
 class ScheduledAndTransactionalAnnotationIntegrationTests {

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 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.
@@ -54,6 +54,7 @@ import static org.assertj.core.api.Assertions.assertThatException;
 * @author Sam Brannen
 * @since 3.1
 */
+@SuppressWarnings("resource")
 class EnableTransactionManagementIntegrationTests {

 	@Test
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2019 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.
@@ -27,13 +27,14 @@ import static org.assertj.core.api.Assertions.assertThat;
 /**
 * Tests proving that regardless the proxy strategy used (JDK interface-based vs. CGLIB
 * subclass-based), discovery of advice-oriented annotations is consistent.
- * <p>
+ *
 * For example, Spring's @Transactional may be declared at the interface or class level,
 * and whether interface or subclass proxies are used, the @Transactional annotation must
 * be discovered in a consistent fashion.
 *
 * @author Chris Beams
 */
+@SuppressWarnings("resource")
 class ProxyAnnotationDiscoveryTests {

 	@Test
--- a/Show More
+++ b/Show More