Release v6.1.11

Closes gh-33061

.github/actions/build/action.yml

@@ -0,0 +1,56 @@
+name: 'Build'
+description: 'Builds the project, optionally publishing it to a local deployment repository'
+inputs:
+  java-version:
+    required: false
+    default: '17'
+    description: 'The Java version to compile and test with'
+  java-distribution:
+    required: false
+    default: 'liberica'
+    description: 'The Java distribution to use for the build'
+  java-toolchain:
+    required: false
+    default: 'false'
+    description: 'Whether a Java toolchain should be used'
+  publish:
+    required: false
+    default: 'false'
+    description: 'Whether to publish artifacts ready for deployment to Artifactory'
+  develocity-access-key:
+    required: false
+    description: 'The access key for authentication with ge.spring.io'
+outputs:
+  build-scan-url:
+    description: 'The URL, if any, of the build scan produced by the build'
+    value: ${{ (inputs.publish == 'true' && steps.publish.outputs.build-scan-url) || steps.build.outputs.build-scan-url }}
+  version:
+    description: 'The version that was built'
+    value: ${{ steps.read-version.outputs.version }}
+runs:
+  using: composite
+  steps:
+    - name: Prepare Gradle Build
+      uses: ./.github/actions/prepare-gradle-build
+      with:
+        develocity-access-key: ${{ inputs.develocity-access-key }}
+        java-version: ${{ inputs.java-version }}
+        java-distribution: ${{ inputs.java-distribution }}
+        java-toolchain: ${{ inputs.java-toolchain }}
+    - name: Build
+      id: build
+      if: ${{ inputs.publish == 'false' }}
+      shell: bash
+      run: ./gradlew check antora
+    - name: Publish
+      id: publish
+      if: ${{ inputs.publish == 'true' }}
+      shell: bash
+      run: ./gradlew -PdeploymentRepository=$(pwd)/deployment-repository build publishAllPublicationsToDeploymentRepository
+    - name: Read Version From gradle.properties
+      id: read-version
+      shell: bash
+      run: |
+        version=$(sed -n 's/version=\(.*\)/\1/p' gradle.properties)
+        echo "Version is $version"
+        echo "version=$version" >> $GITHUB_OUTPUT

.github/actions/create-github-release/action.yml

@@ -0,0 +1,23 @@
+name: Create GitHub Release
+description: Create the release on GitHub with a changelog
+inputs:
+  milestone:
+    description: 'Name of the GitHub milestone for which a release will be created'
+    required: true
+  token:
+    description: 'Token to use for authentication with GitHub'
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Generate Changelog
+      uses: spring-io/github-changelog-generator@185319ad7eaa75b0e8e72e4b6db19c8b2cb8c4c1 #v0.0.11
+      with:
+        milestone: ${{ inputs.milestone }}
+        token: ${{ inputs.token }}
+        config-file: .github/actions/create-github-release/changelog-generator.yml
+    - name: Create GitHub Release
+      env:
+        GITHUB_TOKEN: ${{ inputs.token }}
+      shell: bash
+      run: gh release create ${{ format('v{0}', inputs.milestone) }} --notes-file changelog.md

.github/actions/create-github-release/changelog-generator.yml

@@ -0,0 +1,28 @@
+changelog:
+  repository: spring-projects/spring-framework
+  sections:
+    - title: ":star: New Features"
+      labels:
+        - "type: enhancement"
+    - title: ":lady_beetle: Bug Fixes"
+      labels:
+        - "type: bug"
+        - "type: regression"
+    - title: ":notebook_with_decorative_cover: Documentation"
+      labels:
+        - "type: documentation"
+    - title: ":hammer: Dependency Upgrades"
+      sort: "title"
+      labels:
+        - "type: dependency-upgrade"
+  contributors:
+    exclude:
+      names:
+        - "bclozel"
+        - "jhoeller"
+        - "poutsma"
+        - "rstoyanchev"
+        - "sbrannen"
+        - "sdeleuze"
+        - "simonbasle"
+        - "snicoll"

.github/actions/prepare-gradle-build/action.yml

@@ -0,0 +1,49 @@
+name: 'Prepare Gradle Build'
+description: 'Prepares a Gradle build. Sets up Java and Gradle and configures Gradle properties'
+inputs:
+  java-version:
+    required: false
+    default: '17'
+    description: 'The Java version to use for the build'
+  java-distribution:
+    required: false
+    default: 'liberica'
+    description: 'The Java distribution to use for the build'
+  java-toolchain:
+    required: false
+    default: 'false'
+    description: 'Whether a Java toolchain should be used'
+  develocity-access-key:
+    required: false
+    description: 'The access key for authentication with ge.spring.io'
+runs:
+  using: composite
+  steps:
+    - name: Set Up Java
+      uses: actions/setup-java@v4
+      with:
+        distribution: ${{ inputs.java-distribution }}
+        java-version: |
+          ${{ inputs.java-version }}
+          ${{ inputs.java-toolchain == 'true' && '17' || '' }}
+    - name: Set Up Gradle
+      uses: gradle/actions/setup-gradle@dbbdc275be76ac10734476cc723d82dfe7ec6eda # v3.4.2
+      with:
+        cache-read-only: false
+        develocity-access-key: ${{ inputs.develocity-access-key }}
+    - 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: ${{ inputs.java-toolchain == 'true' }}
+      shell: bash
+      run: |
+        echo toolchainVersion=${{ inputs.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', inputs.java-version) }} >> $HOME/.gradle/gradle.properties

.github/actions/send-notification/action.yml

@@ -0,0 +1,33 @@
+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

.github/actions/sync-to-maven-central/action.yml

@@ -0,0 +1,50 @@
+name: Sync to Maven Central
+description: Syncs a release to Maven Central and waits for it to be available for use
+inputs:
+  jfrog-cli-config-token:
+    description: 'Config token for the JFrog CLI'
+    required: true
+  spring-framework-version:
+    description: 'The version of Spring Framework that is being synced to Central'
+    required: true
+  ossrh-s01-token-username:
+    description: 'Username for authentication with s01.oss.sonatype.org'
+    required: true
+  ossrh-s01-token-password:
+    description: 'Password for authentication with s01.oss.sonatype.org'
+    required: true
+  ossrh-s01-staging-profile:
+    description: 'Staging profile to use when syncing to Central'
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Set Up JFrog CLI
+      uses: jfrog/setup-jfrog-cli@7c95feb32008765e1b4e626b078dfd897c4340ad # v4.1.2
+      env:
+        JF_ENV_SPRING: ${{ inputs.jfrog-cli-config-token }}
+    - name: Download Release Artifacts
+      shell: bash
+      run: jf rt download --spec ${{ format('{0}/artifacts.spec', github.action_path) }} --spec-vars 'buildName=${{ format('spring-framework-{0}', inputs.spring-framework-version) }};buildNumber=${{ github.run_number }}'
+    - name: Sync
+      uses: spring-io/nexus-sync-action@42477a2230a2f694f9eaa4643fa9e76b99b7ab84 # v0.0.1
+      with:
+        username: ${{ inputs.ossrh-s01-token-username }}
+        password: ${{ inputs.ossrh-s01-token-password }}
+        staging-profile-name: ${{ inputs.ossrh-s01-staging-profile }}
+        create: true
+        upload: true
+        close: true
+        release: true
+        generate-checksums: true
+    - name: Await
+      shell: bash
+      run: |
+        url=${{ format('https://repo.maven.apache.org/maven2/org/springframework/spring-context/{0}/spring-context-{0}.jar', inputs.spring-framework-version) }}
+        echo "Waiting for $url"
+        until curl --fail --head --silent $url > /dev/null
+        do
+          echo "."
+          sleep 60
+        done
+        echo "$url is available"

.github/actions/sync-to-maven-central/artifacts.spec

@@ -0,0 +1,20 @@
+{
+  "files": [
+    {
+      "aql": {
+        "items.find": {
+          "$and": [
+            {
+              "@build.name": "${buildName}",
+              "@build.number": "${buildNumber}",
+              "path": {
+                "$nmatch": "org/springframework/framework-api/*"
+              }
+            }
+          ]
+        }
+      },
+      "target": "nexus/"
+    }
+  ]
+}

.github/workflows/backport-bot.yml

@@ -18,11 +18,13 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-java@v3
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Set up Java
+        uses: actions/setup-java@v4
         with:
-          distribution: 'temurin'
-          java-version: '17'
+          distribution: 'liberica'
+          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

.github/workflows/build-and-deploy-snapshot.yml

@@ -0,0 +1,59 @@
+name: Build and Deploy Snapshot
+on:
+  push:
+    branches:
+      - 6.1.x
+permissions:
+  actions: write
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build-and-deploy-snapshot:
+    name: Build and Deploy Snapshot
+    runs-on: ubuntu-latest
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Build and Publish
+        id: build-and-publish
+        uses: ./.github/actions/build
+        with:
+          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+          publish: true
+      - name: Deploy
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
+        with:
+          uri: 'https://repo.spring.io'
+          username: ${{ secrets.ARTIFACTORY_USERNAME }}
+          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          build-name: 'spring-framework-6.1.x'
+          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-and-publish.outputs.build-scan-url }}
+          run-name: ${{ format('{0} | Linux | Java 17', github.ref_name) }}
+    outputs:
+      version: ${{ steps.build-and-publish.outputs.version }}
+  verify:
+    name: Verify
+    needs: build-and-deploy-snapshot
+    uses: ./.github/workflows/verify.yml
+    secrets:
+      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
+      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+    with:
+      version: ${{ needs.build-and-deploy-snapshot.outputs.version }}

.github/workflows/ci.yml

@@ -0,0 +1,57 @@
+name: CI
+on:
+  push:
+    branches:
+      - 6.1.x
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  ci:
+    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
+    runs-on: ${{ matrix.os.id }}
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    strategy:
+      matrix:
+        os:
+          - id: ubuntu-latest
+            name: Linux
+        java:
+          - version: 17
+            toolchain: false
+          - version: 21
+            toolchain: true
+          - version: 22
+            toolchain: true
+          - version: 23-ea
+            distribution: temurin
+            toolchain: true
+        exclude:
+          - os:
+              name: Linux
+            java:
+              version: 17
+    steps:
+      - 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: Build
+        id: build
+        uses: ./.github/actions/build
+        with:
+          java-version: ${{ matrix.java.version }}
+          java-distribution: ${{ matrix.java.distribution || 'liberica' }}
+          java-toolchain: ${{ matrix.java.toolchain }}
+          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+      - 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) }}

.github/workflows/deploy-docs.yml

@@ -1,12 +1,14 @@
 name: Deploy Docs
 on:
   push:
-    branches-ignore: [ gh-pages ]
-    tags: '**'
+    branches:
+      - 'main'
+      - '*.x'
+      - '!gh-pages'
+    tags:
+      - 'v*'
   repository_dispatch:
     types: request-build-reference # legacy
-  schedule:
-  - cron: '0 10 * * *' # Once per day at 10am UTC
   workflow_dispatch:
 permissions:
   actions: write
@@ -15,8 +17,8 @@ jobs:
     runs-on: ubuntu-latest
     if: github.repository_owner == 'spring-projects'
     steps:
-    - name: Checkout
-      uses: actions/checkout@v3
+    - name: Check out code
+      uses: actions/checkout@v4
       with:
         ref: docs-build
         fetch-depth: 1

.github/workflows/gradle-wrapper-validation.yml

@@ -1,13 +0,0 @@
-name: "Validate Gradle Wrapper"
-on: [push, pull_request]
-
-permissions:
-  contents: read
-
-jobs:
-  validation:
-    name: "Validation"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: gradle/wrapper-validation-action@v1

.github/workflows/release.yml

@@ -0,0 +1,90 @@
+name: Release
+on:
+  push:
+    tags:
+      - v6.1.[0-9]+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build-and-stage-release:
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    name: Build and Stage Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Build and Publish
+        id: build-and-publish
+        uses: ./.github/actions/build
+        with:
+          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+          publish: true
+      - name: Stage Release
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
+        with:
+          build-name: ${{ format('spring-framework-{0}', steps.build-and-publish.outputs.version)}}
+          folder: 'deployment-repository'
+          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          repository: 'libs-staging-local'
+          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
+          uri: 'https://repo.spring.io'
+          username: ${{ secrets.ARTIFACTORY_USERNAME }}
+    outputs:
+      version: ${{ steps.build-and-publish.outputs.version }}
+  verify:
+    name: Verify
+    needs: build-and-stage-release
+    uses: ./.github/workflows/verify.yml
+    with:
+      staging: true
+      version: ${{ needs.build-and-stage-release.outputs.version }}
+    secrets:
+      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
+      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+  sync-to-maven-central:
+    name: Sync to Maven Central
+    needs:
+      - build-and-stage-release
+      - verify
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - name: Sync to Maven Central
+        uses: ./.github/actions/sync-to-maven-central
+        with:
+          jfrog-cli-config-token: ${{ secrets.JF_ARTIFACTORY_SPRING }}
+          ossrh-s01-staging-profile: ${{ secrets.OSSRH_S01_STAGING_PROFILE }}
+          ossrh-s01-token-password: ${{ secrets.OSSRH_S01_TOKEN_PASSWORD }}
+          ossrh-s01-token-username: ${{ secrets.OSSRH_S01_TOKEN_USERNAME }}
+          spring-framework-version: ${{ needs.build-and-stage-release.outputs.version }}
+  promote-release:
+    name: Promote Release
+    needs:
+      - build-and-stage-release
+      - sync-to-maven-central
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up JFrog CLI
+        uses: jfrog/setup-jfrog-cli@7c95feb32008765e1b4e626b078dfd897c4340ad # v4.1.2
+        env:
+          JF_ENV_SPRING: ${{ secrets.JF_ARTIFACTORY_SPRING }}
+      - name: Promote build
+        run: jfrog rt build-promote ${{ format('spring-framework-{0}', needs.build-and-stage-release.outputs.version)}} ${{ github.run_number }} libs-release-local
+  create-github-release:
+    name: Create GitHub Release
+    needs:
+      - build-and-stage-release
+      - promote-release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - name: Create GitHub Release
+        uses: ./.github/actions/create-github-release
+        with:
+          milestone: ${{ needs.build-and-stage-release.outputs.version }}
+          token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}

.github/workflows/validate-gradle-wrapper.yml

@@ -0,0 +1,11 @@
+name: "Validate Gradle Wrapper"
+on: [push, pull_request]
+permissions:
+  contents: read
+jobs:
+  validation:
+    name: "Validate Gradle Wrapper"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: gradle/actions/wrapper-validation@dbbdc275be76ac10734476cc723d82dfe7ec6eda # v3.4.2

.github/workflows/verify.yml

@@ -0,0 +1,71 @@
+name: Verify
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      staging:
+        required: false
+        default: false
+        type: boolean
+    secrets:
+      repository-username:
+        required: false
+      repository-password:
+        required: false
+      google-chat-webhook-url:
+        required: true
+      token:
+        required: true
+jobs:
+  verify:
+    name: Verify
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Release Verification Tests
+        uses: actions/checkout@v4
+        with:
+          repository: spring-projects/spring-framework-release-verification
+          ref: 'v0.0.2'
+          token: ${{ secrets.token }}
+      - name: Check Out Send Notification Action
+        uses: actions/checkout@v4
+        with:
+          path: spring-framework
+          sparse-checkout: .github/actions/send-notification
+      - name: Set Up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'liberica'
+          java-version: 17
+      - name: Set Up Gradle
+        uses: gradle/actions/setup-gradle@dbbdc275be76ac10734476cc723d82dfe7ec6eda # v3.4.2
+        with:
+          cache-read-only: false
+      - name: Configure Gradle Properties
+        shell: bash
+        run: |
+          mkdir -p $HOME/.gradle
+          echo 'org.gradle.daemon=false' >> $HOME/.gradle/gradle.properties
+      - name: Run Release Verification Tests
+        env:
+          RVT_VERSION: ${{ inputs.version }}
+          RVT_RELEASE_TYPE: oss
+          RVT_STAGING: ${{ inputs.staging }}
+          RVT_OSS_REPOSITORY_USERNAME: ${{ secrets.repository-username }}
+          RVT_OSS_REPOSITORY_PASSWORD: ${{ secrets.repository-password }}
+        run: ./gradlew spring-framework-release-verification-tests:test
+      - name: Upload Build Reports on Failure
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: build-reports
+          path: '**/build/reports/'
+      - name: Send Notification
+        uses: ./spring-framework/.github/actions/send-notification
+        if: failure()
+        with:
+          webhook-url: ${{ secrets.google-chat-webhook-url }}
+          status: ${{ job.status }}
+          run-name: ${{ format('{0} | Verification | {1}', github.ref_name, inputs.version) }}

.gitignore

@@ -51,3 +51,5 @@ atlassian-ide-plugin.xml
 .vscode/
 
 cached-antora-playbook.yml
+
+node_modules

.sdkmanrc

@@ -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.10-librca
+java=17.0.11-librca

CODE_OF_CONDUCT.adoc

@@ -1,44 +0,0 @@
-= Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of fostering an open
-and welcoming community, we pledge to respect all people who contribute through reporting
-issues, posting feature requests, updating documentation, submitting pull requests or
-patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for
-everyone, regardless of level of experience, gender, gender identity and expression,
-sexual orientation, disability, personal appearance, body size, race, ethnicity, age,
-religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic addresses,
-  without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments,
-commits, code, wiki edits, issues, and other contributions that are not aligned to this
-Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors
-that they deem inappropriate, threatening, offensive, or harmful.
-
-By adopting this Code of Conduct, project maintainers commit themselves to fairly and
-consistently applying these principles to every aspect of managing this project. Project
-maintainers who do not follow or enforce the Code of Conduct may be permanently removed
-from the project team.
-
-This Code of Conduct applies both within project spaces and in public spaces when an
-individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by
-contacting a project maintainer at spring-code-of-conduct@pivotal.io . All complaints will
-be reviewed and investigated and will result in a response that is deemed necessary and
-appropriate to the circumstances. Maintainers are obligated to maintain confidentiality
-with regard to the reporter of an incident.
-
-This Code of Conduct is adapted from the
-https://contributor-covenant.org[Contributor Covenant], version 1.3.0, available at
-https://contributor-covenant.org/version/1/3/0/[contributor-covenant.org/version/1/3/0/]

CONTRIBUTING.md

@@ -18,7 +18,7 @@ First off, thank you for taking the time to contribute! :+1: :tada:
 
 This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc).
 By participating you are expected to uphold this code.
-Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
+Please report unacceptable behavior to spring-code-of-conduct@spring.io.
 
 ### How to Contribute
 

README.md

@@ -1,4 +1,4 @@
-# <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 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://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)
 
 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". 
 
@@ -6,7 +6,7 @@ Spring provides everything required beyond the Java programming language for cre
 
 ## Code of Conduct
 
-This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc). By participating, you are expected to uphold this code of conduct. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
+This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc). By participating, you are expected to uphold this code of conduct. Please report unacceptable behavior to spring-code-of-conduct@spring.io.
 
 ## Access to Binaries
 

build.gradle

@@ -89,9 +89,6 @@ configure([rootProject] + javaProjects) { project ->
 	ext.javadocLinks = [
 			"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",
 			"https://www.quartz-scheduler.org/api/2.3.0/",

buildSrc/gradle.properties

@@ -1,2 +1,2 @@
 org.gradle.caching=true
-javaFormatVersion=0.0.41
+javaFormatVersion=0.0.42

buildSrc/src/main/java/org/springframework/build/CheckstyleConventions.java

@@ -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.13.0");
+			checkstyle.setToolVersion("10.17.0");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
@@ -64,7 +64,7 @@ public class CheckstyleConventions {
 		NoHttpExtension noHttp = project.getExtensions().getByType(NoHttpExtension.class);
 		noHttp.setAllowlistFile(project.file("src/nohttp/allowlist.lines"));
 		noHttp.getSource().exclude("**/test-output/**", "**/.settings/**",
-				"**/.classpath", "**/.project", "**/.gradle/**");
+				"**/.classpath", "**/.project", "**/.gradle/**", "**/node_modules/**");
 		List<String> buildFolders = List.of("bin", "build", "out");
 		project.allprojects(subproject -> {
 			Path rootPath = project.getRootDir().toPath();

buildSrc/src/main/java/org/springframework/build/TestConventions.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2023 the original author or authors.
+ * Copyright 2002-2024 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.
@@ -63,8 +63,7 @@ class TestConventions {
 			test.systemProperty("testGroups", project.getProperties().get("testGroups"));
 		}
 		test.jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED",
-				"--add-opens=java.base/java.util=ALL-UNNAMED",
-				"-Djava.locale.providers=COMPAT");
+				"--add-opens=java.base/java.util=ALL-UNNAMED");
 	}
 
 	private void configureTestRetryPlugin(Project project, Test test) {

ci/README.adoc

@@ -1,5 +1,7 @@
 == 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].

ci/config/changelog-generator.yml

@@ -17,4 +17,13 @@ changelog:
         - "type: dependency-upgrade"
   contributors:
     exclude:
-      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll", "simonbasle"]
+      names:
+        - "bclozel"
+        - "github-actions[bot]"
+        - "jhoeller"
+        - "poutsma"
+        - "rstoyanchev"
+        - "sbrannen"
+        - "sdeleuze"
+        - "simonbasle"
+        - "snicoll"

ci/images/ci-image/Dockerfile

@@ -7,6 +7,6 @@ RUN ./setup.sh
 ENV JAVA_HOME /opt/openjdk/java17
 ENV JDK17 /opt/openjdk/java17
 ENV JDK21 /opt/openjdk/java21
-ENV JDK22 /opt/openjdk/java22
+ENV JDK23 /opt/openjdk/java23
 
 ENV PATH $JAVA_HOME/bin:$PATH

ci/images/get-jdk-url.sh

@@ -8,8 +8,8 @@ case "$1" in
 	java21)
 		echo "https://github.com/bell-sw/Liberica/releases/download/21.0.2%2B14/bellsoft-jdk21.0.2+14-linux-amd64.tar.gz"
 	;;
-	java22)
-		echo "https://download.java.net/java/early_access/jdk22/33/GPL/openjdk-22-ea+33_linux-x64_bin.tar.gz"
+	java23)
+		echo "https://download.java.net/java/early_access/jdk23/17/GPL/openjdk-23-ea+17_linux-x64_bin.tar.gz"
 	;;
 	*)
 		echo $"Unknown java version"

ci/images/setup.sh

@@ -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 java22
+for jdk in java17 java21 java23
 do
   JDK_URL=$( /get-jdk-url.sh $jdk )
   mkdir $jdk

ci/parameters.yml

@@ -3,9 +3,8 @@ github-repo-name: "spring-projects/spring-framework"
 sonatype-staging-profile: "org.springframework"
 docker-hub-organization: "springci"
 artifactory-server: "https://repo.spring.io"
-branch: "main"
+branch: "6.1.x"
 milestone: "6.1.x"
 build-name: "spring-framework"
 pipeline-name: "spring-framework"
 concourse-url: "https://ci.spring.io"
-task-timeout: 1h00m

ci/pipeline.yml

@@ -5,12 +5,10 @@ anchors:
     password: ((github-ci-release-token))
     branch: ((branch))
   gradle-enterprise-task-params: &gradle-enterprise-task-params
-    GRADLE_ENTERPRISE_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
-    GRADLE_ENTERPRISE_CACHE_USERNAME: ((gradle_enterprise_cache_user.username))
-    GRADLE_ENTERPRISE_CACHE_PASSWORD: ((gradle_enterprise_cache_user.password))
+    DEVELOCITY_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
   sonatype-task-params: &sonatype-task-params
-    SONATYPE_USERNAME: ((sonatype-username))
-    SONATYPE_PASSWORD: ((sonatype-password))
+    SONATYPE_USERNAME: ((s01-user-token))
+    SONATYPE_PASSWORD: ((s01-user-token-password))
     SONATYPE_URL: ((sonatype-url))
     SONATYPE_STAGING_PROFILE: ((sonatype-staging-profile))
   artifactory-task-params: &artifactory-task-params
@@ -23,14 +21,6 @@ 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
@@ -64,12 +54,6 @@ 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
@@ -90,13 +74,6 @@ 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
@@ -105,35 +82,6 @@ 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
@@ -168,115 +116,6 @@ 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:
@@ -290,9 +129,32 @@ jobs:
         RELEASE_TYPE: M
         <<: *gradle-enterprise-task-params
     - put: artifactory-repo
-      params:
-        <<: *artifactory-params
+      params: &artifactory-params
+        signing_key: ((signing-key))
+        signing_passphrase: ((signing-passphrase))
         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
@@ -337,7 +199,6 @@ jobs:
     - put: artifactory-repo
       params:
         <<: *artifactory-params
-        repo: libs-staging-local
     - put: git-repo
       params:
         repository: stage-git-repo
@@ -382,7 +243,6 @@ jobs:
     - put: artifactory-repo
       params:
         <<: *artifactory-params
-        repo: libs-staging-local
     - put: git-repo
       params:
         repository: stage-git-repo
@@ -427,8 +287,6 @@ 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"

ci/scripts/build-pr.sh

@@ -1,9 +0,0 @@
-#!/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

ci/scripts/build-project.sh

@@ -1,10 +0,0 @@
-#!/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

ci/scripts/check-project.sh

@@ -1,9 +0,0 @@
-#!/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

ci/tasks/build-pr.yml

@@ -1,19 +0,0 @@
----
-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

ci/tasks/build-project.yml

@@ -1,22 +0,0 @@
----
-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

ci/tasks/check-project.yml

@@ -1,24 +0,0 @@
----
-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

framework-docs/antora-playbook.yml

@@ -0,0 +1,39 @@
+antora:
+  extensions:
+  - require: '@springio/antora-extensions'
+    root_component_name: 'framework'
+site:
+  title: Spring Framework
+  url: https://docs.spring.io/spring-framework/reference
+  robots: allow
+git:
+  ensure_git_suffix: false
+content:
+  sources:
+  - url: https://github.com/spring-projects/spring-framework
+    # Refname matching:
+    # https://docs.antora.org/antora/latest/playbook/content-refname-matching/
+    branches: ['main', '{6..9}.+({0..9}).x']
+    tags: ['v{6..9}.+({0..9}).+({0..9})?(-{RC,M}*)', '!(v6.0.{0..8})', '!(v6.0.0-{RC,M}{0..9})']
+    start_path: framework-docs
+asciidoc:
+  extensions:
+    - '@asciidoctor/tabs'
+    - '@springio/asciidoctor-extensions'
+    - '@springio/asciidoctor-extensions/include-code-extension'
+  attributes:
+    page-stackoverflow-url: https://stackoverflow.com/questions/tagged/spring
+    page-pagination: ''
+    hide-uri-scheme: '@'
+    tabs-sync-option: '@'
+    include-java: 'example$docs-src/main/java/org/springframework/docs'
+urls:
+  latest_version_segment_strategy: redirect:to
+  latest_version_segment: ''
+  redirect_facility: httpd
+runtime:
+  log:
+    failure_level: warn
+ui:
+  bundle:
+    url: https://github.com/spring-io/antora-ui-spring/releases/download/v0.4.16/ui-bundle.zip

framework-docs/framework-docs.gradle

@@ -10,27 +10,10 @@ apply from: "${rootDir}/gradle/ide.gradle"
 apply from: "${rootDir}/gradle/publications.gradle"
 
 antora {
-	version = '3.2.0-alpha.2'
-	playbook = 'cached-antora-playbook.yml'
-	playbookProvider {
-		repository = 'spring-projects/spring-framework'
-		branch = 'docs-build'
-		path = 'lib/antora/templates/per-branch-antora-playbook.yml'
-		checkLocalBranch = true
-	}
-	options = ['--clean', '--stacktrace']
+	options = [clean: true, fetch: !project.gradle.startParameter.offline, stacktrace: true]
 	environment = [
-			'ALGOLIA_API_KEY': '82c7ead946afbac3cf98c32446154691',
-			'ALGOLIA_APP_ID': '244V8V9FGG',
-			'ALGOLIA_INDEX_NAME': 'framework-docs'
-	]
-	dependencies = [
-			'@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',
-			'@springio/asciidoctor-extensions': '1.0.0-alpha.9'
+			'BUILD_REFNAME': 'HEAD',
+			'BUILD_VERSION': project.version,
 	]
 }
 

framework-docs/modules/ROOT/nav.adoc

@@ -39,8 +39,8 @@
 ** xref:core/resources.adoc[]
 ** xref:core/validation.adoc[]
 *** xref:core/validation/validator.adoc[]
-*** xref:core/validation/conversion.adoc[]
 *** xref:core/validation/beans-beans.adoc[]
+*** xref:core/validation/conversion.adoc[]
 *** xref:core/validation/convert.adoc[]
 *** xref:core/validation/format.adoc[]
 *** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
@@ -439,4 +439,5 @@
 ** xref:languages/groovy.adoc[]
 ** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
-* {spring-framework-wiki}[Wiki]
+* {spring-framework-wiki}[Wiki]
+

framework-docs/modules/ROOT/pages/core/aop-api/targetsource.adoc

@@ -221,8 +221,8 @@ NOTE: `ThreadLocal` instances come with serious issues (potentially resulting in
 incorrectly using them in multi-threaded and multi-classloader environments. You
 should always consider wrapping a `ThreadLocal` in some other class and never directly use
 the `ThreadLocal` itself (except in the wrapper class). Also, you should
-always remember to correctly set and unset (where the latter simply involves a call to
-`ThreadLocal.set(null)`) the resource local to the thread. Unsetting should be done in
+always remember to correctly set and unset (where the latter involves a call to
+`ThreadLocal.remove()`) the resource local to the thread. Unsetting should be done in
 any case, since not unsetting it might result in problematic behavior. Spring's
 `ThreadLocal` support does this for you and should always be considered in favor of using
 `ThreadLocal` instances without other proper handling code.

framework-docs/modules/ROOT/pages/core/aop/proxying.adoc

@@ -19,6 +19,10 @@ 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:

framework-docs/modules/ROOT/pages/core/aot.adoc

@@ -15,7 +15,7 @@ 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.
+** `@Profile`, in particular profile-specific configuration, needs to be chosen at build time and is automatically enabled at runtime when AOT is enabled.
 ** `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
@@ -152,8 +152,23 @@ 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:
 
@@ -209,6 +224,17 @@ 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
 
@@ -300,6 +326,32 @@ However, this is not a best practice and flagging the preferred constructor with
 
 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.comlext-data-structure]]
+=== Avoid Complex Data Structure for Constructor Parameters and Properties
+
+When crafting a `RootBeanDefinition` programmatically, you are not constrained in terms of types that you can use.
+For instance, you may have a custom `record` with several properties that your bean takes as a constructor argument.
+
+While this works fine with the regular runtime, AOT does not know how to generate the code of your custom data structure.
+A good rule of thumb is to keep in mind that bean definitions are an abstraction on top of several models.
+Rather than using such structure, decomposing to simple types or referring to a bean that is built as such is recommended.
+
+As a last resort, you can implement your own `org.springframework.aot.generate.ValueCodeGenerator$Delegate`.
+To use it, register its fully qualified name in `META-INF/spring/aot.factories` using the `Delegate` as the key.
+
+[[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.
+
 [[aot.bestpractices.factory-bean]]
 === FactoryBean
 

framework-docs/modules/ROOT/pages/core/beans/annotation-config.adoc

@@ -1,33 +1,16 @@
 [[beans-annotation-config]]
 = Annotation-based Container Configuration
 
-.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.
+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.
 
-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
+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
@@ -36,13 +19,16 @@ can be found in the xref:core/beans/standard-annotations.adoc[relevant section].
 
 [NOTE]
 ====
-Annotation injection is performed before XML injection. Thus, the XML configuration
-overrides the annotations for properties wired through both approaches.
+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.
 ====
 
-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):
+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:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----

framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired-qualifiers.adoc

@@ -153,17 +153,15 @@ Letting qualifier values select against target bean names, within the type-match
 candidates, does not require a `@Qualifier` annotation at the injection point.
 If there is no other resolution indicator (such as a qualifier or a primary marker),
 for a non-unique dependency situation, Spring matches the injection point name
-(that is, the field name or parameter name) against the target bean names and chooses the
-same-named candidate, if any.
+(that is, the field name or parameter name) against the target bean names and chooses
+the same-named candidate, if any (either by bean name or by associated alias).
 
 Since version 6.1, this requires the `-parameters` Java compiler flag to be present.
 ====
 
-That said, if you intend to express annotation-driven injection by name, do not
-primarily use `@Autowired`, even if it is capable of selecting by bean name among
-type-matching candidates. Instead, use the JSR-250 `@Resource` annotation, which is
-semantically defined to identify a specific target component by its unique name, with
-the declared type being irrelevant for the matching process. `@Autowired` has rather
+As an alternative for injection by name, consider the JSR-250 `@Resource` annotation
+which is semantically defined to identify a specific target component by its unique name,
+with the declared type being irrelevant for the matching process. `@Autowired` has rather
 different semantics: After selecting candidate beans by type, the specified `String`
 qualifier value is considered within those type-selected candidates only (for example,
 matching an `account` qualifier against beans marked with the same qualifier label).

framework-docs/modules/ROOT/pages/core/beans/annotation-config/autowired.adoc

@@ -186,6 +186,15 @@ 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:
@@ -268,6 +277,12 @@ 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.

framework-docs/modules/ROOT/pages/core/beans/basics.adoc

@@ -2,36 +2,28 @@
 = 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 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.
+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.
 
-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.
+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`].
 
 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 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
+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
 xref:core/beans/context-introduction.adoc#context-create[Convenient ApplicationContext Instantiation for Web Applications]).
-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.
+In a Spring Boot scenario, the application context is implicitly bootstrapped for you
+based on common setup conventions.
 
 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[]
@@ -43,33 +35,25 @@ 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 objects in your application.
+application developer, tell the Spring container to instantiate, configure,
+and assemble the components 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.
-
-For information about using other forms of metadata with the Spring container, see:
+xref:core/beans/java.adoc[Java-based configuration] for their Spring applications:
 
 * xref:core/beans/annotation-config.adoc[Annotation-based configuration]: define beans using
-  annotation-based configuration metadata.
+  annotation-based configuration metadata on your application's component classes.
 * xref:core/beans/java.adoc[Java-based configuration]: define beans external to your application
-  classes by using Java rather than XML files. To use these features, see the
+  classes by using Java-based configuration classes. 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. 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.
+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.
 
 These bean definitions correspond to the actual objects that make up your application.
 Typically, you define service layer objects, persistence layer objects such as
@@ -79,7 +63,14 @@ 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.
 
-The following example shows the basic structure of XML-based configuration metadata:
+
+
+[[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:
 
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -110,14 +101,9 @@ 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.
 
-
-
-[[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
+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
 as the local file system, the Java `CLASSPATH`, and so on.
 
 [tabs]
@@ -209,9 +195,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 application context constructor to load bean definitions from all these
+You can use the `ClassPathXmlApplicationContext` constructor to load bean definitions from
 XML fragments. This constructor takes multiple `Resource` locations, as was shown in the
-xref:core/beans/basics.adoc#beans-factory-instantiation[previous section]. Alternatively,
+xref:core/beans/basics.adoc#beans-factory-xml[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:
 
@@ -259,7 +245,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.
 
 
-[[groovy-bean-definition-dsl]]
+[[beans-factory-groovy]]
 === The Groovy Bean Definition DSL
 
 As a further example for externalized configuration metadata, bean definitions can also
@@ -420,4 +406,3 @@ a dependency on a specific bean through metadata (such as an autowiring annotati
 
 
 
-

framework-docs/modules/ROOT/pages/core/beans/definition.adoc

@@ -75,6 +75,31 @@ lead to concurrent access exceptions, inconsistent state in the bean container,
 
 
 
+[[beans-definition-overriding]]
+== Overriding Beans
+
+Bean overriding is happening when a bean is registered using an identifier that is
+already allocated. While bean overriding is possible, it makes the configuration harder
+to read and this feature will be deprecated in a future release.
+
+To disable bean overriding altogether, you can set the `allowBeanDefinitionOverriding`
+flag to `false` on the `ApplicationContext` before it is refreshed. In such setup, an
+exception is thrown if bean overriding is used.
+
+By default, the container logs every bean overriding at `INFO` level so that you can
+adapt your configuration accordingly. While not recommended, you can silence those logs
+by setting the `allowBeanDefinitionOverriding` flag to `true`.
+
+.Java-configuration
+****
+If you use Java Configuration, a corresponding `@Bean` method always silently overrides
+a scanned bean class with the same component name as long as the return type of the
+`@Bean` method matches that bean class. This simply means that the container will call
+the `@Bean` factory method in favor of any pre-declared constructor on the bean class.
+****
+
+
+
 [[beans-beanname]]
 == Naming Beans
 
@@ -234,6 +259,10 @@ 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
@@ -294,6 +323,24 @@ 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
@@ -416,8 +463,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
@@ -444,5 +491,3 @@ cases into account and returns the type of object that a `BeanFactory.getBean` c
 going to return for the same bean name.
 
 
-
-

framework-docs/modules/ROOT/pages/core/beans/dependencies/factory-method-injection.adoc

@@ -201,7 +201,7 @@ the original class. Consider the following example:
 		<!-- inject dependencies here as required -->
 	</bean>
 
-	<!-- commandProcessor uses statefulCommandHelper -->
+	<!-- commandManager uses myCommand prototype bean -->
 	<bean id="commandManager" class="fiona.apple.CommandManager">
 		<lookup-method name="createCommand" bean="myCommand"/>
 	</bean>

framework-docs/modules/ROOT/pages/core/beans/factory-extension.adoc

@@ -439,7 +439,7 @@ dataSource.url=jdbc:mysql:mydb
 ----
 
 This example file can be used with a container definition that contains a bean called
-`dataSource` that has `driver` and `url` properties.
+`dataSource` that has `driverClassName` and `url` properties.
 
 Compound property names are also supported, as long as every component of the path
 except the final property being overridden is already non-null (presumably initialized

framework-docs/modules/ROOT/pages/core/beans/java/basic-concepts.adoc

@@ -55,33 +55,34 @@ The preceding `AppConfig` class is equivalent to the following Spring `<beans/>`
 	</beans>
 ----
 
-.Full @Configuration vs "`lite`" @Bean mode?
+.@Configuration classes with or without local calls between @Bean methods?
 ****
-When `@Bean` methods are declared within classes that are not annotated with
-`@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.
-
-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.
+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.
+
+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.
 ****
 
 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.
 
 

framework-docs/modules/ROOT/pages/core/expressions/evaluation.adoc

@@ -518,6 +518,7 @@ following kinds of expressions cannot be compiled.
 * 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.

framework-docs/modules/ROOT/pages/core/expressions/language-ref/array-construction.adoc

@@ -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,14 +26,22 @@ 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.
+====

framework-docs/modules/ROOT/pages/core/expressions/language-ref/variables.adoc

@@ -20,6 +20,15 @@ characters.
 * 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

framework-docs/modules/ROOT/pages/core/validation/beanvalidation.adoc

@@ -299,7 +299,7 @@ Java::
 	public class AppConfig {
 
 		@Bean
-		public MethodValidationPostProcessor validationPostProcessor() {
+		public static MethodValidationPostProcessor validationPostProcessor() {
 			return new MethodValidationPostProcessor();
 		}
 	}
@@ -341,7 +341,7 @@ xref:web/webflux/ann-rest-exceptions.adoc[Error Responses] sections.
 === Method Validation Exceptions
 
 By default, `jakarta.validation.ConstraintViolationException` is raised with the set of
-``ConstraintViolation``s returned by `jakarata.validation.Validator`. As an alternative,
+``ConstraintViolation``s returned by `jakarta.validation.Validator`. As an alternative,
 you can have `MethodValidationException` raised instead with ``ConstraintViolation``s
 adapted to `MessageSourceResolvable` errors. To enable set the following flag:
 
@@ -357,7 +357,7 @@ Java::
 	public class AppConfig {
 
 		@Bean
-		public MethodValidationPostProcessor validationPostProcessor() {
+		public static MethodValidationPostProcessor validationPostProcessor() {
 			MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
 			processor.setAdaptConstraintViolations(true);
 			return processor;

framework-docs/modules/ROOT/pages/data-access/jdbc/advanced.adoc

@@ -211,19 +211,28 @@ the JDBC driver. If the count is not available, the JDBC driver returns a value
 ====
 In such a scenario, with automatic setting of values on an underlying `PreparedStatement`,
 the corresponding JDBC type for each value needs to be derived from the given Java type.
-While this usually works well, there is a potential for issues (for example, with Map-contained
-`null` values). Spring, by default, calls `ParameterMetaData.getParameterType` in such a
-case, which can be expensive with your JDBC driver. You should use a recent driver
+While this usually works well, there is a potential for issues (for example, with
+Map-contained `null` values). Spring, by default, calls `ParameterMetaData.getParameterType`
+in such a case, which can be expensive with your JDBC driver. You should use a recent driver
 version and consider setting the `spring.jdbc.getParameterType.ignore` property to `true`
 (as a JVM system property or via the
-xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism) if you encounter
-a performance issue (as reported on Oracle 12c, JBoss, and PostgreSQL).
+xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism)
+if you encounter a specific performance issue for your application.
 
-Alternatively, you might consider specifying the corresponding JDBC types explicitly,
-either through a `BatchPreparedStatementSetter` (as shown earlier), through an explicit type
-array given to a `List<Object[]>` based call, through `registerSqlType` calls on a
-custom `MapSqlParameterSource` instance, or through a `BeanPropertySqlParameterSource`
-that derives the SQL type from the Java-declared property type even for a null value.
+As of 6.1.2, Spring bypasses the default `getParameterType` resolution on PostgreSQL and
+MS SQL Server. This is a common optimization to avoid further roundtrips to the DBMS just
+for parameter type resolution which is known to make a very significant difference on
+PostgreSQL and MS SQL Server specifically, in particular for batch operations. If you
+happen to see a side effect e.g. when setting a byte array to null without specific type
+indication, you may explicitly set the `spring.jdbc.getParameterType.ignore=false` flag
+as a system property (see above) to restore full `getParameterType` resolution.
+
+Alternatively, you could consider specifying the corresponding JDBC types explicitly,
+either through a `BatchPreparedStatementSetter` (as shown earlier), through an explicit
+type array given to a `List<Object[]>` based call, through `registerSqlType` calls on a
+custom `MapSqlParameterSource` instance, through a `BeanPropertySqlParameterSource`
+that derives the SQL type from the Java-declared property type even for a null value, or
+through providing individual `SqlParameterValue` instances instead of plain null values.
 ====
 
 

framework-docs/modules/ROOT/pages/data-access/jdbc/object.adoc

@@ -112,7 +112,7 @@ Java::
 		this.actorMappingQuery = new ActorMappingQuery(dataSource);
 	}
 
-	public Customer getCustomer(Long id) {
+	public Actor getActor(Long id) {
 		return actorMappingQuery.findObject(id);
 	}
 ----
@@ -123,11 +123,11 @@ Kotlin::
 ----
 	private val actorMappingQuery = ActorMappingQuery(dataSource)
 
-	fun getCustomer(id: Long) = actorMappingQuery.findObject(id)
+	fun getActor(id: Long) = actorMappingQuery.findObject(id)
 ----
 ======
 
-The method in the preceding example retrieves the customer with the `id` that is passed in as the
+The method in the preceding example retrieves the actor with the `id` that is passed in as the
 only parameter. Since we want only one object to be returned, we call the `findObject` convenience
 method with the `id` as the parameter. If we had instead a query that returned a
 list of objects and took additional parameters, we would use one of the `execute`

framework-docs/modules/ROOT/pages/data-access/orm/jpa.adoc

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

framework-docs/modules/ROOT/pages/data-access/transaction/declarative/annotations.adoc

@@ -74,10 +74,11 @@ 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.
@@ -436,9 +437,10 @@ 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.

framework-docs/modules/ROOT/pages/data-access/transaction/declarative/rolling-back.adoc

@@ -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 [official Vavr documentation](https://www.vavr.io/vavr-docs/#_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:
+
 [tabs]
 ======
 Java::
@@ -42,6 +42,32 @@ 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_.

framework-docs/modules/ROOT/pages/index.adoc

@@ -29,8 +29,6 @@ Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clem
 Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane
 Nicoll, Sebastien Deleuze, Jay Bryant, Mark Paluch
 
-Copyright © 2002 - 2024 VMware, Inc. All Rights Reserved.
-
 Copies of this document may be made for your own use and for distribution to others,
 provided that you do not charge any fee for such copies and further provided that each
-copy contains this Copyright Notice, whether distributed in print or electronically.
+copy contains the Copyright Notice, whether distributed in print or electronically.

framework-docs/modules/ROOT/pages/integration/cds.adoc

@@ -24,7 +24,7 @@ To create the archive, two additional JVM flags must be specified:
 * `-Dspring.context.exit=onRefresh`: starts and then immediately exits your Spring
   application as described above
 
-To create a CDS archive, your JDK must have a base image. If you add the flags above to
+To create a CDS archive, your JDK/JRE must have a base image. If you add the flags above to
 your startup script, you may get a warning that looks like this:
 
 [source,shell,indent=0,subs="verbatim"]
@@ -32,7 +32,8 @@ your startup script, you may get a warning that looks like this:
   -XX:ArchiveClassesAtExit is unsupported when base CDS archive is not loaded. Run with -Xlog:cds for more info.
 ----
 
-The base CDS archive can be created by issuing the following command:
+The base CDS archive is usually provided out-of-the-box, but can also be created if needed by issuing the following
+command:
 
 [source,shell,indent=0,subs="verbatim"]
 ----
@@ -44,6 +45,9 @@ The base CDS archive can be created by issuing the following command:
 Once the archive is available, add `-XX:SharedArchiveFile=application.jsa` to your startup
 script to use it, assuming an `application.jsa` file in the working directory.
 
+To check if the CDS cache is effective, you can use (for testing purposes only, not in production) `-Xshare:on` which
+prints an error message and exits if CDS can't be enabled.
+
 To figure out how effective the cache is, you can enable class loading logs by adding
 an extra attribute: `-Xlog:class+load:file=cds.log`. This creates a `cds.log` with every
 attempt to load a class and its source. Classes that are loaded from the cache should have
@@ -58,8 +62,11 @@ a "shared objects file" source, as shown in the following example:
     [0.065s][info][class,load] org.springframework.context.MessageSource source: shared objects file (top)
 ----
 
-TIP: If you have a large number of classes that are not loaded from the cache, make sure that
-the JDK and classpath used by the commands that create the archive and start the application
-are identical. Note also that to effectively cache classes, the classpath should be specified
-as a list of JARs containing those classes, and avoid the usage of directories and `*`
-wildcard characters.
+If CDS can't be enabled or if you have a large number of classes that are not loaded from the cache, make sure that
+the following conditions are fulfilled when creating and using the archive:
+
+ - The very same JVM must used.
+ - The classpath must be specified as a list of JARs, and avoid the usage of directories and `*` wildcard characters.
+ - The timestamps of the JARs must be preserved.
+ - When using the archive, the classpath must be the same than the one used to create the archive, in the same order.
+Additional JARs or directories can be specified *at the end* (but won't be cached).

framework-docs/modules/ROOT/pages/integration/jms/annotated.adoc

@@ -58,7 +58,7 @@ your `@Configuration` classes, as the following example shows:
 By default, the infrastructure looks for a bean named `jmsListenerContainerFactory`
 as the source for the factory to use to create message listener containers. In this
 case (and ignoring the JMS infrastructure setup), you can invoke the `processOrder`
-method with a core poll size of three threads and a maximum pool size of ten threads.
+method with a core pool size of three threads and a maximum pool size of ten threads.
 
 You can customize the listener container factory to use for each annotation or you can
 configure an explicit default by implementing the `JmsListenerConfigurer` interface.

framework-docs/modules/ROOT/pages/integration/rest-clients.adoc

@@ -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 Java object to HTTP request, and creation of objects from the HTTP response.
+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.
 
 === 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, a 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, default request headers, or `uriBuilderFactory`, or registering interceptors and initializers.
 
 Once created (or built), the `RestClient` can be used safely by multiple threads.
 
@@ -64,35 +64,62 @@ 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 `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`.
+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`:
 
-The URL can also be provided with a function, or as `java.net.URI`, both of which are not encoded.
+[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].
+
+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.
 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 request 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 requests 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 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 can be converted 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]
 ======
@@ -171,7 +198,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]
 ======
@@ -248,8 +275,9 @@ 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 overriden using `onStatus`.
+This behavior can be overridden using `onStatus`.
 
 [tabs]
 ======
@@ -286,8 +314,9 @@ 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 you 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 use `exchange()`, because the exchange function already provides access to the full response, allowing you to perform any error handling necessary.
 
 [tabs]
 ======
@@ -336,6 +365,7 @@ 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`.
@@ -397,7 +427,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 `messageConverters` on the `RestClient` builder, or via the `messageConverters` property of `RestTemplate`.
+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`.
 
 ==== Jackson JSON Views
 
@@ -437,13 +467,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]]
@@ -453,17 +483,20 @@ 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`
 
@@ -473,12 +506,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.
 
@@ -848,17 +881,17 @@ It can be used to migrate from the latter to the former.
 .toEntity(ParameterizedTypeReference)` footnote:request-entity[]
 
 
-| `execute(String, HttpMethod method, RequestCallback, ResponseExtractor, Object...)`
+| `execute(String, HttpMethod, RequestCallback, ResponseExtractor, Object...)`
 | `method(HttpMethod)
 .uri(String, Object...)
 .exchange(ExchangeFunction)`
 
-| `execute(String, HttpMethod method, RequestCallback, ResponseExtractor, Map)`
+| `execute(String, HttpMethod, RequestCallback, ResponseExtractor, Map)`
 | `method(HttpMethod)
 .uri(String, Map)
 .exchange(ExchangeFunction)`
 
-| `execute(URI, HttpMethod method, RequestCallback, ResponseExtractor)`
+| `execute(URI, HttpMethod, RequestCallback, ResponseExtractor)`
 | `method(HttpMethod)
 .uri(URI)
 .exchange(ExchangeFunction)`

framework-docs/modules/ROOT/pages/languages/groovy.adoc

@@ -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#groovy-bean-definition-dsl[The Groovy Bean Definition DSL].
+xref:core/beans/basics.adoc#beans-factory-groovy[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].

framework-docs/modules/ROOT/pages/languages/kotlin/spring-projects-in.adoc

@@ -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 in Kotlin are `final`].
+By default, https://discuss.kotlinlang.org/t/classes-final-by-default/166[all classes and member functions 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,6 +38,12 @@ 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.
@@ -160,7 +166,7 @@ public class SampleConfiguration {
 	@Bean
 	@NotNull
 	public SampleBean sampleBean$demo_kotlin_internal_test() {
-        return new SampleBean();
+		return new SampleBean();
 	}
 }
 ----

framework-docs/modules/ROOT/pages/testing/spring-mvc-test-framework/server-setup-options.adoc

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

framework-docs/modules/ROOT/pages/testing/spring-mvc-test-framework/vs-end-to-end-integration-tests.adoc

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

framework-docs/modules/ROOT/pages/testing/spring-mvc-test-framework/vs-streaming-response.adoc

@@ -1,38 +1,16 @@
 [[spring-mvc-test-vs-streaming-response]]
 = Streaming Responses
 
-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:
+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].
 
-[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].
+`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.
 
 

framework-docs/modules/ROOT/pages/testing/testcontext-framework/ctx-management/groovy.adoc

@@ -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#groovy-bean-definition-dsl[Groovy Bean Definition DSL], you can annotate
+xref:core/beans/basics.adoc#beans-factory-groovy[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

framework-docs/modules/ROOT/pages/testing/webtestclient.adoc

@@ -672,13 +672,13 @@ Kotlin::
 	val result = client.get().uri("/persons/1")
 			.exchange()
 			.expectStatus().isOk()
-			.expectBody(Person.class)
-			.returnResult();
+			.expectBody<Person>()
+			.returnResult()
 
 	// For a response without a body
 	val result = client.get().uri("/path")
 			.exchange()
-			.expectBody().isEmpty();
+			.expectBody().isEmpty()
 ----
 ======
 

framework-docs/modules/ROOT/pages/web/webflux-functional.adoc

@@ -803,7 +803,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
 	ClassPathResource index = new ClassPathResource("static/index.html");
-	List<String> extensions = List.of("js", "css", "ico", "png", "jpg", "gif");
+	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)

framework-docs/modules/ROOT/pages/web/webflux-reactive-libraries.adoc

@@ -4,10 +4,13 @@
 `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. 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.
+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).
 
 For annotated controllers, WebFlux transparently adapts to the reactive library chosen by
 the application. This is done with the help of the
@@ -15,15 +18,3 @@ 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.

framework-docs/modules/ROOT/pages/web/webflux-webclient/client-retrieve.adoc

@@ -97,8 +97,8 @@ Java::
 	Mono<Person> result = client.get()
 			.uri("/persons/{id}", id).accept(MediaType.APPLICATION_JSON)
 			.retrieve()
-			.onStatus(HttpStatus::is4xxClientError, response -> ...)
-			.onStatus(HttpStatus::is5xxServerError, response -> ...)
+			.onStatus(HttpStatusCode::is4xxClientError, response -> ...)
+			.onStatus(HttpStatusCode::is5xxServerError, response -> ...)
 			.bodyToMono(Person.class);
 ----
 
@@ -109,8 +109,8 @@ Kotlin::
 	val result = client.get()
 			.uri("/persons/{id}", id).accept(MediaType.APPLICATION_JSON)
 			.retrieve()
-			.onStatus(HttpStatus::is4xxClientError) { ... }
-			.onStatus(HttpStatus::is5xxServerError) { ... }
+			.onStatus(HttpStatusCode::is4xxClientError) { ... }
+			.onStatus(HttpStatusCode::is5xxServerError) { ... }
 			.awaitBody<Person>()
 ----
 ======

framework-docs/modules/ROOT/pages/web/webflux/ann-rest-exceptions.adoc

@@ -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}/rfc7807.html[RFC 7807].
+specification, {rfc-site}/rfc9457.html[RFC 9457].
 
 The following are the main abstractions for this support:
 
-- `ProblemDetail` -- representation for an RFC 7807 problem detail; a simple container
+- `ProblemDetail` -- representation for an RFC 9457 problem detail; a simple container
 for both standard fields defined in the spec, and for non-standard ones.
 - `ErrorResponse` -- contract to expose HTTP error response details including HTTP
-status, response headers, and a body in the format of RFC 7807; this allows exceptions to
+status, response headers, and a body in the format of RFC 9457; 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 7807 response. This is processed as follows:
+any `@RequestMapping` method to render an RFC 9457 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 7807 responses for Spring WebFlux exceptions and for any
+To enable RFC 9457 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 7807 response with non-standard fields in one of two ways.
+You can extend an RFC 9457 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

framework-docs/modules/ROOT/pages/web/webflux/config.adoc

@@ -338,7 +338,7 @@ Kotlin::
 	class WebConfig : WebFluxConfigurer {
 
 		override fun configureHttpMessageCodecs(configurer: ServerCodecConfigurer) {
-			// ...
+			configurer.defaultCodecs().maxInMemorySize(512 * 1024)
 		}
 	}
 ----

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/arguments.adoc

@@ -77,7 +77,7 @@ and others) and is equivalent to `required=false`.
 | For access to a part in  a `multipart/form-data` request. Supports reactive types.
   See xref:web/webflux/controller/ann-methods/multipart-forms.adoc[Multipart Content] and xref:web/webflux/reactive-spring.adoc#webflux-multipart[Multipart Data].
 
-| `java.util.Map`, `org.springframework.ui.Model`, and `org.springframework.ui.ModelMap`.
+| `java.util.Map` or `org.springframework.ui.Model`
 | For access to the model that is used in HTML controllers and is exposed to templates as
   part of view rendering.
 
@@ -89,9 +89,9 @@ and others) and is equivalent to `required=false`.
   Note that use of `@ModelAttribute` is optional -- for example, to set its attributes.
   See "`Any other argument`" later in this table.
 
-| `Errors`, `BindingResult`
+| `Errors` or `BindingResult`
 | For access to errors from validation and data binding for a command object, i.e. a
-  `@ModelAttribute` argument. An `Errors`, or `BindingResult` argument must be declared
+  `@ModelAttribute` argument. An `Errors` or `BindingResult` argument must be declared
   immediately after the validated method argument.
 
 | `SessionStatus` + class-level `@SessionAttributes`

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/jackson.adoc

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

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-methods/return-types.adoc

@@ -4,9 +4,20 @@
 [.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-reactive.adoc#webflux-reactive-libraries[or other] are
+types from libraries such as Reactor, RxJava, xref:web/webflux-reactive-libraries.adoc[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
@@ -24,11 +35,11 @@ generally supported for all return values.
 | For returning a response with headers and no body.
 
 | `ErrorResponse`
-| To render an RFC 7807 error response with details in the body,
+| To render an RFC 9457 error response with details in the body,
   see xref:web/webflux/ann-rest-exceptions.adoc[Error Responses]
 
 | `ProblemDetail`
-| To render an RFC 7807 error response with details in the body,
+| To render an RFC 9457 error response with details in the body,
   see xref:web/webflux/ann-rest-exceptions.adoc[Error Responses]
 
 | `String`

framework-docs/modules/ROOT/pages/web/webflux/controller/ann-validation.adoc

@@ -3,31 +3,43 @@
 
 [.small]#xref:web/webmvc/mvc-controller/ann-validation.adoc[See equivalent in the Servlet stack]#
 
-Spring WebFlux has built-in xref:core/validation/validator.adoc[Validation] support for
-`@RequestMapping` methods, including the option to use
-xref:core/validation/beanvalidation.adoc[Java Bean Validation].
-The validation support works on two levels.
+Spring WebFlux has built-in xref:core/validation/validator.adoc[Validation] for
+`@RequestMapping` methods, including xref:core/validation/beanvalidation.adoc[Java Bean Validation].
+Validation may be applied at one of two levels:
 
-First, resolvers for
-xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
+1. 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] argument
+resolvers validate a method argument individually if the method parameter is annotated
+with Jakarta `@Valid` or Spring's `@Validated`, _AND_ there is no `Errors` or
+`BindingResult` parameter immediately after, _AND_ method validation is not needed (to be
+discussed next). The exception raised in this case is `WebExchangeBindException`.
 
-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.
+2. When `@Constraint` annotations such as `@Min`, `@NotBlank` and others are declared
+directly on method parameters, or on the method (for the return value), then method
+validation must be applied, and that supersedes validation at the method argument level
+because method validation covers both method parameter constraints and nested constraints
+via `@Valid`. The exception raised in this case is `HandlerMethodValidationException`.
+
+Applications must handle both `WebExchangeBindException` and
+`HandlerMethodValidationException` as either may be raised depending on the controller
+method signature. The two exceptions, however are designed to be very similar, and can be
+handled with almost identical code. The main difference is that the former is for a single
+object while the latter is for a list of method parameters.
+
+NOTE: `@Valid` is not a constraint annotation, but rather for nested constraints within
+an Object. Therefore, by itself `@Valid` does not lead to method validation. `@NotNull`
+on the other hand is a constraint, and adding it to an `@Valid` parameter leads to method
+validation. For nullability specifically, you may also use the `required` flag of
+`@RequestBody` or `@ModelAttribute`.
+
+Method validation may be used in combination with `Errors` or `BindingResult` method
+parameters. However, the controller method is called only if all validation errors are on
+method parameters with an `Errors` immediately after. If there are validation errors on
+any other method parameter then `HandlerMethodValidationException` is raised.
 
 You can configure a `Validator` globally through the
-xref:web/webflux/config.adoc#webflux-config-validation[WebMvc config], or locally
+xref:web/webflux/config.adoc#webflux-config-validation[WebFlux config], or locally
 through an xref:web/webflux/controller/ann-initbinder.adoc[@InitBinder] method in an
 `@Controller` or `@ControllerAdvice`. You can also use multiple validators.
 
@@ -37,8 +49,8 @@ through an AOP proxy. In order to take advantage of the Spring MVC built-in supp
 method validation added in Spring Framework 6.1, you need to remove the class level
 `@Validated` annotation from the controller.
 
-The xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses] section provides further
-details on how `MethodArgumentNotValidException` and `HandlerMethodValidationException`
+The xref:web/webflux/ann-rest-exceptions.adoc[Error Responses] section provides further
+details on how `WebExchangeBindException` and `HandlerMethodValidationException`
 are handled, and also how their rendering can be customized through a `MessageSource` and
 locale and language specific resource bundles.
 

framework-docs/modules/ROOT/pages/web/webmvc-functional.adoc

@@ -781,7 +781,7 @@ Java::
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
     ClassPathResource index = new ClassPathResource("static/index.html");
-	List<String> extensions = List.of("js", "css", "ico", "png", "jpg", "gif");
+	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)

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-jackson.adoc

@@ -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 customized XML mapping as needed by using JAXB or Jackson's provided
+You can customize 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.

framework-docs/modules/ROOT/pages/web/webmvc-view/mvc-jsp.adoc

@@ -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 wildcarding functionality.
+shows that the `errors` tag also supports some basic wildcard functionality.
 
 * `path="{asterisk}"`: Displays all errors.
 * `path="lastName"`: Displays all errors associated with the `lastName` field.

framework-docs/modules/ROOT/pages/web/webmvc/mvc-ann-async.adoc

@@ -500,8 +500,8 @@ The MVC configuration exposes the following options for asynchronous request pro
 
 You can configure the following:
 
-* Default timeout value for async requests, which if not set, depends
-on the underlying Servlet container.
+* The default timeout value for async requests depends
+on the underlying Servlet container, unless it is set explicitly.
 * `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.

framework-docs/modules/ROOT/pages/web/webmvc/mvc-ann-rest-exceptions.adoc

@@ -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}/rfc7807[RFC 7807].
+specification, {rfc-site}/rfc9457[RFC 9457].
 
 The following are the main abstractions for this support:
 
-- `ProblemDetail` -- representation for an RFC 7807 problem detail; a simple container
+- `ProblemDetail` -- representation for an RFC 9457 problem detail; a simple container
 for both standard fields defined in the spec, and for non-standard ones.
 - `ErrorResponse` -- contract to expose HTTP error response details including HTTP
-status, response headers, and a body in the format of RFC 7807; this allows exceptions to
+status, response headers, and a body in the format of RFC 9457; 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 7807 response. This is processed as follows:
+any `@RequestMapping` method to render an RFC 9457 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 7807 responses for Spring WebFlux exceptions and for any
+To enable RFC 9457 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 7807 response with non-standard fields in one of two ways.
+You can extend an RFC 9457 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,9 +79,11 @@ 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 follows the pattern:
+The default strategy for message codes is as follows:
 
-`problemDetail.[type|title|detail].[fully qualified exception class name]`
+* "type": `problemDetail.type.[fully qualified exception class name]`
+* "title": `problemDetail.title.[fully qualified exception class name]`
+* "detail": `problemDetail.[fully qualified exception class name][suffix]`
 
 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
@@ -136,7 +138,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 resolvedvia `MessageSource`.
+  Message codes and arguments for each error are also resolved via `MessageSource`.
 
 | `MissingRequestHeaderException`
 | (default)

framework-docs/modules/ROOT/pages/web/webmvc/mvc-config/interceptors.adoc

@@ -52,14 +52,10 @@ The following example shows how to achieve the same configuration in XML:
 	</mvc:interceptors>
 ----
 
-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.
+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: The XML config declares interceptors as `MappedInterceptor` beans, and those are in
 turn detected by any `HandlerMapping` bean, including those from other frameworks.

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-exceptionhandler.adoc

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

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/responsebody.adoc

@@ -37,6 +37,13 @@ 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.
 

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/responseentity.adoc

@@ -32,6 +32,18 @@ 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`). Also, custom
+subclasses of `InputStreamResource` are only supported in combination with a custom
+`contentLength()` implementation which avoids consuming the stream for that purpose.
+
 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:

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-methods/return-types.adoc

@@ -23,11 +23,11 @@ supported for all return values.
 | For returning a response with headers and no body.
 
 | `ErrorResponse`
-| To render an RFC 7807 error response with details in the body,
+| To render an RFC 9457 error response with details in the body,
   see xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses]
 
 | `ProblemDetail`
-| To render an RFC 7807 error response with details in the body,
+| To render an RFC 9457 error response with details in the body,
   see xref:web/webmvc/mvc-ann-rest-exceptions.adoc[Error Responses]
 
 | `String`

framework-docs/modules/ROOT/pages/web/webmvc/mvc-controller/ann-validation.adoc

@@ -3,28 +3,40 @@
 
 [.small]#xref:web/webflux/controller/ann-validation.adoc[See equivalent in the Reactive stack]#
 
-Spring MVC has built-in xref:core/validation/validator.adoc[Validation] support for
-`@RequestMapping` methods, including the option to use
-xref:core/validation/beanvalidation.adoc[Java Bean Validation].
-The validation support works on two levels.
+Spring MVC has built-in xref:core/validation/validator.adoc[validation] for
+`@RequestMapping` methods, including xref:core/validation/beanvalidation.adoc[Java Bean Validation].
+Validation may be applied at one of two levels:
 
-First, resolvers for
-xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[@ModelAttribute],
+1. 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] argument
+resolvers validate a method argument individually if the method parameter is annotated
+with Jakarta `@Valid` or Spring's `@Validated`, _AND_ there is no `Errors` or
+`BindingResult` parameter immediately after, _AND_ method validation is not needed (to be
+discussed next). The exception raised in this case is `MethodArgumentNotValidException`.
 
-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.
+2. When `@Constraint` annotations such as `@Min`, `@NotBlank` and others are declared
+directly on method parameters, or on the method (for the return value), then method
+validation must be applied, and that supersedes validation at the method argument level
+because method validation covers both method parameter constraints and nested constraints
+via `@Valid`. The exception raised in this case is `HandlerMethodValidationException`.
+
+Applications must handle both `MethodArgumentNotValidException` and
+`HandlerMethodValidationException` as either may be raised depending on the controller
+method signature. The two exceptions, however are designed to be very similar, and can be
+handled with almost identical code. The main difference is that the former is for a single
+object while the latter is for a list of method parameters.
+
+NOTE: `@Valid` is not a constraint annotation, but rather for nested constraints within
+an Object. Therefore, by itself `@Valid` does not lead to method validation. `@NotNull`
+on the other hand is a constraint, and adding it to an `@Valid` parameter leads to method
+validation. For nullability specifically, you may also use the `required` flag of
+`@RequestBody` or `@ModelAttribute`.
+
+Method validation may be used in combination with `Errors` or `BindingResult` method
+parameters. However, the controller method is called only if all validation errors are on
+method parameters with an `Errors` immediately after. If there are validation errors on
+any other method parameter then `HandlerMethodValidationException` is raised.
 
 You can configure a `Validator` globally through the
 xref:web/webmvc/mvc-config/validation.adoc[WebMvc config], or locally through an

framework-docs/modules/ROOT/pages/web/webmvc/mvc-servlet/handlermapping-interceptor.adoc

@@ -1,34 +1,29 @@
 [[mvc-handlermapping-interceptor]]
 = Interception
 
-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:
+All `HandlerMapping` implementations support handler interception which is useful when
+you want to apply functionality across requests. A `HandlerInterceptor` can implement the
+following:
 
-* `preHandle(..)`: Before the actual handler is run
-* `postHandle(..)`: After the handler is run
-* `afterCompletion(..)`: After the complete request has finished
+* `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.
 
-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.
+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`.
 
 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.
 
-`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`.
-
-
-
+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.
 

framework-docs/modules/ROOT/pages/web/websocket/stomp/handle-simple-broker.adoc

@@ -13,7 +13,7 @@ If configured with a task scheduler, the simple broker supports
 https://stomp.github.io/stomp-specification-1.2.html#Heart-beating[STOMP heartbeats].
 To configure a scheduler, you can declare your own `TaskScheduler` bean and set it through
 the `MessageBrokerRegistry`. Alternatively, you can use the one that is automatically
-declared in the built-in WebSocket configuration, however, you'll' need `@Lazy` to avoid
+declared in the built-in WebSocket configuration, however, you'll need `@Lazy` to avoid
 a cycle between the built-in WebSocket configuration and your
 `WebSocketMessageBrokerConfigurer`. For example:
 

framework-docs/modules/ROOT/partials/web/web-uris.adoc

@@ -389,7 +389,7 @@ template.
 encode URI component value _after_ URI variables are expanded.
 * `NONE`: No encoding is applied.
 
-The `RestTemplate` is set to `EncodingMode.URI_COMPONENT` for historic
+The `RestTemplate` is set to `EncodingMode.URI_COMPONENT` for historical
 reasons and for backwards compatibility. The `WebClient` relies on the default value
 in `DefaultUriBuilderFactory`, which was changed from `EncodingMode.URI_COMPONENT` in
 5.0.x to `EncodingMode.TEMPLATE_AND_VALUES` in 5.1.

framework-docs/package.json

@@ -0,0 +1,10 @@
+{
+  "dependencies": {
+    "antora": "3.2.0-alpha.4",
+    "@antora/atlas-extension": "1.0.0-alpha.2",
+    "@antora/collector-extension": "1.0.0-alpha.3",
+    "@asciidoctor/tabs": "1.0.0-beta.6",
+    "@springio/antora-extensions": "1.11.1",
+    "@springio/asciidoctor-extensions": "1.0.0-alpha.10"
+  }
+}

framework-platform/framework-platform.gradle

@@ -7,33 +7,33 @@ javaPlatform {
 }
 
 dependencies {
-	api(platform("com.fasterxml.jackson:jackson-bom:2.15.3"))
-	api(platform("io.micrometer:micrometer-bom:1.12.3"))
-	api(platform("io.netty:netty-bom:4.1.107.Final"))
+	api(platform("com.fasterxml.jackson:jackson-bom:2.15.4"))
+	api(platform("io.micrometer:micrometer-bom:1.12.8"))
+	api(platform("io.netty:netty-bom:4.1.111.Final"))
 	api(platform("io.netty:netty5-bom:5.0.0.Alpha5"))
-	api(platform("io.projectreactor:reactor-bom:2023.0.3"))
+	api(platform("io.projectreactor:reactor-bom:2023.0.8"))
 	api(platform("io.rsocket:rsocket-bom:1.1.3"))
-	api(platform("org.apache.groovy:groovy-bom:4.0.18"))
+	api(platform("org.apache.groovy:groovy-bom:4.0.22"))
 	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.6"))
-	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.6"))
+	api(platform("org.assertj:assertj-bom:3.26.0"))
+	api(platform("org.eclipse.jetty:jetty-bom:12.0.11"))
+	api(platform("org.eclipse.jetty.ee10:jetty-ee10-bom:12.0.11"))
 	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.10.0"))
+	api(platform("org.jetbrains.kotlinx:kotlinx-serialization-bom:1.6.3"))
+	api(platform("org.junit:junit-bom:5.10.3"))
+	api(platform("org.mockito:mockito-bom:5.12.0"))
 
 	constraints {
 		api("com.fasterxml:aalto-xml:1.3.2")
-		api("com.fasterxml.woodstox:woodstox-core:6.5.1")
+		api("com.fasterxml.woodstox:woodstox-core:6.6.2")
 		api("com.github.ben-manes.caffeine:caffeine:3.1.8")
-		api("com.github.librepdf:openpdf:1.3.40")
+		api("com.github.librepdf:openpdf:1.3.43")
 		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.2")
+		api("com.google.protobuf:protobuf-java-util:3.25.3")
 		api("com.h2database:h2:2.2.224")
-		api("com.jayway.jsonpath:json-path:2.8.0")
+		api("com.jayway.jsonpath:json-path:2.9.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,7 +42,7 @@ 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.0.3")
+		api("com.thoughtworks.qdox:qdox:2.1.0")
 		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")
@@ -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.11.Final")
-		api("io.undertow:undertow-servlet:2.3.11.Final")
-		api("io.undertow:undertow-websockets-jsr:2.3.11.Final")
+		api("io.undertow:undertow-core:2.3.14.Final")
+		api("io.undertow:undertow-servlet:2.3.14.Final")
+		api("io.undertow:undertow-websockets-jsr:2.3.14.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")
@@ -101,26 +101,26 @@ dependencies {
 		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.core5:httpcore5-reactive:5.2.4")
+		api("org.apache.httpcomponents.core5:httpcore5-reactive:5.2.5")
 		api("org.apache.poi:poi-ooxml:5.2.5")
-		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.apache.tomcat.embed:tomcat-embed-core:10.1.25")
+		api("org.apache.tomcat.embed:tomcat-embed-websocket:10.1.25")
+		api("org.apache.tomcat:tomcat-util:10.1.25")
+		api("org.apache.tomcat:tomcat-websocket:10.1.25")
+		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.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.2")
+		api("org.eclipse.jetty:jetty-reactive-httpclient:4.0.5")
 		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")
 		api("org.ehcache:jcache:1.0.1")
-		api("org.freemarker:freemarker:2.3.32")
+		api("org.freemarker:freemarker:2.3.33")
 		api("org.glassfish.external:opendmk_jmxremote_optional_jar:1.0-b01-ea")
 		api("org.glassfish:jakarta.el:4.0.2")
 		api("org.glassfish.tyrus:tyrus-container-servlet:2.1.3")
@@ -129,17 +129,17 @@ dependencies {
 		api("org.hibernate:hibernate-core-jakarta:5.6.15.Final")
 		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.5.0")
+		api("org.javamoney:moneta:1.4.4")
+		api("org.jruby:jruby:9.4.8.0")
 		api("org.junit.support:testng-engine:1.0.5")
-		api("org.mozilla:rhino:1.7.14")
+		api("org.mozilla:rhino:1.7.15")
 		api("org.ogce:xpp3:1.1.6")
 		api("org.python:jython-standalone:2.7.3")
 		api("org.quartz-scheduler:quartz:2.3.2")
 		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.skyscreamer:jsonassert:1.5.3")
+		api("org.slf4j:slf4j-api:2.0.13")
 		api("org.testng:testng:7.9.0")
 		api("org.webjars:underscorejs:1.8.3")
 		api("org.webjars:webjars-locator-core:0.55")

gradle.properties

@@ -1,10 +1,10 @@
-version=6.1.4-SNAPSHOT
+version=6.1.11
 
 org.gradle.caching=true
 org.gradle.jvmargs=-Xmx2048m
 org.gradle.parallel=true
 
-kotlinVersion=1.9.22
+kotlinVersion=1.9.24
 
 kotlin.jvm.target.validation.mode=ignore
 kotlin.stdlib.default.dependency=false

gradle/docs-dokka.gradle

@@ -6,6 +6,7 @@ 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/"))
@@ -21,6 +22,7 @@ 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/"))

gradle/publications.gradle

@@ -29,7 +29,7 @@ publishing {
 					developer {
 						id = "jhoeller"
 						name = "Juergen Hoeller"
-						email = "jhoeller@pivotal.io"
+						email = "juergen.hoeller@broadcom.com"
 					}
 				}
 				issueManagement {

gradle/toolchains.gradle

@@ -87,12 +87,12 @@ rootProject.ext {
 gradle.taskGraph.afterTask { Task task, TaskState state ->
 	if (!resolvedMainToolchain && task instanceof JavaCompile && task.javaCompiler.isPresent()) {
 		def metadata = task.javaCompiler.get().metadata
-		task.project.buildScan.value('Main toolchain', "$metadata.vendor $metadata.languageVersion ($metadata.installationPath)")
+		task.project.develocity.buildScan.value('Main toolchain', "$metadata.vendor $metadata.languageVersion ($metadata.installationPath)")
 		resolvedMainToolchain = true
 	}
 	if (testToolchainConfigured() && !resolvedTestToolchain && task instanceof Test && task.javaLauncher.isPresent()) {
 		def metadata = task.javaLauncher.get().metadata
-		task.project.buildScan.value('Test toolchain', "$metadata.vendor $metadata.languageVersion ($metadata.installationPath)")
+		task.project.develocity.buildScan.value('Test toolchain', "$metadata.vendor $metadata.languageVersion ($metadata.installationPath)")
 		resolvedTestToolchain = true
 	}
 }