Release v6.1.2

2026-06-08 17:33:33 +00:00 · 2023-12-14 10:28:53 +00:00
3062 changed files with 30165 additions and 50984 deletions
@@ -1,20 +0,0 @@
-name: Await HTTP Resource
-description: 'Waits for an HTTP resource to be available (a HEAD request succeeds)'
-inputs:
-  url:
-    description: 'URL of the resource to await'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Await HTTP resource
-      shell: bash
-      run: |
-        url=${{ inputs.url }}
-        echo "Waiting for $url"
-        until curl --fail --head --silent ${{ inputs.url }} > /dev/null
-        do
-          echo "."
-          sleep 60
-        done
-        echo "$url is available"
@@ -1,61 +0,0 @@
-name: 'Build'
-description: 'Builds the project, optionally publishing it to a local deployment repository'
-inputs:
-  develocity-access-key:
-    description: 'Access key for authentication with ge.spring.io'
-    required: false
-  java-distribution:
-    description: 'Java distribution to use'
-    required: false
-    default: 'liberica'
-  java-early-access:
-    description: 'Whether the Java version is in early access'
-    required: false
-    default: 'false'
-  java-toolchain:
-    description: 'Whether a Java toolchain should be used'
-    required: false
-    default: 'false'
-  java-version:
-    description: 'Java version to compile and test with'
-    required: false
-    default: '17'
-  publish:
-    description: 'Whether to publish artifacts ready for deployment to Artifactory'
-    required: false
-    default: 'false'
-outputs:
-  build-scan-url:
-    description: '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: '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-distribution: ${{ inputs.java-distribution }}
-        java-early-access: ${{ inputs.java-early-access }}
-        java-toolchain: ${{ inputs.java-toolchain }}
-        java-version: ${{ inputs.java-version }}
-    - 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
@@ -1,23 +0,0 @@
-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:
-        config-file: .github/actions/create-github-release/changelog-generator.yml
-        milestone: ${{ inputs.milestone }}
-        token: ${{ inputs.token }}
-    - name: Create GitHub Release
-      shell: bash
-      env:
-        GITHUB_TOKEN: ${{ inputs.token }}
-      run: gh release create ${{ format('v{0}', inputs.milestone) }} --notes-file changelog.md
@@ -1,53 +0,0 @@
-name: Prepare Gradle Build
-description: 'Prepares a Gradle build. Sets up Java and Gradle and configures Gradle properties'
-inputs:
-  develocity-access-key:
-    description: 'Access key for authentication with ge.spring.io'
-    required: false
-  java-distribution:
-    description: 'Java distribution to use'
-    required: false
-    default: 'liberica'
-  java-early-access:
-    description: 'Whether the Java version is in early access. When true, forces java-distribution to temurin'
-    required: false
-    default: 'false'
-  java-toolchain:
-    description: 'Whether a Java toolchain should be used'
-    required: false
-    default: 'false'
-  java-version:
-    description: 'Java version to use for the build'
-    required: false
-    default: '17'
-runs:
-  using: composite
-  steps:
-    - name: Set Up Java
-      uses: actions/setup-java@v4
-      with:
-        distribution: ${{ inputs.java-early-access == 'true' && 'temurin' || (inputs.java-distribution || 'liberica') }}
-        java-version: |
-          ${{ inputs.java-early-access == 'true' && format('{0}-ea', inputs.java-version) || inputs.java-version }}
-          ${{ inputs.java-toolchain == 'true' && '17' || '' }}
-    - name: Set Up Gradle
-      uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
-      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
@@ -1,17 +0,0 @@
-name: Print JVM thread dumps
-description: 'Prints a thread dump for all running JVMs'
-runs:
-  using: composite
-  steps:
-    - if: ${{ runner.os == 'Linux' }}
-      shell: bash
-      run: |
-        for jvm_pid in $(jps -q -J-XX:+PerfDisableSharedMem); do
-          jcmd $jvm_pid Thread.print
-        done
-    - if: ${{ runner.os == 'Windows' }}
-      shell: powershell
-      run: |
-        foreach ($jvm_pid in $(jps -q -J-XX:+PerfDisableSharedMem)) {
-          jcmd $jvm_pid Thread.print
-        }
@@ -1,39 +0,0 @@
-name: Send Notification
-description: 'Sends a Google Chat message as a notification of the job''s outcome'
-inputs:
-  build-scan-url:
-    description: 'URL of the build scan to include in the notification'
-    required: false
-  run-name:
-    description: 'Name of the run to include in the notification'
-    required: false
-    default: ${{ format('{0} {1}', github.ref_name, github.job) }}
-  status:
-    description: 'Status of the job'
-    required: true
-  webhook-url:
-    description: 'Google Chat Webhook URL'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Prepare Variables
-      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"
-    - name: Success Notification
-      if: ${{ inputs.status == 'success' }}
-      shell: bash
-      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
-    - name: Failure Notification
-      if: ${{ inputs.status == 'failure' }}
-      shell: bash
-      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
-    - name: Cancel Notification
-      if: ${{ inputs.status == 'cancelled' }}
-      shell: bash
-      run: |
-        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was cancelled"}' || true
@@ -1,43 +0,0 @@
-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
-  ossrh-s01-staging-profile:
-    description: 'Staging profile to use when syncing to Central'
-    required: true
-  ossrh-s01-token-password:
-    description: 'Password for authentication with s01.oss.sonatype.org'
-    required: true
-  ossrh-s01-token-username:
-    description: 'Username for authentication with s01.oss.sonatype.org'
-    required: true
-  spring-framework-version:
-    description: 'Version of Spring Framework that is being synced to Central'
-    required: true
-runs:
-  using: composite
-  steps:
-    - name: Set Up JFrog CLI
-      uses: jfrog/setup-jfrog-cli@9fe0f98bd45b19e6e931d457f4e98f8f84461fb5 # v4.4.1
-      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:
-        close: true
-        create: true
-        generate-checksums: true
-        password: ${{ inputs.ossrh-s01-token-password }}
-        release: true
-        staging-profile-name: ${{ inputs.ossrh-s01-staging-profile }}
-        upload: true
-        username: ${{ inputs.ossrh-s01-token-username }}
-    - name: Await
-      uses: ./.github/actions/await-http-resource
-      with:
-        url: ${{ format('https://repo.maven.apache.org/maven2/org/springframework/spring-context/{0}/spring-context-{0}.jar', inputs.spring-framework-version) }}
@@ -1,20 +0,0 @@
-{
-  "files": [
-    {
-      "aql": {
-        "items.find": {
-          "$and": [
-            {
-              "@build.name": "${buildName}",
-              "@build.number": "${buildNumber}",
-              "path": {
-                "$nmatch": "org/springframework/framework-api/*"
-              }
-            }
-          ]
-        }
-      },
-      "target": "nexus/"
-    }
-  ]
-}
@@ -1,4 +1,5 @@
 name: Backport Bot
+
 on:
  issues:
    types: [labeled]
@@ -17,17 +18,15 @@ jobs:
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Java
-        uses: actions/setup-java@v4
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
        with:
-          distribution: 'liberica'
-          java-version: 17
+          distribution: 'temurin'
+          java-version: '17'
      - name: Download BackportBot
        run: wget https://github.com/spring-io/backport-bot/releases/download/latest/backport-bot-0.0.1-SNAPSHOT.jar
      - name: Backport
        env:
-          GITHUB_EVENT: ${{ toJSON(github.event) }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_EVENT: ${{ toJSON(github.event) }}
        run: java -jar backport-bot-0.0.1-SNAPSHOT.jar --github.accessToken="$GITHUB_TOKEN" --github.event_name "$GITHUB_EVENT_NAME" --github.event "$GITHUB_EVENT"
@@ -1,58 +0,0 @@
-name: Build and Deploy Snapshot
-on:
-  push:
-    branches:
-      - 6.1.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-deploy-snapshot:
-    name: Build and Deploy Snapshot
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    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.DEVELOCITY_ACCESS_KEY }}
-          publish: true
-      - name: Deploy
-        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
-        with:
-          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
-          build-name: 'spring-framework-6.1.x'
-          folder: 'deployment-repository'
-          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
-          repository: 'libs-snapshot-local'
-          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
-          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          uri: 'https://repo.spring.io'
-          username: ${{ secrets.ARTIFACTORY_USERNAME }}
-      - name: Send Notification
-        if: always()
-        uses: ./.github/actions/send-notification
-        with:
-          build-scan-url: ${{ steps.build-and-publish.outputs.build-scan-url }}
-          run-name: ${{ format('{0} | Linux | Java 17', github.ref_name) }}
-          status: ${{ job.status }}
-          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
-    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 }}
@@ -1,36 +0,0 @@
-name: Build Pull Request
-on: pull_request
-permissions:
-  contents: read
-jobs:
-  build:
-    name: Build Pull Request
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - name: Set Up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: '17'
-      - name: Check Out
-        uses: actions/checkout@v4
-      - name: Validate Gradle Wrapper
-        uses: gradle/actions/wrapper-validation@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
-      - name: Set Up Gradle
-        uses: gradle/actions/setup-gradle@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
-      - name: Build
-        env:
-          CI: 'true'
-          GRADLE_ENTERPRISE_URL: 'https://ge.spring.io'
-        run: ./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --no-parallel --continue build
-      - name: Print JVM Thread Dumps When Cancelled
-        if: cancelled()
-        uses: ./.github/actions/print-jvm-thread-dumps
-      - name: Upload Build Reports
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-reports
-          path: '**/build/reports/'
@@ -1,58 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - 6.1.x
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  ci:
-    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    runs-on: ${{ matrix.os.id }}
-    timeout-minutes: 60
-    strategy:
-      matrix:
-        os:
-          - id: ubuntu-latest
-            name: Linux
-        java:
-          - version: 17
-            toolchain: false
-          - version: 21
-            toolchain: true
-          - version: 22
-            toolchain: true
-          - version: 23
-            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:
-          develocity-access-key: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
-          java-early-access: ${{ matrix.java.early-access || 'false' }}
-          java-distribution: ${{ matrix.java.distribution }}
-          java-toolchain: ${{ matrix.java.toolchain }}
-          java-version: ${{ matrix.java.version }}
-      - name: Send Notification
-        if: always()
-        uses: ./.github/actions/send-notification
-        with:
-          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) }}
-          status: ${{ job.status }}
-          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
@@ -1,28 +1,25 @@
 name: Deploy Docs
 on:
  push:
-    branches:
-      - 'main'
-      - '*.x'
-      - '!gh-pages'
-    tags:
-      - 'v*'
+    branches-ignore: [ gh-pages ]
+    tags: '**'
  repository_dispatch:
    types: request-build-reference # legacy
+  schedule:
+  - cron: '0 10 * * *' # Once per day at 10am UTC
  workflow_dispatch:
 permissions:
  actions: write
 jobs:
  build:
-    name: Dispatch docs deployment
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
    runs-on: ubuntu-latest
+    if: github.repository_owner == 'spring-projects'
    steps:
-    - name: Check out code
-      uses: actions/checkout@v4
+    - name: Checkout
+      uses: actions/checkout@v3
      with:
-        fetch-depth: 1
        ref: docs-build
+        fetch-depth: 1
    - name: Dispatch (partial build)
      if: github.ref_type == 'branch'
      env:
@@ -0,0 +1,13 @@
+name: "Validate Gradle Wrapper"
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  validation:
+    name: "Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: gradle/wrapper-validation-action@v1
@@ -1,94 +0,0 @@
-name: Release
-on:
-  push:
-    tags:
-      - v6.1.[0-9]+
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-jobs:
-  build-and-stage-release:
-    name: Build and Stage Release
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    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.DEVELOCITY_ACCESS_KEY }}
-          publish: true
-      - name: Stage Release
-        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
-        with:
-          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
-          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
-    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:
-      staging: true
-      version: ${{ needs.build-and-stage-release.outputs.version }}
-  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@9fe0f98bd45b19e6e931d457f4e98f8f84461fb5 # v4.4.1
-        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 }}
@@ -1,77 +0,0 @@
-name: Verify
-on:
-  workflow_call:
-    inputs:
-      staging:
-        description: 'Whether the release to verify is in the staging repository'
-        required: false
-        default: false
-        type: boolean
-      version:
-        description: 'Version to verify'
-        required: true
-        type: string
-    secrets:
-      google-chat-webhook-url:
-        description: 'Google Chat Webhook URL'
-        required: true
-      repository-password:
-        description: 'Password for authentication with the repository'
-        required: false
-      repository-username:
-        description: 'Username for authentication with the repository'
-        required: false
-      token:
-        description: 'Token to use for authentication with GitHub'
-        required: true
-jobs:
-  verify:
-    name: Verify
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check Out Release Verification Tests
-        uses: actions/checkout@v4
-        with:
-          ref: 'v0.0.2'
-          repository: spring-projects/spring-framework-release-verification
-          token: ${{ secrets.token }}
-      - name: Check Out Send Notification Action
-        uses: actions/checkout@v4
-        with:
-          path: send-notification
-          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@d156388eb19639ec20ade50009f3d199ce1e2808 # v4.1.0
-        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_OSS_REPOSITORY_PASSWORD: ${{ secrets.repository-password }}
-          RVT_OSS_REPOSITORY_USERNAME: ${{ secrets.repository-username }}
-          RVT_RELEASE_TYPE: oss
-          RVT_STAGING: ${{ inputs.staging }}
-          RVT_VERSION: ${{ inputs.version }}
-        run: ./gradlew spring-framework-release-verification-tests:test
-      - name: Upload Build Reports on Failure
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: build-reports
-          path: '**/build/reports/'
-      - name: Send Notification
-        if: failure()
-        uses: ./send-notification/.github/actions/send-notification
-        with:
-          run-name: ${{ format('{0} | Verification | {1}', github.ref_name, inputs.version) }}
-          status: ${{ job.status }}
-          webhook-url: ${{ secrets.google-chat-webhook-url }}
@@ -51,5 +51,3 @@ atlassian-ide-plugin.xml
 .vscode/

 cached-antora-playbook.yml
-
-node_modules
@@ -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.13-librca
+java=17.0.8.1-librca
@@ -0,0 +1,44 @@
+= 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/]
@@ -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@spring.io.
+Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.

 ### How to Contribute

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

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

@@ -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@spring.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@pivotal.io.

 ## Access to Binaries

@@ -31,7 +31,7 @@ Information regarding CI builds can be found in the [Spring Framework Concourse

 ## Stay in Touch

-Follow [@SpringCentral](https://twitter.com/springcentral), [@SpringFramework](https://twitter.com/springframework), and its [team members](https://twitter.com/springframework/lists/team/members) on 𝕏. In-depth articles can be found at [The Spring Blog](https://spring.io/blog/), and releases are announced via our [releases feed](https://spring.io/blog/category/releases).
+Follow [@SpringCentral](https://twitter.com/springcentral), [@SpringFramework](https://twitter.com/springframework), and its [team members](https://twitter.com/springframework/lists/team/members) on Twitter. In-depth articles can be found at [The Spring Blog](https://spring.io/blog/), and releases are announced via our [releases feed](https://spring.io/blog/category/releases).

 ## License

@@ -3,10 +3,10 @@ plugins {
 	// kotlinVersion is managed in gradle.properties
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
 	id 'org.jetbrains.dokka' version '1.8.20'
-	id 'com.github.ben-manes.versions' version '0.51.0'
-	id 'com.github.bjornvester.xjc' version '1.8.2' apply false
+	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
+	id 'com.github.ben-manes.versions' version '0.49.0'
+	id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
 	id 'de.undercouch.download' version '5.4.0'
-	id 'io.github.goooler.shadow' version '8.1.8' apply false
 	id 'me.champeau.jmh' version '0.7.2' apply false
 	id 'me.champeau.mrjar' version '0.1.1'
 }
@@ -89,19 +89,22 @@ 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/",
 			"https://fasterxml.github.io/jackson-core/javadoc/2.14/",
 			"https://fasterxml.github.io/jackson-databind/javadoc/2.14/",
 			"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.14/",
-			"https://hc.apache.org/httpcomponents-client-5.4.x/current/httpclient5/apidocs/",
+			"https://hc.apache.org/httpcomponents-client-5.2.x/current/httpclient5/apidocs/",
 			"https://projectreactor.io/docs/test/release/api/",
 			"https://junit.org/junit4/javadoc/4.13.2/",
 			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
 			// See https://github.com/spring-projects/spring-framework/issues/27497
 			//
-			// "https://junit.org/junit5/docs/5.10.4/api/",
+			// "https://junit.org/junit5/docs/5.10.1/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			//"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
@@ -1,2 +1,2 @@
 org.gradle.caching=true
-javaFormatVersion=0.0.42
+javaFormatVersion=0.0.39
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2025 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -50,12 +50,12 @@ 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.21.2");
+			checkstyle.setToolVersion("10.12.5");
 			checkstyle.getConfigDirectory().set(project.getRootProject().file("src/checkstyle"));
 			String version = SpringJavaFormatPlugin.class.getPackage().getImplementationVersion();
 			DependencySet checkstyleDependencies = project.getConfigurations().getByName("checkstyle").getDependencies();
-			checkstyleDependencies.add(
-					project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
+			checkstyleDependencies
+				.add(project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
 		});
 	}

@@ -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/**", "**/node_modules/**");
+				"**/.classpath", "**/.project", "**/.gradle/**");
 		List<String> buildFolders = List.of("bin", "build", "out");
 		project.allprojects(subproject -> {
 			Path rootPath = project.getRootDir().toPath();
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2024 the original author or authors.
+ * Copyright 2002-2023 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -62,11 +62,9 @@ class TestConventions {
 		if (project.hasProperty("testGroups")) {
 			test.systemProperty("testGroups", project.getProperties().get("testGroups"));
 		}
-		test.jvmArgs(
-				"--add-opens=java.base/java.lang=ALL-UNNAMED",
+		test.jvmArgs("--add-opens=java.base/java.lang=ALL-UNNAMED",
 				"--add-opens=java.base/java.util=ALL-UNNAMED",
-				"-Xshare:off"
-		);
+				"-Djava.locale.providers=COMPAT");
 	}

 	private void configureTestRetryPlugin(Project project, Test test) {
@@ -26,9 +26,7 @@ import org.gradle.api.attributes.LibraryElements;
 import org.gradle.api.attributes.Usage;
 import org.gradle.api.attributes.java.TargetJvmVersion;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.jvm.JvmTestSuite;
 import org.gradle.api.tasks.testing.Test;
-import org.gradle.testing.base.TestingExtension;

 import java.util.Collections;

@@ -49,8 +47,6 @@ public class RuntimeHintsAgentPlugin implements Plugin<Project> {
 	public void apply(Project project) {

 		project.getPlugins().withType(JavaPlugin.class, javaPlugin -> {
-			TestingExtension testing = project.getExtensions().getByType(TestingExtension.class);
-			JvmTestSuite jvmTestSuite = (JvmTestSuite) testing.getSuites().getByName("test");
 			RuntimeHintsAgentExtension agentExtension = createRuntimeHintsAgentExtension(project);
 			Test agentTest = project.getTasks().create(RUNTIMEHINTS_TEST_TASK, Test.class, test -> {
 				test.useJUnitPlatform(options -> {
@@ -59,8 +55,6 @@ public class RuntimeHintsAgentPlugin implements Plugin<Project> {
 				test.include("**/*Tests.class", "**/*Test.class");
 				test.systemProperty("java.awt.headless", "true");
 				test.systemProperty("org.graalvm.nativeimage.imagecode", "runtime");
-				test.setTestClassesDirs(jvmTestSuite.getSources().getOutput().getClassesDirs());
-				test.setClasspath(jvmTestSuite.getSources().getRuntimeClasspath());
 				test.getJvmArgumentProviders().add(createRuntimeHintsAgentArgumentProvider(project, agentExtension));
 			});
 			project.getTasks().getByName("check", task -> task.dependsOn(agentTest));
@@ -0,0 +1,57 @@
+== Spring Framework Concourse pipeline
+
+The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
+The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
+for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].
+
+=== Setting up your development environment
+
+If you're part of the Spring Framework project on GitHub, you can get access to CI management features.
+First, you need to go to https://ci.spring.io and install the client CLI for your platform (see bottom right of the screen).
+
+You can then login with the instance using:
+
+[source]
+----
+$ fly -t spring login -n spring-framework -c https://ci.spring.io
+----
+
+Once logged in, you should get something like:
+
+[source]
+----
+$ fly ts
+name                  url                   team                  expiry
+spring                https://ci.spring.io  spring-framework      Wed, 25 Mar 2020 17:45:26 UTC
+----
+
+=== Pipeline configuration and structure
+
+The build pipelines are described in `pipeline.yml` file.
+
+This file is listing Concourse resources, i.e. build inputs and outputs such as container images, artifact repositories, source repositories, notification services, etc.
+
+It also describes jobs (a job is a sequence of inputs, tasks and outputs); jobs are organized by groups.
+
+The `pipeline.yml` definition contains `((parameters))` which are loaded from the `parameters.yml` file or from our https://docs.cloudfoundry.org/credhub/[credhub instance].
+
+You'll find in this folder the following resources:
+
+* `pipeline.yml` the build pipeline
+* `parameters.yml` the build parameters used for the pipeline
+* `images/` holds the container images definitions used in this pipeline
+* `scripts/` holds the build scripts that ship within the CI container images
+* `tasks` contains the task definitions used in the main `pipeline.yml`
+
+=== Updating the build pipeline
+
+Updating files on the repository is not enough to update the build pipeline, as changes need to be applied.
+
+The pipeline can be deployed using the following command:
+
+[source]
+----
+$ fly -t spring set-pipeline -p spring-framework-6.0.x -c ci/pipeline.yml -l ci/parameters.yml
+----
+
+NOTE: This assumes that you have credhub integration configured with the appropriate secrets.
@@ -17,12 +17,4 @@ changelog:
        - "type: dependency-upgrade"
  contributors:
    exclude:
-      names:
-        - "bclozel"
-        - "jhoeller"
-        - "poutsma"
-        - "rstoyanchev"
-        - "sbrannen"
-        - "sdeleuze"
-        - "simonbasle"
-        - "snicoll"
+      names: ["bclozel", "jhoeller", "poutsma", "rstoyanchev", "sbrannen", "sdeleuze", "snicoll", "simonbasle"]
@@ -0,0 +1,10 @@
+logging:
+  level:
+    io.spring.concourse: DEBUG
+spring:
+  main:
+    banner-mode: off
+sonatype:
+  exclude:
+    - 'build-info\.json'
+    - '.*\.zip'
@@ -0,0 +1,21 @@
+== CI Images
+
+These images are used by CI to run the actual builds.
+
+To build the image locally run the following from this directory:
+
+----
+$ docker build --no-cache -f <image-folder>/Dockerfile .
+----
+
+For example
+
+----
+$ docker build --no-cache -f spring-framework-ci-image/Dockerfile .
+----
+
+To test run:
+
+----
+$ docker run -it --entrypoint /bin/bash <SHA>
+----
@@ -0,0 +1,12 @@
+FROM ubuntu:jammy-20231128
+
+ADD setup.sh /setup.sh
+ADD get-jdk-url.sh /get-jdk-url.sh
+RUN ./setup.sh
+
+ENV JAVA_HOME /opt/openjdk/java17
+ENV JDK17 /opt/openjdk/java17
+ENV JDK21 /opt/openjdk/java21
+ENV JDK22 /opt/openjdk/java22
+
+ENV PATH $JAVA_HOME/bin:$PATH
@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+	java17)
+		echo "https://download.bell-sw.com/java/17.0.9+11/bellsoft-jdk17.0.9+11-linux-amd64.tar.gz"
+	;;
+	java21)
+		echo "https://download.bell-sw.com/java/21.0.1+12/bellsoft-jdk21.0.1+12-linux-amd64.tar.gz"
+	;;
+	java22)
+		echo "https://download.java.net/java/early_access/jdk22/27/GPL/openjdk-22-ea+27_linux-x64_bin.tar.gz"
+	;;
+	*)
+		echo $"Unknown java version"
+		exit 1
+esac
@@ -0,0 +1,40 @@
+#!/bin/bash
+set -ex
+
+###########################################################
+# UTILS
+###########################################################
+
+export DEBIAN_FRONTEND=noninteractive
+apt-get update
+apt-get install --no-install-recommends -y tzdata ca-certificates net-tools libxml2-utils git curl libudev1 libxml2-utils iptables iproute2 jq fontconfig
+ln -fs /usr/share/zoneinfo/UTC /etc/localtime
+dpkg-reconfigure --frontend noninteractive tzdata
+rm -rf /var/lib/apt/lists/*
+
+curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/concourse-java.sh > /opt/concourse-java.sh
+
+###########################################################
+# JAVA
+###########################################################
+
+mkdir -p /opt/openjdk
+pushd /opt/openjdk > /dev/null
+for jdk in java17 java21 java22
+do
+  JDK_URL=$( /get-jdk-url.sh $jdk )
+  mkdir $jdk
+  pushd $jdk > /dev/null
+  curl -L ${JDK_URL} | tar zx --strip-components=1
+  test -f bin/java
+  test -f bin/javac
+  popd > /dev/null
+done
+popd
+
+###########################################################
+# GRADLE ENTERPRISE
+###########################################################
+cd /
+mkdir ~/.gradle
+echo 'systemProp.user.name=concourse' > ~/.gradle/gradle.properties
@@ -0,0 +1,11 @@
+github-repo: "https://github.com/spring-projects/spring-framework.git"
+github-repo-name: "spring-projects/spring-framework"
+sonatype-staging-profile: "org.springframework"
+docker-hub-organization: "springci"
+artifactory-server: "https://repo.spring.io"
+branch: "main"
+milestone: "6.1.x"
+build-name: "spring-framework"
+pipeline-name: "spring-framework"
+concourse-url: "https://ci.spring.io"
+task-timeout: 1h00m
@@ -0,0 +1,433 @@
+anchors:
+  git-repo-resource-source: &git-repo-resource-source
+    uri: ((github-repo))
+    username: ((github-username))
+    password: ((github-ci-release-token))
+    branch: ((branch))
+  gradle-enterprise-task-params: &gradle-enterprise-task-params
+    GRADLE_ENTERPRISE_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
+    GRADLE_ENTERPRISE_CACHE_USERNAME: ((gradle_enterprise_cache_user.username))
+    GRADLE_ENTERPRISE_CACHE_PASSWORD: ((gradle_enterprise_cache_user.password))
+  sonatype-task-params: &sonatype-task-params
+    SONATYPE_USERNAME: ((sonatype-username))
+    SONATYPE_PASSWORD: ((sonatype-password))
+    SONATYPE_URL: ((sonatype-url))
+    SONATYPE_STAGING_PROFILE: ((sonatype-staging-profile))
+  artifactory-task-params: &artifactory-task-params
+    ARTIFACTORY_SERVER: ((artifactory-server))
+    ARTIFACTORY_USERNAME: ((artifactory-username))
+    ARTIFACTORY_PASSWORD: ((artifactory-password))
+  build-project-task-params: &build-project-task-params
+      BRANCH: ((branch))
+      <<: *gradle-enterprise-task-params
+  docker-resource-source: &docker-resource-source
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+  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
+    body: generated-changelog/changelog.md
+  github-task-params: &github-task-params
+    GITHUB_USERNAME: ((github-username))
+    GITHUB_TOKEN: ((github-ci-release-token))
+
+resource_types:
+- name: registry-image
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: concourse/registry-image-resource
+    tag: 1.8.0
+- name: artifactory-resource
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: springio/artifactory-resource
+    tag: 0.0.18
+- name: github-release
+  type: registry-image
+  source:
+    <<: *docker-resource-source
+    repository: concourse/github-release-resource
+    tag: 1.8.0
+- name: github-status-resource
+  type: registry-image
+  source:
+    <<: *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
+  icon: github
+  source:
+    <<: *git-repo-resource-source
+- name: ci-images-git-repo
+  type: git
+  icon: github
+  source:
+    uri: ((github-repo))
+    branch: ((branch))
+    paths: ["ci/images/*"]
+- name: ci-image
+  type: registry-image
+  icon: docker
+  source:
+    <<: *docker-resource-source
+    repository: ((docker-hub-organization))/spring-framework-ci
+    tag: ((milestone))
+- name: every-morning
+  type: time
+  icon: alarm
+  source:
+    start: 8:00 AM
+    stop: 9:00 AM
+    location: Europe/Vienna
+- name: artifactory-repo
+  type: artifactory-resource
+  icon: package-variant
+  source:
+    uri: ((artifactory-server))
+    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
+  source:
+    owner: spring-projects
+    repository: spring-framework
+    access_token: ((github-ci-release-token))
+    pre_release: true
+    release: false
+- name: github-release
+  type: github-release
+  icon: briefcase-download
+  source:
+    owner: spring-projects
+    repository: spring-framework
+    access_token: ((github-ci-release-token))
+    pre_release: false
+jobs:
+- name: build-ci-images
+  plan:
+    - get: git-repo
+    - get: ci-images-git-repo
+      trigger: true
+    - task: build-ci-image
+      privileged: true
+      file: git-repo/ci/tasks/build-ci-image.yml
+      output_mapping:
+        image: ci-image
+      vars:
+        ci-image-name: ci-image
+        <<: *docker-resource-source
+    - 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
+    - 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:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - task: stage
+      image: ci-image
+      file: git-repo/ci/tasks/stage-version.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+        repo: libs-staging-local
+    - put: git-repo
+      params:
+        repository: stage-git-repo
+- name: promote-milestone
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-milestone]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *artifactory-task-params
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: M
+        <<: *github-task-params
+        <<: *docker-resource-source
+    - put: github-pre-release
+      params:
+        <<: *changelog-task-params
+- name: stage-rc
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - task: stage
+      image: ci-image
+      file: git-repo/ci/tasks/stage-version.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+        repo: libs-staging-local
+    - put: git-repo
+      params:
+        repository: stage-git-repo
+- name: promote-rc
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-rc]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *docker-resource-source
+        <<: *artifactory-task-params
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: RC
+        <<: *github-task-params
+    - put: github-pre-release
+      params:
+        <<: *changelog-task-params
+- name: stage-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - task: stage
+      image: ci-image
+      file: git-repo/ci/tasks/stage-version.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *gradle-enterprise-task-params
+    - put: artifactory-repo
+      params:
+        <<: *artifactory-params
+        repo: libs-staging-local
+    - put: git-repo
+      params:
+        repository: stage-git-repo
+- name: promote-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+      trigger: false
+    - get: artifactory-repo
+      trigger: false
+      passed: [stage-release]
+      params:
+        download_artifacts: true
+        save_build_info: true
+    - task: promote
+      file: git-repo/ci/tasks/promote-version.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *docker-resource-source
+        <<: *artifactory-task-params
+        <<: *sonatype-task-params
+- name: create-github-release
+  serial: true
+  plan:
+    - get: ci-image
+    - get: git-repo
+    - get: artifactory-repo
+      trigger: true
+      passed: [promote-release]
+      params:
+        download_artifacts: false
+        save_build_info: true
+    - task: generate-changelog
+      file: git-repo/ci/tasks/generate-changelog.yml
+      params:
+        RELEASE_TYPE: RELEASE
+        <<: *docker-resource-source
+        <<: *github-task-params
+    - put: github-release
+      params:
+        <<: *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"
+  jobs: ["build-ci-images"]
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
+  --no-daemon --max-workers=4 check
+popd > /dev/null
@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+repository=$(pwd)/distribution-repository
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21,JDK22 \
+  --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
+popd > /dev/null
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+
+pushd git-repo > /dev/null
+./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
+  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check antora
+popd > /dev/null
@@ -0,0 +1,2 @@
+source /opt/concourse-java.sh
+setup_symlinks
@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+CONFIG_DIR=git-repo/ci/config
+version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
+
+java -jar /github-changelog-generator.jar \
+  --spring.config.location=${CONFIG_DIR}/changelog-generator.yml \
+  ${version} generated-changelog/changelog.md
+
+echo ${version} > generated-changelog/version
+echo v${version} > generated-changelog/tag
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+CONFIG_DIR=git-repo/ci/config
+
+version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
+export BUILD_INFO_LOCATION=$(pwd)/artifactory-repo/build-info.json
+
+java -jar /concourse-release-scripts.jar \
+  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
+  publishToCentral $RELEASE_TYPE $BUILD_INFO_LOCATION artifactory-repo || { exit 1; }
+
+java -jar /concourse-release-scripts.jar \
+  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
+  promote $RELEASE_TYPE $BUILD_INFO_LOCATION || { exit 1; }
+
+echo "Promotion complete"
+echo $version > version/version
@@ -0,0 +1,51 @@
+#!/bin/bash
+set -e
+
+source $(dirname $0)/common.sh
+repository=$(pwd)/distribution-repository
+
+pushd git-repo > /dev/null
+git fetch --tags --all > /dev/null
+popd > /dev/null
+
+git clone git-repo stage-git-repo > /dev/null
+
+pushd stage-git-repo > /dev/null
+
+snapshotVersion=$( awk -F '=' '$1 == "version" { print $2 }' gradle.properties )
+if [[ $RELEASE_TYPE = "M" ]]; then
+	stageVersion=$( get_next_milestone_release $snapshotVersion)
+	nextVersion=$snapshotVersion
+elif [[ $RELEASE_TYPE = "RC" ]]; then
+	stageVersion=$( get_next_rc_release $snapshotVersion)
+	nextVersion=$snapshotVersion
+elif [[ $RELEASE_TYPE = "RELEASE" ]]; then
+	stageVersion=$( get_next_release $snapshotVersion)
+	nextVersion=$( bump_version_number $snapshotVersion)
+else
+	echo "Unknown release type $RELEASE_TYPE" >&2; exit 1;
+fi
+
+echo "Staging $stageVersion (next version will be $nextVersion)"
+sed -i "s/version=$snapshotVersion/version=$stageVersion/" gradle.properties
+
+git config user.name "Spring Builds" > /dev/null
+git config user.email "spring-builds@users.noreply.github.com" > /dev/null
+git add gradle.properties > /dev/null
+git commit -m"Release v$stageVersion" > /dev/null
+git tag -a "v$stageVersion" -m"Release v$stageVersion" > /dev/null
+
+./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} -Porg.gradle.java.installations.fromEnv=JDK17,JDK21 \
+  build publishAllPublicationsToDeploymentRepository
+
+git reset --hard HEAD^ > /dev/null
+if [[ $nextVersion != $snapshotVersion ]]; then
+	echo "Setting next development version (v$nextVersion)"
+	sed -i "s/version=$snapshotVersion/version=$nextVersion/" gradle.properties
+	git add gradle.properties > /dev/null
+	git commit -m"Next development version (v$nextVersion)" > /dev/null
+fi;
+
+echo "Staging Complete"
+
+popd > /dev/null
@@ -0,0 +1,30 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: concourse/oci-build-task
+    tag: 0.10.0
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+  - name: ci-images-git-repo
+outputs:
+  - name: image
+caches:
+  - path: ci-image-cache
+params:
+  CONTEXT: ci-images-git-repo/ci/images
+  DOCKERFILE: ci-images-git-repo/ci/images/ci-image/Dockerfile
+  DOCKER_HUB_AUTH: ((docker-hub-auth))
+run:
+  path: /bin/sh
+  args:
+    - "-c"
+    - |
+      mkdir -p /root/.docker
+      cat > /root/.docker/config.json <<EOF
+      { "auths": { "https://index.docker.io/v1/": { "auth": "$DOCKER_HUB_AUTH" }}}
+      EOF
+      build
+
@@ -0,0 +1,19 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/build-pr.sh
@@ -0,0 +1,22 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: distribution-repository
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/build-project.sh
@@ -0,0 +1,24 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: distribution-repository
+- name: git-repo
+caches:
+- path: gradle
+params:
+  BRANCH:
+  CI: true
+  MAIN_TOOLCHAIN:
+  TEST_TOOLCHAIN:
+  GRADLE_ENTERPRISE_ACCESS_KEY:
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+run:
+  path: bash
+  args:
+    - -ec
+    - |
+      ${PWD}/git-repo/ci/scripts/check-project.sh
@@ -0,0 +1,22 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/github-changelog-generator
+    tag: '0.0.8'
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+- name: git-repo
+- name: artifactory-repo
+outputs:
+- name: generated-changelog
+params:
+  GITHUB_ORGANIZATION:
+  GITHUB_REPO:
+  GITHUB_USERNAME:
+  GITHUB_TOKEN:
+  RELEASE_TYPE:
+run:
+  path: git-repo/ci/scripts/generate-changelog.sh
@@ -0,0 +1,25 @@
+---
+platform: linux
+image_resource:
+  type: registry-image
+  source:
+    repository: springio/concourse-release-scripts
+    tag: '0.4.0'
+    username: ((docker-hub-username))
+    password: ((docker-hub-password))
+inputs:
+- name: git-repo
+- name: artifactory-repo
+outputs:
+- name: version
+params:
+  RELEASE_TYPE:
+  ARTIFACTORY_SERVER:
+  ARTIFACTORY_USERNAME:
+  ARTIFACTORY_PASSWORD:
+  SONATYPE_USER:
+  SONATYPE_PASSWORD:
+  SONATYPE_URL:
+  SONATYPE_STAGING_PROFILE:
+run:
+  path: git-repo/ci/scripts/promote-version.sh
@@ -0,0 +1,17 @@
+---
+platform: linux
+inputs:
+- name: git-repo
+outputs:
+- name: stage-git-repo
+- name: distribution-repository
+params:
+  RELEASE_TYPE:
+  CI: true
+  GRADLE_ENTERPRISE_CACHE_USERNAME:
+  GRADLE_ENTERPRISE_CACHE_PASSWORD:
+  GRADLE_ENTERPRISE_URL: https://ge.spring.io
+caches:
+- path: gradle
+run:
+  path: git-repo/ci/scripts/stage-version.sh
@@ -28,7 +28,7 @@ javadoc {
 		header = rootProject.description
 		use = true
 		overview = project.relativePath("$rootProject.rootDir/framework-docs/src/docs/api/overview.html")
-		destinationDir = project.java.docsDir.dir("javadoc-api").get().asFile
+		destinationDir = file("${project.buildDir}/docs/javadoc-api")
 		splitIndex = true
 		links(rootProject.ext.javadocLinks)
 		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
@@ -52,7 +52,7 @@ rootProject.tasks.dokkaHtmlMultiModule.configure {
 		tasks.named("javadoc")
 	}
 	moduleName.set("spring-framework")
-	outputDirectory.set(project.java.docsDir.dir("kdoc-api").get().asFile)
+	outputDirectory.set(project.file("$buildDir/docs/kdoc-api"))
 	includes.from("$rootProject.rootDir/framework-docs/src/docs/api/dokka-overview.md")
 }

@@ -1,39 +0,0 @@
-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}.+({1..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.18/ui-bundle.zip
@@ -18,9 +18,7 @@ asciidoc:
    # FIXME: The package is not renamed
    chomp: 'all'
    fold: 'all'
-    table-stripes: 'odd'
    include-java: 'example$docs-src/main/java/org/springframework/docs'
-    include-kotlin: 'example$docs-src/main/kotlin/org/springframework/docs'
    spring-site: 'https://spring.io'
    spring-site-blog: '{spring-site}/blog'
    spring-site-cve: "{spring-site}/security"
@@ -71,9 +69,6 @@ asciidoc:
    kotlin-coroutines-api: '{kotlin-site}/api/kotlinx.coroutines'
    kotlin-github-org: 'https://github.com/Kotlin'
    kotlin-issues: 'https://youtrack.jetbrains.com/issue'
-    micrometer-docs: 'https://docs.micrometer.io/micrometer/reference'
-    micrometer-context-propagation-docs: 'https://docs.micrometer.io/context-propagation/reference'
-    petclinic-github-org: 'https://github.com/spring-petclinic'
    reactive-streams-site: 'https://www.reactive-streams.org'
    reactive-streams-spec: 'https://github.com/reactive-streams/reactive-streams-jvm/blob/master/README.md#specification'
    reactor-github-org: 'https://github.com/reactor'
@@ -91,5 +86,4 @@ asciidoc:
    stackoverflow-questions: '{stackoverflow-site}/questions'
    stackoverflow-spring-tag: "{stackoverflow-questions}/tagged/spring"
    stackoverflow-spring-kotlin-tags: "{stackoverflow-spring-tag}+kotlin"
-    testcontainers-site: 'https://www.testcontainers.org'
-    vavr-docs: 'https://vavr-io.github.io/vavr-docs'
+    testcontainers-site: 'https://www.testcontainers.org'
@@ -10,10 +10,27 @@ apply from: "${rootDir}/gradle/ide.gradle"
 apply from: "${rootDir}/gradle/publications.gradle"

 antora {
-	options = [clean: true, fetch: !project.gradle.startParameter.offline, stacktrace: true]
+	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']
 	environment = [
-			'BUILD_REFNAME': 'HEAD',
-			'BUILD_VERSION': project.version,
+			'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-alpha.2',
+			'@springio/antora-extensions': '1.3.0',
+			'@springio/asciidoctor-extensions': '1.0.0-alpha.9'
 	]
 }

@@ -43,15 +60,10 @@ repositories {

 dependencies {
 	api(project(":spring-context"))
-	api(project(":spring-jdbc"))
 	api(project(":spring-jms"))
 	api(project(":spring-web"))
-	api(project(":spring-webflux"))
-
-	api("com.oracle.database.jdbc:ojdbc11")
 	api("jakarta.jms:jakarta.jms-api")
 	api("jakarta.servlet:jakarta.servlet-api")
-	api("org.jetbrains.kotlin:kotlin-stdlib")

 	implementation(project(":spring-core-test"))
 	implementation("org.assertj:assertj-core")
@@ -39,8 +39,8 @@
 ** xref:core/resources.adoc[]
 ** xref:core/validation.adoc[]
 *** xref:core/validation/validator.adoc[]
-*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/conversion.adoc[]
+*** xref:core/validation/beans-beans.adoc[]
 *** xref:core/validation/convert.adoc[]
 *** xref:core/validation/format.adoc[]
 *** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
@@ -421,7 +421,7 @@
 *** xref:integration/cache/specific-config.adoc[]
 ** xref:integration/observability.adoc[]
 ** xref:integration/checkpoint-restore.adoc[]
-** xref:integration/cds.adoc[]
+** xref:integration/class-data-sharing.adoc[]
 ** xref:integration/appendix.adoc[]
 * xref:languages.adoc[]
 ** xref:languages/kotlin.adoc[]
@@ -439,5 +439,4 @@
 ** xref:languages/groovy.adoc[]
 ** xref:languages/dynamic.adoc[]
 * xref:appendix.adoc[]
-* {spring-framework-wiki}[Wiki]
-
+* {spring-framework-wiki}[Wiki]
@@ -19,57 +19,15 @@ of the classpath -- for example, deployed within the application's JAR file.
 The following table lists all currently supported Spring properties.

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

-| `spring.aop.ajc.ignore`
-| Instructs Spring to ignore ajc-compiled aspects for Spring AOP proxying, restoring traditional
-Spring behavior for scenarios where both weaving and AspectJ auto-proxying are enabled. See
-{spring-framework-api}++/aop/aspectj/annotation/AbstractAspectJAdvisorFactory.html#IGNORE_AJC_PROPERTY_NAME++[`AbstractAspectJAdvisorFactory`]
-for details.
-
-| `spring.aot.enabled`
-| Indicates the application should run with AOT generated artifacts. See
-xref:core/aot.adoc[Ahead of Time Optimizations] and 
-{spring-framework-api}++/aot/AotDetector.html#AOT_ENABLED++[`AotDetector`]
-for details.
-
 | `spring.beaninfo.ignore`
 | Instructs Spring to use the `Introspector.IGNORE_ALL_BEANINFO` mode when calling the
 JavaBeans `Introspector`. See
-{spring-framework-api}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`StandardBeanInfoFactory`]
+{spring-framework-api}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
 for details.

-| `spring.cache.reactivestreams.ignore`
-| Instructs Spring's caching infrastructure to ignore the presence of Reactive Streams,
-in particular Reactor's `Mono`/`Flux` in `@Cacheable` method return type declarations. See
-{spring-framework-api}++/cache/interceptor/CacheAspectSupport.html#IGNORE_REACTIVESTREAMS_PROPERTY_NAME++[`CacheAspectSupport`]
-for details.
-
-| `spring.classformat.ignore`
-| Instructs Spring to ignore class format exceptions during classpath scanning, in
-particular for unsupported class file versions. See
-{spring-framework-api}++/context/annotation/ClassPathScanningCandidateComponentProvider.html#IGNORE_CLASSFORMAT_PROPERTY_NAME++[`ClassPathScanningCandidateComponentProvider`]
-for details.
-
-| `spring.context.checkpoint`
-| Property that specifies a common context checkpoint. See
-xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic checkpoint/restore at startup] and
-{spring-framework-api}++/context/support/DefaultLifecycleProcessor.html#CHECKPOINT_PROPERTY_NAME++[`DefaultLifecycleProcessor`]
-for details.
-
-| `spring.context.exit`
-| Property for terminating the JVM when the context reaches a specific phase. See
-xref:integration/checkpoint-restore.adoc#_automatic_checkpointrestore_at_startup[Automatic checkpoint/restore at startup] and
-{spring-framework-api}++/context/support/DefaultLifecycleProcessor.html#EXIT_PROPERTY_NAME++[`DefaultLifecycleProcessor`]
-for details.
-
-| `spring.context.expression.maxLength`
-| The maximum length for
-xref:core/expressions/evaluation.adoc#expressions-parser-configuration[Spring Expression Language]
-expressions used in XML bean definitions, `@Value`, etc.
-
 | `spring.expression.compiler.mode`
 | The mode to use when compiling expressions for the
 xref:core/expressions/evaluation.adoc#expressions-compiler-configuration[Spring Expression Language].
@@ -291,8 +291,6 @@ to consider:
 * `final` classes cannot be proxied, because they cannot be extended.
 * `final` methods cannot be advised, because they cannot be overridden.
 * `private` methods cannot be advised, because they cannot be overridden.
-* Methods that are not visible, typically package private methods in a parent class
-from a different package, cannot be advised because they are effectively private.

 NOTE: There is no need to add CGLIB to your classpath. CGLIB is repackaged and included
 in the `spring-core` JAR. In other words, CGLIB-based AOP works "out of the box", as do
@@ -168,7 +168,7 @@ Kotlin::
 ======

 NOTE: Pooling stateless service objects is not usually necessary. We do not believe it should
-be the default choice, as most stateless objects are naturally thread-safe, and instance
+be the default choice, as most stateless objects are naturally thread safe, and instance
 pooling is problematic if resources are cached.

 Simpler pooling is available by using auto-proxying. You can set the `TargetSource` implementations
@@ -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 involves a call to
-`ThreadLocal.remove()`) the resource local to the thread. Unsetting should be done in
+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
 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.
@@ -19,10 +19,6 @@ you can do so. However, you should consider the following issues:
  since the CGLIB proxy instance is created through Objenesis. Only if your JVM does
  not allow for constructor bypassing, you might see double invocations and
  corresponding debug log entries from Spring's AOP support.
-* Your CGLIB proxy usage may face limitations with the JDK 9+ platform module system.
-  As a typical case, you cannot create a CGLIB proxy for a class from the `java.lang`
-  package when deploying on the module path. Such cases require a JVM bootstrap flag
-  `--add-opens=java.base/java.lang=ALL-UNNAMED` which is not available for modules.

 To force the use of CGLIB proxies, set the value of the `proxy-target-class` attribute
 of the `<aop:config>` element to true, as follows:
@@ -420,7 +420,7 @@ who typically are in charge of the deployment configuration, such as the launch
 Now that the sales pitch is over, let us first walk through a quick example of AspectJ
 LTW that uses Spring, followed by detailed specifics about elements introduced in the
 example. For a complete example, see the
-{petclinic-github-org}/spring-framework-petclinic[Petclinic sample application based on Spring Framework].
+{spring-github-org}/spring-petclinic[Petclinic sample application].


 [[aop-aj-ltw-first-example]]
@@ -521,8 +521,8 @@ standard AspectJ. The following example shows the `aop.xml` file:
 	<aspectj>

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

 		<aspects>
@@ -533,11 +533,6 @@ standard AspectJ. The following example shows the `aop.xml` file:
 	</aspectj>
 ----

-NOTE: It is recommended to only weave specific classes (typically those in the
-application packages, as shown in the `aop.xml` example above) in order
-to avoid side effects such as AspectJ dump files and warnings.
-This is also a best practice from an efficiency perspective.
-
 Now we can move on to the Spring-specific portion of the configuration. We need
 to configure a `LoadTimeWeaver` (explained later). This load-time weaver is the
 essential component responsible for weaving the aspect configuration in one or
@@ -719,29 +714,10 @@ Furthermore, the compiled aspect classes need to be available on the classpath.


 [[aop-aj-ltw-aop_dot_xml]]
-=== `META-INF/aop.xml`
+=== 'META-INF/aop.xml'

 The AspectJ LTW infrastructure is configured by using one or more `META-INF/aop.xml`
 files that are on the Java classpath (either directly or, more typically, in jar files).
-For example:
-
-[source,xml,indent=0,subs="verbatim"]
----
-	<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "https://www.eclipse.org/aspectj/dtd/aspectj.dtd">
-	<aspectj>
-
-		<weaver>
-			<!-- only weave classes in our application-specific packages and sub-packages -->
-			<include within="com.xyz..*"/>
-		</weaver>
-
-	</aspectj>
----
-
-NOTE: It is recommended to only weave specific classes (typically those in the
-application packages, as shown in the `aop.xml` example above) in order
-to avoid side effects such as AspectJ dump files and warnings.
-This is also a best practice from an efficiency perspective.

 The structure and contents of this file is detailed in the LTW part of the
 {aspectj-docs-devguide}/ltw-configuration.html[AspectJ reference
@@ -15,13 +15,10 @@ Applying such optimizations early implies the following restrictions:

 * The classpath is fixed and fully defined at build time.
 * The beans defined in your application cannot change at runtime, meaning:
-** `@Profile`, in particular profile-specific configuration, needs to be chosen at build time and is automatically enabled at runtime when AOT is enabled.
+** `@Profile`, in particular profile-specific configuration needs to be chosen at build time.
 ** `Environment` properties that impact the presence of a bean (`@Conditional`) are only considered at build time.
-* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time.
-* Beans registered as singletons (using `registerSingleton`, typically from
-`ConfigurableListableBeanFactory`) cannot be transformed ahead-of-time either.
-* As we cannot rely on the instance, make sure that the bean type is as precise as
-possible.
+* Bean definitions with instance suppliers (lambdas or method references) cannot be transformed ahead-of-time (see related {spring-framework-issues}/29555[spring-framework#29555] issue).
+* Make sure that the bean type is as precise as possible.

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

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

 * Java source code
 * Bytecode (usually for dynamic proxies)
-* {spring-framework-api}/aot/hint/RuntimeHints.html[`RuntimeHints`] for the use of reflection, resource loading, serialization, and JDK proxies
+* {spring-framework-api}/aot/hint/RuntimeHints.html[`RuntimeHints`] for the use of reflection, resource loading, serialization, and JDK proxies.

 NOTE: At the moment, AOT is focused on allowing Spring applications to be deployed as native images using GraalVM.
 We intend to support more JVM-based use cases in future generations.

 [[aot.basics]]
-== AOT Engine Overview
+== AOT engine overview

-The entry point of the AOT engine for processing an `ApplicationContext` is `ApplicationContextAotGenerator`. It takes care of the following steps, based on a `GenericApplicationContext` that represents the application to optimize and a {spring-framework-api}/aot/generate/GenerationContext.html[`GenerationContext`]:
+The entry point of the AOT engine for processing an `ApplicationContext` arrangement is `ApplicationContextAotGenerator`. It takes care of the following steps, based on a `GenericApplicationContext` that represents the application to optimize and a {spring-framework-api}/aot/generate/GenerationContext.html[`GenerationContext`]:

 * Refresh an `ApplicationContext` for AOT processing. Contrary to a traditional refresh, this version only creates bean definitions, not bean instances.
 * Invoke the available `BeanFactoryInitializationAotProcessor` implementations and apply their contributions against the `GenerationContext`.
@@ -70,14 +67,7 @@ include-code::./AotProcessingSample[tag=aotcontext]
 In this mode, xref:core/beans/factory-extension.adoc#beans-factory-extension-factory-postprocessors[`BeanFactoryPostProcessor` implementations] are invoked as usual.
 This includes configuration class parsing, import selectors, classpath scanning, etc.
 Such steps make sure that the `BeanRegistry` contains the relevant bean definitions for the application.
-If bean definitions are guarded by conditions (such as `@Profile`), these are evaluated,
-and bean definitions that don't match their conditions are discarded at this stage.
-
-If custom code needs to register extra beans programmatically, make sure that custom
-registration code uses `BeanDefinitionRegistry` instead of `BeanFactory` as only bean
-definitions are taken into account. A good pattern is to implement
-`ImportBeanDefinitionRegistrar` and register it via an `@Import` on one of your
-configuration classes.
+If bean definitions are guarded by conditions (such as `@Profile`), these are discarded at this stage.

 Because this mode does not actually create bean instances, `BeanPostProcessor` implementations are not invoked, except for specific variants that are relevant for AOT processing.
 These are:
@@ -94,12 +84,12 @@ Once this part completes, the `BeanFactory` contains the bean definitions that a
 Components that want to participate in this step can implement the {spring-framework-api}/beans/factory/aot/BeanFactoryInitializationAotProcessor.html[`BeanFactoryInitializationAotProcessor`] interface.
 Each implementation can return an AOT contribution, based on the state of the bean factory.

-An AOT contribution is a component that contributes generated code which reproduces a particular behavior.
+An AOT contribution is a component that contributes generated code that reproduces a particular behavior.
 It can also contribute `RuntimeHints` to indicate the need for reflection, resource loading, serialization, or JDK proxies.

-A `BeanFactoryInitializationAotProcessor` implementation can be registered in `META-INF/spring/aot.factories` with a key equal to the fully-qualified name of the interface.
+A `BeanFactoryInitializationAotProcessor` implementation can be registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.

-The `BeanFactoryInitializationAotProcessor` interface can also be implemented directly by a bean.
+A `BeanFactoryInitializationAotProcessor` can also be implemented directly by a bean.
 In this mode, the bean provides an AOT contribution equivalent to the feature it provides with a regular runtime.
 Consequently, such a bean is automatically excluded from the AOT-optimized context.

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

 * Implemented by a `BeanPostProcessor` bean, to replace its runtime behavior.
 For instance xref:core/beans/factory-extension.adoc#beans-factory-extension-bpp-examples-aabpp[`AutowiredAnnotationBeanPostProcessor`] implements this interface to generate code that injects members annotated with `@Autowired`.
-* Implemented by a type registered in `META-INF/spring/aot.factories` with a key equal to the fully-qualified name of the interface.
+* Implemented by a type registered in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the interface.
 Typically used when the bean definition needs to be tuned for specific features of the core framework.

 [NOTE]
@@ -152,23 +142,8 @@ Java::

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

-WARNING: Kotlin class names with backticks that use invalid Java identifiers (not starting with a letter, containing spaces, etc.) are not supported.
-
 Since there isn't any particular condition on this class, `dataSourceConfiguration` and `dataSource` are identified as candidates.
 The AOT engine will convert the configuration class above to code similar to the following:

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

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

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

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

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

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

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

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

-In case you are working on a code base that you cannot modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.
-
-[[aot.bestpractices.complex-data-structures]]
-=== Avoid Complex Data Structures 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 structures, 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 Beans 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.circular-dependencies]]
-=== Avoid Circular Dependencies
-
-Certain use cases can result in circular dependencies between one or more beans. With the
-regular runtime, it may be possible to wire those circular dependencies via `@Autowired`
-on setter methods or fields. However, an AOT-optimized context will fail to start with
-explicit circular dependencies.
-
-In an AOT-optimized application, you should therefore strive to avoid circular
-dependencies. If that is not possible, you can use `@Lazy` injection points or
-`ObjectProvider` to lazily access or retrieve the necessary collaborating beans. See
-xref:core/beans/classpath-scanning.adoc#beans-factorybeans-annotations-lazy-injection-points[this tip]
-for further information.
+In case you are working on a code base that you can't modify, you can set the {spring-framework-api}/beans/factory/support/AbstractBeanDefinition.html#PREFERRED_CONSTRUCTORS_ATTRIBUTE[`preferredConstructors` attribute] on the related bean definition to indicate which constructor should be used.

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

 Running an application as a native image requires additional information compared to a regular JVM runtime.
 For instance, GraalVM needs to know ahead of time if a component uses reflection.
-Similarly, classpath resources are not included in a native image unless specified explicitly.
+Similarly, classpath resources are not shipped in a native image unless specified explicitly.
 Consequently, if the application needs to load a resource, it must be referenced from the corresponding GraalVM native image configuration file.

 The {spring-framework-api}/aot/hint/RuntimeHints.html[`RuntimeHints`] API collects the need for reflection, resource loading, serialization, and JDK proxies at runtime.
@@ -514,7 +415,7 @@ include-code::./SpellCheckService[]
 If at all possible, `@ImportRuntimeHints` should be used as close as possible to the component that requires the hints.
 This way, if the component is not contributed to the `BeanFactory`, the hints won't be contributed either.

-It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equal to the fully-qualified name of the `RuntimeHintsRegistrar` interface.
+It is also possible to register an implementation statically by adding an entry in `META-INF/spring/aot.factories` with a key equal to the fully qualified name of the `RuntimeHintsRegistrar` interface.


 [[aot.hints.reflective]]
@@ -523,7 +424,7 @@ It is also possible to register an implementation statically by adding an entry
 {spring-framework-api}/aot/hint/annotation/Reflective.html[`@Reflective`] provides an idiomatic way to flag the need for reflection on an annotated element.
 For instance, `@EventListener` is meta-annotated with `@Reflective` since the underlying implementation invokes the annotated method using reflection.

-By default, only Spring beans are considered, and an invocation hint is registered for the annotated element.
+By default, only Spring beans are considered and an invocation hint is registered for the annotated element.
 This can be tuned by specifying a custom `ReflectiveProcessor` implementation via the
 `@Reflective` annotation.

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

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

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

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

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

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -153,15 +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 (either by bean name or by associated alias).
-
-Since version 6.1, this requires the `-parameters` Java compiler flag to be present.
+(that is, the field name or parameter name) against the target bean names and chooses the
+same-named candidate, if any.
 ====

-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
+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
 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).
@@ -186,15 +186,6 @@ implementation type, consider declaring the most specific return type on your fa
 method (at least as specific as required by the injection points referring to your bean).
 ====

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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



+
@@ -317,8 +317,8 @@ exposed based on security policies in some environments -- for example, standalo
 JDK 1.7.0_45 and higher (which requires 'Trusted-Library' setup in your manifests -- see
 {stackoverflow-questions}/19394570/java-jre-7u45-breaks-classloader-getresources).

-On the module path (Java Module System), Spring's classpath scanning generally works as
-expected. However, make sure that your component classes are exported in your `module-info`
+On JDK 9's module path (Jigsaw), Spring's classpath scanning generally works as expected.
+However, make sure that your component classes are exported in your `module-info`
 descriptors. If you expect Spring to invoke non-public members of your classes, make
 sure that they are 'opened' (that is, that they use an `opens` declaration instead of an
 `exports` declaration in your `module-info` descriptor).
@@ -480,15 +480,11 @@ factory method and other bean definition properties, such as a qualifier value t
 the `@Qualifier` annotation. Other method-level annotations that can be specified are
 `@Scope`, `@Lazy`, and custom qualifier annotations.

-[[beans-factorybeans-annotations-lazy-injection-points]]
-[TIP]
-====
-In addition to its role for component initialization, you can also place the `@Lazy`
+TIP: In addition to its role for component initialization, you can also place the `@Lazy`
 annotation on injection points marked with `@Autowired` or `@Inject`. In this context,
 it leads to the injection of a lazy-resolution proxy. However, such a proxy approach
 is rather limited. For sophisticated lazy interactions, in particular in combination
 with optional dependencies, we recommend `ObjectProvider<MyTargetBean>` instead.
-====

 Autowired fields and methods are supported, as previously discussed, with additional
 support for autowiring of `@Bean` methods. The following example shows how to do so:
@@ -755,7 +751,7 @@ and bean definition show.
 TIP: If you run into naming conflicts due to multiple autodetected components having the
 same non-qualified class name (i.e., classes with identical names but residing in
 different packages), you may need to configure a `BeanNameGenerator` that defaults to the
-fully qualified class name for the generated bean name. The
+fully qualified class name for the generated bean name. As of Spring Framework 5.2.3, the
 `FullyQualifiedAnnotationBeanNameGenerator` located in package
 `org.springframework.context.annotation` can be used for such purposes.

@@ -924,8 +920,7 @@ Kotlin::
 [[beans-scanning-qualifiers]]
 == Providing Qualifier Metadata with Annotations

-The `@Qualifier` annotation is discussed in
-xref:core/beans/annotation-config/autowired-qualifiers.adoc[Fine-tuning Annotation-based Autowiring with Qualifiers].
+The `@Qualifier` annotation is discussed in xref:core/beans/annotation-config/autowired-qualifiers.adoc[Fine-tuning Annotation-based Autowiring with Qualifiers].
 The examples in that section demonstrate the use of the `@Qualifier` annotation and
 custom qualifier annotations to provide fine-grained control when you resolve autowire
 candidates. Because those examples were based on XML bean definitions, the qualifier
@@ -1,7 +1,7 @@
 [[context-introduction]]
 = Additional Capabilities of the `ApplicationContext`

-As discussed in the xref:core/beans/introduction.adoc[chapter introduction], the `org.springframework.beans.factory`
+As discussed in the xref:web/webmvc-view/mvc-xslt.adoc#mvc-view-xslt-beandefs[chapter introduction], the `org.springframework.beans.factory`
 package provides basic functionality for managing and manipulating beans, including in a
 programmatic way. The `org.springframework.context` package adds the
 {spring-framework-api}/context/ApplicationContext.html[`ApplicationContext`]
@@ -644,7 +644,7 @@ Each `SpEL` expression evaluates against a dedicated context. The following tabl
 items made available to the context so that you can use them for conditional event processing:

 [[context-functionality-events-annotation-tbl]]
-.Event metadata available in SpEL expressions
+.Event SpEL available metadata
 |===
 | Name| Location| Description| Example

@@ -660,8 +660,8 @@ items made available to the context so that you can use them for conditional eve

 | __Argument name__
 | evaluation context
-| The name of a particular method argument. If the names are not available
-  (for example, because the code was compiled without the `-parameters` flag), individual
+| The name of any of the method arguments. If, for some reason, the names are not available
+  (for example, because there is no debug information in the compiled byte code), individual
  arguments are also available using the `#a<#arg>` syntax where `<#arg>` stands for the
  argument index (starting from 0).
 | `#blEvent` or `#a0` (you can also use `#p0` or `#p<#arg>` parameter notation as an alias)
@@ -883,12 +883,11 @@ e.g. for processing all events asynchronously and/or for handling listener excep
 == Convenient Access to Low-level Resources

 For optimal usage and understanding of application contexts, you should familiarize
-yourself with Spring's `Resource` abstraction, as described in
-xref:core/resources.adoc[Resources].
+yourself with Spring's `Resource` abstraction, as described in xref:web/webflux-webclient/client-builder.adoc#webflux-client-builder-reactor-resources[Resources].

 An application context is a `ResourceLoader`, which can be used to load `Resource` objects.
 A `Resource` is essentially a more feature rich version of the JDK `java.net.URL` class.
-In fact, implementations of `Resource` wrap an instance of `java.net.URL`, where
+In fact, the implementations of the `Resource` wrap an instance of `java.net.URL`, where
 appropriate. A `Resource` can obtain low-level resources from almost any location in a
 transparent fashion, including from the classpath, a filesystem location, anywhere
 describable with a standard URL, and some other variations. If the resource location
@@ -75,31 +75,6 @@ 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

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

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

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

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

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

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

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


+
+
@@ -60,7 +60,6 @@ instance's values consist of all bean instances that match the expected type, an
 `Map` instance's keys contain the corresponding bean names.


-
 [[beans-autowired-exceptions]]
 == Limitations and Disadvantages of Autowiring

@@ -102,10 +101,10 @@ In the latter scenario, you have several options:
 == Excluding a Bean from Autowiring

 On a per-bean basis, you can exclude a bean from autowiring. In Spring's XML format, set
-the `autowire-candidate` attribute of the `<bean/>` element to `false`; with the `@Bean`
-annotation, the attribute is named `autowireCandidate`. The container makes that specific
-bean definition unavailable to the autowiring infrastructure, including annotation-based
-injection points such as xref:core/beans/annotation-config/autowired.adoc[`@Autowired`].
+the `autowire-candidate` attribute of the `<bean/>` element to `false`. The container
+makes that specific bean definition unavailable to the autowiring infrastructure
+(including annotation style configurations such as xref:core/beans/annotation-config/autowired.adoc[`@Autowired`]
+).

 NOTE: The `autowire-candidate` attribute is designed to only affect type-based autowiring.
 It does not affect explicit references by name, which get resolved even if the
@@ -120,8 +119,8 @@ provide multiple patterns, define them in a comma-separated list. An explicit va
 `true` or `false` for a bean definition's `autowire-candidate` attribute always takes
 precedence. For such beans, the pattern matching rules do not apply.

-These techniques are useful for beans that you never want to be injected into other beans
-by autowiring. It does not mean that an excluded bean cannot itself be configured by
+These techniques are useful for beans that you never want to be injected into other
+beans by autowiring. It does not mean that an excluded bean cannot itself be configured by
 using autowiring. Rather, the bean itself is not a candidate for autowiring other beans.


@@ -159,12 +159,10 @@ Kotlin::
 ----
 ======

-[discrete]
-[[beans-factory-ctor-arguments-type]]
-==== Constructor argument type matching
-
+.[[beans-factory-ctor-arguments-type]]Constructor argument type matching
+--
 In the preceding scenario, the container can use type matching with simple types if
-you explicitly specify the type of the constructor argument via the `type` attribute,
+you explicitly specify the type of the constructor argument by using the `type` attribute,
 as the following example shows:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -174,11 +172,10 @@ as the following example shows:
 		<constructor-arg type="java.lang.String" value="42"/>
 	</bean>
 ----
+--

-[discrete]
-[[beans-factory-ctor-arguments-index]]
-==== Constructor argument index
-
+.[[beans-factory-ctor-arguments-index]]Constructor argument index
+--
 You can use the `index` attribute to specify explicitly the index of constructor arguments,
 as the following example shows:

@@ -194,11 +191,10 @@ In addition to resolving the ambiguity of multiple simple values, specifying an
 resolves ambiguity where a constructor has two arguments of the same type.

 NOTE: The index is 0-based.
+--

-[discrete]
-[[beans-factory-ctor-arguments-name]]
-==== Constructor argument name
-
+.[[beans-factory-ctor-arguments-name]]Constructor argument name
+--
 You can also use the constructor parameter name for value disambiguation, as the following
 example shows:

@@ -211,8 +207,8 @@ example shows:
 ----

 Keep in mind that, to make this work out of the box, your code must be compiled with the
-`-parameters` flag enabled so that Spring can look up the parameter name from the constructor.
-If you cannot or do not want to compile your code with the `-parameters` flag, you can use the
+debug flag enabled so that Spring can look up the parameter name from the constructor.
+If you cannot or do not want to compile your code with the debug flag, you can use the
 https://download.oracle.com/javase/8/docs/api/java/beans/ConstructorProperties.html[@ConstructorProperties]
 JDK annotation to explicitly name your constructor arguments. The sample class would
 then have to look as follows:
@@ -248,6 +244,7 @@ Kotlin::
 	constructor(val years: Int, val ultimateAnswer: String)
 ----
 ======
+--


 [[beans-setter-injection]]
@@ -2,15 +2,13 @@
 = Using `depends-on`

 If a bean is a dependency of another bean, that usually means that one bean is set as a
-property of another. Typically you accomplish this with the
-xref:core/beans/dependencies/factory-properties-detailed.adoc#beans-ref-element[`<ref/>` element>]
-in XML-based metadata or through xref:core/beans/dependencies/factory-autowire.adoc[autowiring].
-
-However, sometimes dependencies between beans are less direct. An example is when a static
-initializer in a class needs to be triggered, such as for database driver registration.
-The `depends-on` attribute or `@DependsOn` annotation can explicitly force one or more beans
-to be initialized before the bean using this element is initialized. The following example
-uses the `depends-on` attribute to express a dependency on a single bean:
+property of another. Typically you accomplish this with the <<beans-ref-element, `<ref/>`
+element>> in XML-based configuration metadata. However, sometimes dependencies between
+beans are less direct. An example is when a static initializer in a class needs to be
+triggered, such as for database driver registration. The `depends-on` attribute can
+explicitly force one or more beans to be initialized before the bean using this element
+is initialized. The following example uses the `depends-on` attribute to express a
+dependency on a single bean:

 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
@@ -33,10 +31,10 @@ delimiters):
 ----

 NOTE: The `depends-on` attribute can specify both an initialization-time dependency and,
-in the case of xref:core/beans/factory-scopes.adoc#beans-factory-scopes-singleton[singleton]
-beans only, a corresponding destruction-time dependency. Dependent beans that define a
-`depends-on` relationship with a given bean are destroyed first, prior to the given bean
-itself being destroyed. Thus, `depends-on` can also control shutdown order.
+in the case of xref:core/beans/factory-scopes.adoc#beans-factory-scopes-singleton[singleton] beans only, a corresponding
+destruction-time dependency. Dependent beans that define a `depends-on` relationship
+with a given bean are destroyed first, prior to the given bean itself being destroyed.
+Thus, `depends-on` can also control shutdown order.



@@ -120,6 +120,8 @@ dynamically generate a subclass that overrides the method.
  subclasses cannot be `final`, and the method to be overridden cannot be `final`, either.
 * Unit-testing a class that has an `abstract` method requires you to subclass the class
  yourself and to supply a stub implementation of the `abstract` method.
+* Concrete methods are also necessary for component scanning, which requires concrete
+  classes to pick up.
 * A further key limitation is that lookup methods do not work with factory methods and
  in particular not with `@Bean` methods in configuration classes, since, in that case,
  the container is not in charge of creating the instance and therefore cannot create
@@ -199,7 +201,7 @@ the original class. Consider the following example:
 		<!-- inject dependencies here as required -->
 	</bean>

-	<!-- commandManager uses myCommand prototype bean -->
+	<!-- commandProcessor uses statefulCommandHelper -->
 	<bean id="commandManager" class="fiona.apple.CommandManager">
 		<lookup-method name="createCommand" bean="myCommand"/>
 	</bean>
@@ -291,6 +293,11 @@ Kotlin::
 ----
 ======

+Note that you should typically declare such annotated lookup methods with a concrete
+stub implementation, in order for them to be compatible with Spring's component
+scanning rules where abstract classes get ignored by default. This limitation does not
+apply to explicitly registered or explicitly imported bean classes.
+
 [TIP]
 ====
 Another way of accessing differently scoped target beans is an `ObjectFactory`/
@@ -102,8 +102,8 @@ following snippet:
 ----
 	<bean id="theTargetBean" class="..." />

-	<bean id="theClientBean" class="...">
-		<property name="targetName" ref="theTargetBean"/>
+	<bean id="client" class="...">
+		<property name="targetName" value="theTargetBean"/>
 	</bean>
 ----

@@ -582,7 +582,7 @@ it needs to be declared in the XML file even though it is not defined in an XSD
 (it exists inside the Spring core).

 For the rare cases where the constructor argument names are not available (usually if
-the bytecode was compiled without the `-parameters` flag), you can fall back to the
+the bytecode was compiled without debugging information), you can use fallback to the
 argument indexes, as follows:

 [source,xml,indent=0,subs="verbatim,quotes"]
@@ -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 `driverClassName` and `url` properties.
+`dataSource` that has `driver` 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
@@ -592,40 +592,6 @@ Kotlin::



-[[beans-factory-thread-safety]]
-=== Thread Safety and Visibility
-
-The Spring core container publishes created singleton instances in a thread-safe manner,
-guarding access through a singleton lock and guaranteeing visibility in other threads.
-
-As a consequence, application-provided bean classes do not have to be concerned about the
-visibility of their initialization state. Regular configuration fields do not have to be
-marked as `volatile` as long as they are only mutated during the initialization phase,
-providing visibility guarantees similar to `final` even for setter-based configuration
-state that is mutable during that initial phase. If such fields get changed after the
-bean creation phase and its subsequent initial publication, they need to be declared as
-`volatile` or guarded by a common lock whenever accessed.
-
-Note that concurrent access to such configuration state in singleton bean instances,
-e.g. for controller instances or repository instances, is perfectly thread-safe after
-such safe initial publication from the container side. This includes common singleton
-`FactoryBean` instances which are processed within the general singleton lock as well.
-
-For destruction callbacks, the configuration state remains thread-safe but any runtime
-state accumulated between initialization and destruction should be kept in thread-safe
-structures (or in `volatile` fields for simple cases) as per common Java guidelines.
-
-Deeper `Lifecycle` integration as shown above involves runtime-mutable state such as
-a `runnable` field which will have to be declared as `volatile`. While the common
-lifecycle callbacks follow a certain order, e.g. a start callback is guaranteed to
-only happen after full initialization and a stop callback only after an initial start,
-there is a special case with the common stop before destroy arrangement: It is strongly
-recommended that the internal state in any such bean also allows for an immediate
-destroy callback without a preceding stop since this may happen during an extraordinary
-shutdown after a cancelled bootstrap or in case of a stop timeout caused by another bean.
-
-
-
 [[beans-factory-aware]]
 == `ApplicationContextAware` and `BeanNameAware`

@@ -324,6 +324,7 @@ Kotlin::



+
 [[beans-factory-scopes-application]]
 === Application Scope

@@ -373,6 +374,7 @@ Kotlin::



+
 [[beans-factory-scopes-websocket]]
 === WebSocket Scope

@@ -382,6 +384,7 @@ xref:web/websocket/stomp/scope.adoc[WebSocket scope] for more details.



+
 [[beans-factory-scopes-other-injection]]
 === Scoped Beans as Dependencies

@@ -541,19 +544,6 @@ see xref:core/aop/proxying.adoc[Proxying Mechanisms].



-[[beans-factory-scopes-injection]]
-=== Injecting Request/Session References Directly
-
-As an alternative to factory scopes, a Spring `WebApplicationContext` also supports
-the injection of `HttpServletRequest`, `HttpServletResponse`, `HttpSession`,
-`WebRequest` and (if JSF is present) `FacesContext` and `ExternalContext` into
-Spring-managed beans, simply through type-based autowiring next to regular injection
-points for other beans. Spring generally injects proxies for such request and session
-objects which has the advantage of working in singleton beans and serializable beans
-as well, similar to scoped proxies for factory-scoped beans.
-
-
-
 [[beans-factory-scopes-custom]]
 == Custom Scopes

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

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

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

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


@@ -116,7 +116,7 @@ the configuration model, in that references to other beans must be valid Java sy
 Fortunately, solving this problem is simple. As
 xref:core/beans/java/bean-annotation.adoc#beans-java-dependencies[we already discussed],
 a `@Bean` method can have an arbitrary number of parameters that describe the bean
-dependencies. Consider the following more realistic scenario with several `@Configuration`
+dependencies. Consider the following more real-world scenario with several `@Configuration`
 classes, each depending on beans declared in the others:

 [tabs]
@@ -331,10 +331,8 @@ TIP: Constructor injection in `@Configuration` classes is only supported as of S
 Framework 4.3. Note also that there is no need to specify `@Autowired` if the target
 bean defines only one constructor.

-[discrete]
-[[beans-java-injecting-imported-beans-fq]]
-==== Fully-qualifying imported beans for ease of navigation
-
+.[[beans-java-injecting-imported-beans-fq]]Fully-qualifying imported beans for ease of navigation
+--
 In the preceding scenario, using `@Autowired` works well and provides the desired
 modularity, but determining exactly where the autowired bean definitions are declared is
 still somewhat ambiguous. For example, as a developer looking at `ServiceConfig`, how do
@@ -503,6 +501,7 @@ Now `ServiceConfig` is loosely coupled with respect to the concrete
 get a type hierarchy of `RepositoryConfig` implementations. In this
 way, navigating `@Configuration` classes and their dependencies becomes no different
 than the usual process of navigating interface-based code.
+--

 TIP: If you want to influence the startup creation order of certain beans, consider
 declaring some of them as `@Lazy` (for creation on first access instead of on startup)
@@ -541,7 +540,7 @@ Java::
 		MultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.class.getName());
 		if (attrs != null) {
 			for (Object value : attrs.get("value")) {
-				if (context.getEnvironment().matchesProfiles((String[]) value)) {
+				if (context.getEnvironment().acceptsProfiles(((String[]) value))) {
 					return true;
 				}
 			}
@@ -560,7 +559,7 @@ Kotlin::
 		val attrs = metadata.getAllAnnotationAttributes(Profile::class.java.name)
 		if (attrs != null) {
 			for (value in attrs["value"]!!) {
-				if (context.environment.matchesProfiles(*value as Array<String>)) {
+				if (context.environment.acceptsProfiles(Profiles.of(*value as Array<String>))) {
 					return true
 				}
 			}
@@ -595,18 +594,16 @@ that uses Spring XML, it is easier to create `@Configuration` classes on an
 as-needed basis and include them from the existing XML files. Later in this section, we cover the
 options for using `@Configuration` classes in this kind of "`XML-centric`" situation.

-[discrete]
-[[beans-java-combining-xml-centric-declare-as-bean]]
-==== Declaring `@Configuration` classes as plain Spring `<bean/>` elements
-
-Remember that `@Configuration` classes are ultimately bean definitions in the container.
-In this series of examples, we create a `@Configuration` class named `AppConfig` and
+.[[beans-java-combining-xml-centric-declare-as-bean]]Declaring `@Configuration` classes as plain Spring `<bean/>` elements
+--
+Remember that `@Configuration` classes are ultimately bean definitions in the
+container. In this series examples, we create a `@Configuration` class named `AppConfig` and
 include it within `system-test-config.xml` as a `<bean/>` definition. Because
 `<context:annotation-config/>` is switched on, the container recognizes the
 `@Configuration` annotation and processes the `@Bean` methods declared in `AppConfig`
 properly.

-The following example shows the `AppConfig` configuration class in Java and Kotlin:
+The following example shows an ordinary configuration class in Java:

 [tabs]
 ======
@@ -627,7 +624,7 @@ Java::

 		@Bean
 		public TransferService transferService() {
-			return new TransferServiceImpl(accountRepository());
+			return new TransferService(accountRepository());
 		}
 	}
 ----
@@ -660,7 +657,6 @@ The following example shows part of a sample `system-test-config.xml` file:
 	<beans>
 		<!-- enable processing of annotations such as @Autowired and @Configuration -->
 		<context:annotation-config/>
-
 		<context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>

 		<bean class="com.acme.AppConfig"/>
@@ -707,20 +703,20 @@ Kotlin::
 ----
 ======

-NOTE: In the `system-test-config.xml` file, the `AppConfig` `<bean/>` does not declare an `id`
-attribute. While it would be acceptable to do so, it is unnecessary, given that no other bean
+
+NOTE: In `system-test-config.xml` file, the `AppConfig` `<bean/>` does not declare an `id`
+element. While it would be acceptable to do so, it is unnecessary, given that no other bean
 ever refers to it, and it is unlikely to be explicitly fetched from the container by name.
 Similarly, the `DataSource` bean is only ever autowired by type, so an explicit bean `id`
 is not strictly required.
+--

-[discrete]
-[[beans-java-combining-xml-centric-component-scan]]
-==== Using <context:component-scan/> to pick up `@Configuration` classes
-
+.[[beans-java-combining-xml-centric-component-scan]] Using <context:component-scan/> to pick up `@Configuration` classes
+--
 Because `@Configuration` is meta-annotated with `@Component`, `@Configuration`-annotated
 classes are automatically candidates for component scanning. Using the same scenario as
-described in the previous example, we can redefine `system-test-config.xml` to take
-advantage of component-scanning. Note that, in this case, we need not explicitly declare
+described in the previous example, we can redefine `system-test-config.xml` to take advantage of component-scanning.
+Note that, in this case, we need not explicitly declare
 `<context:annotation-config/>`, because `<context:component-scan/>` enables the same
 functionality.

@@ -731,7 +727,6 @@ The following example shows the modified `system-test-config.xml` file:
 	<beans>
 		<!-- picks up and registers AppConfig as a bean definition -->
 		<context:component-scan base-package="com.acme"/>
-
 		<context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>

 		<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">
@@ -741,17 +736,19 @@ The following example shows the modified `system-test-config.xml` file:
 		</bean>
 	</beans>
 ----
+--

 [[beans-java-combining-java-centric]]
 === `@Configuration` Class-centric Use of XML with `@ImportResource`

 In applications where `@Configuration` classes are the primary mechanism for configuring
-the container, it may still be necessary to use at least some XML. In such scenarios, you
-can use `@ImportResource` and define only as much XML as you need. Doing so achieves a
-"`Java-centric`" approach to configuring the container and keeps XML to a bare minimum.
-The following example (which includes a configuration class, an XML file that defines a
-bean, a properties file, and the `main()` method) shows how to use the `@ImportResource`
-annotation to achieve "`Java-centric`" configuration that uses XML as needed:
+the container, it is still likely necessary to use at least some XML. In these
+scenarios, you can use `@ImportResource` and define only as much XML as you need. Doing
+so achieves a "`Java-centric`" approach to configuring the container and keeps XML to a
+bare minimum. The following example (which includes a configuration class, an XML file
+that defines a bean, a properties file, and the `main` class) shows how to use
+the `@ImportResource` annotation to achieve "`Java-centric`" configuration that uses XML
+as needed:

 [tabs]
 ======
@@ -776,17 +773,6 @@ Java::
 		public DataSource dataSource() {
 			return new DriverManagerDataSource(url, username, password);
 		}
-
-		@Bean
-		public AccountRepository accountRepository(DataSource dataSource) {
-			return new JdbcAccountRepository(dataSource);
-		}
-
-		@Bean
-		public TransferService transferService(AccountRepository accountRepository) {
-			return new TransferServiceImpl(accountRepository);
-		}
-
 	}
 ----

@@ -811,32 +797,21 @@ Kotlin::
 		fun dataSource(): DataSource {
 			return DriverManagerDataSource(url, username, password)
 		}
-
-		@Bean
-		fun accountRepository(dataSource: DataSource): AccountRepository {
-			return JdbcAccountRepository(dataSource)
-		}
-
-		@Bean
-		fun transferService(accountRepository: AccountRepository): TransferService {
-			return TransferServiceImpl(accountRepository)
-		}
-
 	}
 ----
 ======

-.properties-config.xml
 [source,xml,indent=0,subs="verbatim,quotes"]
 ----
+	properties-config.xml
 	<beans>
 		<context:property-placeholder location="classpath:/com/acme/jdbc.properties"/>
 	</beans>
 ----

-.jdbc.properties
 [literal,subs="verbatim,quotes"]
 ----
+jdbc.properties
 jdbc.url=jdbc:hsqldb:hsql://localhost/xdb
 jdbc.username=sa
 jdbc.password=
@@ -869,3 +844,5 @@ Kotlin::
 ----
 ======

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

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

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

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

+
+
+
@@ -1,12 +1,12 @@
 [[expressions-evaluation]]
 = Evaluation

-This section introduces programmatic use of SpEL's interfaces and its expression language.
-The complete language reference can be found in the
+This section introduces the simple use of SpEL interfaces and its expression language.
+The complete language reference can be found in
 xref:core/expressions/language-ref.adoc[Language Reference].

-The following code demonstrates how to use the SpEL API to evaluate the literal string
-expression, `Hello World`.
+The following code introduces the SpEL API to evaluate the literal string expression,
+`Hello World`.

 [tabs]
 ======
@@ -18,7 +18,7 @@ Java::
 	Expression exp = parser.parseExpression("'Hello World'"); // <1>
 	String message = (String) exp.getValue();
 ----
-<1> The value of the message variable is `"Hello World"`.
+<1> The value of the message variable is `'Hello World'`.

 Kotlin::
 +
@@ -28,24 +28,24 @@ Kotlin::
 	val exp = parser.parseExpression("'Hello World'") // <1>
 	val message = exp.value as String
 ----
-<1> The value of the message variable is `"Hello World"`.
+<1> The value of the message variable is `'Hello World'`.
 ======

+
 The SpEL classes and interfaces you are most likely to use are located in the
 `org.springframework.expression` package and its sub-packages, such as `spel.support`.

-The `ExpressionParser` interface is responsible for parsing an expression string. In the
-preceding example, the expression string is a string literal denoted by the surrounding
-single quotation marks. The `Expression` interface is responsible for evaluating the
-defined expression string. The two types of exceptions that can be thrown when calling
-`parser.parseExpression(...)` and `exp.getValue(...)` are `ParseException` and
-`EvaluationException`, respectively.
+The `ExpressionParser` interface is responsible for parsing an expression string. In
+the preceding example, the expression string is a string literal denoted by the surrounding single
+quotation marks. The `Expression` interface is responsible for evaluating the previously defined
+expression string. Two exceptions that can be thrown, `ParseException` and
+`EvaluationException`, when calling `parser.parseExpression` and `exp.getValue`,
+respectively.

-SpEL supports a wide range of features such as calling methods, accessing properties,
+SpEL supports a wide range of features, such as calling methods, accessing properties,
 and calling constructors.

-In the following method invocation example, we call the `concat` method on the string
-literal, `Hello World`.
+In the following example of method invocation, we call the `concat` method on the string literal:

 [tabs]
 ======
@@ -57,7 +57,7 @@ Java::
 	Expression exp = parser.parseExpression("'Hello World'.concat('!')"); // <1>
 	String message = (String) exp.getValue();
 ----
-<1> The value of `message` is now `"Hello World!"`.
+<1> The value of `message` is now 'Hello World!'.

 Kotlin::
 +
@@ -67,11 +67,10 @@ Kotlin::
 	val exp = parser.parseExpression("'Hello World'.concat('!')") // <1>
 	val message = exp.value as String
 ----
-<1> The value of `message` is now `"Hello World!"`.
+<1> The value of `message` is now 'Hello World!'.
 ======

-The following example demonstrates how to access the `Bytes` JavaBean property of the
-string literal, `Hello World`.
+The following example of calling a JavaBean property calls the `String` property `Bytes`:

 [tabs]
 ======
@@ -101,10 +100,10 @@ Kotlin::
 ======

 SpEL also supports nested properties by using the standard dot notation (such as
-`prop1.prop2.prop3`) as well as the corresponding setting of property values.
+`prop1.prop2.prop3`) and also the corresponding setting of property values.
 Public fields may also be accessed.

-The following example shows how to use dot notation to get the length of a string literal.
+The following example shows how to use dot notation to get the length of a literal:

 [tabs]
 ======
@@ -134,7 +133,7 @@ Kotlin::
 ======

 The String's constructor can be called instead of using a string literal, as the following
-example shows.
+example shows:

 [tabs]
 ======
@@ -146,7 +145,7 @@ Java::
 	Expression exp = parser.parseExpression("new String('hello world').toUpperCase()"); // <1>
 	String message = exp.getValue(String.class);
 ----
-<1> Construct a new `String` from the literal and convert it to upper case.
+<1> Construct a new `String` from the literal and make it be upper case.

 Kotlin::
 +
@@ -156,9 +155,10 @@ Kotlin::
 	val exp = parser.parseExpression("new String('hello world').toUpperCase()")  // <1>
 	val message = exp.getValue(String::class.java)
 ----
-<1> Construct a new `String` from the literal and convert it to upper case.
+<1> Construct a new `String` from the literal and make it be upper case.
 ======

+
 Note the use of the generic method: `public <T> T getValue(Class<T> desiredResultType)`.
 Using this method removes the need to cast the value of the expression to the desired
 result type. An `EvaluationException` is thrown if the value cannot be cast to the
@@ -166,8 +166,8 @@ type `T` or converted by using the registered type converter.

 The more common usage of SpEL is to provide an expression string that is evaluated
 against a specific object instance (called the root object). The following example shows
-how to retrieve the `name` property from an instance of the `Inventor` class and how to
-reference the `name` property in a boolean expression.
+how to retrieve the `name` property from an instance of the `Inventor` class or
+create a boolean condition:

 [tabs]
 ======
@@ -222,38 +222,29 @@ Kotlin::
 [[expressions-evaluation-context]]
 == Understanding `EvaluationContext`

-The `EvaluationContext` API is used when evaluating an expression to resolve properties,
-methods, or fields and to help perform type conversion. Spring provides two
+The `EvaluationContext` interface is used when evaluating an expression to resolve
+properties, methods, or fields and to help perform type conversion. Spring provides two
 implementations.

-`SimpleEvaluationContext`::
-  Exposes a subset of essential SpEL language features and configuration options, for
-  categories of expressions that do not require the full extent of the SpEL language
-  syntax and should be meaningfully restricted. Examples include but are not limited to
-  data binding expressions and property-based filters.
+* `SimpleEvaluationContext`: Exposes a subset of essential SpEL language features and
+configuration options, for categories of expressions that do not require the full extent
+of the SpEL language syntax and should be meaningfully restricted. Examples include but
+are not limited to data binding expressions and property-based filters.

-`StandardEvaluationContext`::
-  Exposes the full set of SpEL language features and configuration options. You can use
-  it to specify a default root object and to configure every available evaluation-related
-  strategy.
+* `StandardEvaluationContext`: Exposes the full set of SpEL language features and
+configuration options. You can use it to specify a default root object and to configure
+every available evaluation-related strategy.

-`SimpleEvaluationContext` is designed to support only a subset of the SpEL language
-syntax. For example, it excludes Java type references, constructors, and bean references.
-It also requires you to explicitly choose the level of support for properties and methods
-in expressions. When creating a `SimpleEvaluationContext` you need to choose the level of
-support that you need for data binding in SpEL expressions:
+`SimpleEvaluationContext` is designed to support only a subset of the SpEL language syntax.
+It excludes Java type references, constructors, and bean references. It also requires
+you to explicitly choose the level of support for properties and methods in expressions.
+By default, the `create()` static factory method enables only read access to properties.
+You can also obtain a builder to configure the exact level of support needed, targeting
+one or some combination of the following:

-* Data binding for read-only access
-* Data binding for read and write access
-* A custom `PropertyAccessor` (typically not reflection-based), potentially combined with
-  a `DataBindingPropertyAccessor`
-
-Conveniently, `SimpleEvaluationContext.forReadOnlyDataBinding()` enables read-only access
-to properties via `DataBindingPropertyAccessor`. Similarly,
-`SimpleEvaluationContext.forReadWriteDataBinding()` enables read and write access to
-properties. Alternatively, configure custom accessors via
-`SimpleEvaluationContext.forPropertyAccessors(...)`, potentially disable assignment, and
-optionally activate method resolution and/or a type converter through the builder.
+* Custom `PropertyAccessor` only (no reflection)
+* Data binding properties for read-only access
+* Data binding properties for read and write


 [[expressions-type-conversion]]
@@ -261,15 +252,16 @@ optionally activate method resolution and/or a type converter through the builde

 By default, SpEL uses the conversion service available in Spring core
 (`org.springframework.core.convert.ConversionService`). This conversion service comes
-with many built-in converters for common conversions, but is also fully extensible so
-that you can add custom conversions between types. Additionally, it is generics-aware.
-This means that, when you work with generic types in expressions, SpEL attempts
-conversions to maintain type correctness for any objects it encounters.
+with many built-in converters for common conversions but is also fully extensible so that
+you can add custom conversions between types. Additionally, it is
+generics-aware. This means that, when you work with generic types in
+expressions, SpEL attempts conversions to maintain type correctness for any objects
+it encounters.

 What does this mean in practice? Suppose assignment, using `setValue()`, is being used
 to set a `List` property. The type of the property is actually `List<Boolean>`. SpEL
 recognizes that the elements of the list need to be converted to `Boolean` before
-being placed in it. The following example shows how to do so.
+being placed in it. The following example shows how to do so:

 [tabs]
 ======
@@ -323,17 +315,17 @@ Kotlin::
 It is possible to configure the SpEL expression parser by using a parser configuration
 object (`org.springframework.expression.spel.SpelParserConfiguration`). The configuration
 object controls the behavior of some of the expression components. For example, if you
-index into a collection and the element at the specified index is `null`, SpEL can
-automatically create the element. This is useful when using expressions made up of a
-chain of property references. Similarly, if you index into a collection and specify an
-index that is greater than the current size of the collection, SpEL can automatically
-grow the collection to accommodate that index. In order to add an element at the
+index into an array or collection and the element at the specified index is `null`, SpEL
+can automatically create the element. This is useful when using expressions made up of a
+chain of property references. If you index into an array or list and specify an index
+that is beyond the end of the current size of the array or list, SpEL can automatically
+grow the array or list to accommodate that index. In order to add an element at the
 specified index, SpEL will try to create the element using the element type's default
 constructor before setting the specified value. If the element type does not have a
-default constructor, `null` will be added to the collection. If there is no built-in
-converter or custom converter that knows how to set the value, `null` will remain in the
-collection at the specified index. The following example demonstrates how to
-automatically grow a `List`.
+default constructor, `null` will be added to the array or list. If there is no built-in
+or custom converter that knows how to set the value, `null` will remain in the array or
+list at the specified index. The following example demonstrates how to automatically grow
+the list:

 [tabs]
 ======
@@ -388,25 +380,16 @@ Kotlin::
 ----
 ======

-By default, a SpEL expression cannot contain more than 10,000 characters; however, the
-`maxExpressionLength` is configurable. If you create a `SpelExpressionParser`
-programmatically, you can specify a custom `maxExpressionLength` when creating the
-`SpelParserConfiguration` that you provide to the `SpelExpressionParser`. If you wish to
-set the `maxExpressionLength` used for parsing SpEL expressions within an
-`ApplicationContext` -- for example, in XML bean definitions, `@Value`, etc. -- you can
-set a JVM system property or Spring property named `spring.context.expression.maxLength`
-to the maximum expression length needed by your application (see
-xref:appendix.adoc#appendix-spring-properties[Supported Spring Properties]).


 [[expressions-spel-compilation]]
 == SpEL Compilation

-Spring provides a basic compiler for SpEL expressions. Expressions are usually
-interpreted, which provides a lot of dynamic flexibility during evaluation but does not
-provide optimum performance. For occasional expression usage, this is fine, but, when
-used by other components such as Spring Integration, performance can be very important,
-and there is no real need for the dynamism.
+Spring Framework 4.1 includes a basic expression compiler. Expressions are usually
+interpreted, which provides a lot of dynamic flexibility during evaluation but
+does not provide optimum performance. For occasional expression usage,
+this is fine, but, when used by other components such as Spring Integration,
+performance can be very important, and there is no real need for the dynamism.

 The SpEL compiler is intended to address this need. During evaluation, the compiler
 generates a Java class that embodies the expression behavior at runtime and uses that
@@ -419,17 +402,16 @@ information can cause trouble later if the types of the various expression eleme
 change over time. For this reason, compilation is best suited to expressions whose
 type information is not going to change on repeated evaluations.

-Consider the following basic expression.
+Consider the following basic expression:

-[source,java,indent=0,subs="verbatim,quotes"]
 ----
-	someArray[0].someProperty.someOtherProperty < 0.1
+someArray[0].someProperty.someOtherProperty < 0.1
 ----

-Because the preceding expression involves array access, some property de-referencing, and
-numeric operations, the performance gain can be very noticeable. In an example micro
-benchmark run of 50,000 iterations, it took 75ms to evaluate by using the interpreter and
-only 3ms using the compiled version of the expression.
+Because the preceding expression involves array access, some property de-referencing,
+and numeric operations, the performance gain can be very noticeable. In an example
+micro benchmark run of 50000 iterations, it took 75ms to evaluate by using the
+interpreter and only 3ms using the compiled version of the expression.


 [[expressions-compiler-configuration]]
@@ -437,34 +419,33 @@ only 3ms using the compiled version of the expression.

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

 The compiler can operate in one of three modes, which are captured in the
-`org.springframework.expression.spel.SpelCompilerMode` enum. The modes are as follows.
+`org.springframework.expression.spel.SpelCompilerMode` enum. The modes are as follows:

 * `OFF` (default): The compiler is switched off.
 * `IMMEDIATE`: In immediate mode, the expressions are compiled as soon as possible. This
-  is typically after the first interpreted evaluation. If the compiled expression fails
-  (typically due to a type changing, as described earlier), the caller of the expression
-  evaluation receives an exception.
-* `MIXED`: In mixed mode, the expressions silently switch between interpreted and
-  compiled mode over time. After some number of interpreted runs, they switch to compiled
-  form and, if something goes wrong with the compiled form (such as a type changing, as
-  described earlier), the expression automatically switches back to interpreted form
-  again. Sometime later, it may generate another compiled form and switch to it.
-  Basically, the exception that the user gets in `IMMEDIATE` mode is instead handled
-  internally.
+is typically after the first interpreted evaluation. If the compiled expression fails
+(typically due to a type changing, as described earlier), the caller of the expression
+evaluation receives an exception.
+* `MIXED`: In mixed mode, the expressions silently switch between interpreted and compiled
+mode over time. After some number of interpreted runs, they switch to compiled
+form and, if something goes wrong with the compiled form (such as a type changing, as
+described earlier), the expression automatically switches back to interpreted form
+again. Sometime later, it may generate another compiled form and switch to it. Basically,
+the exception that the user gets in `IMMEDIATE` mode is instead handled internally.

 `IMMEDIATE` mode exists because `MIXED` mode could cause issues for expressions that
 have side effects. If a compiled expression blows up after partially succeeding, it
 may have already done something that has affected the state of the system. If this
 has happened, the caller may not want it to silently re-run in interpreted mode,
-since part of the expression may be run twice.
+since part of the expression may be running twice.

 After selecting a mode, use the `SpelParserConfiguration` to configure the parser. The
-following example shows how to do so.
+following example shows how to do so:

 [tabs]
 ======
@@ -501,16 +482,15 @@ Kotlin::
 ----
 ======

-When you specify the compiler mode, you can also specify a `ClassLoader` (passing `null`
-is allowed). Compiled expressions are defined in a child `ClassLoader` created under any
-that is supplied. It is important to ensure that, if a `ClassLoader` is specified, it can
-see all the types involved in the expression evaluation process. If you do not specify a
-`ClassLoader`, a default `ClassLoader` is used (typically the context `ClassLoader` for
-the thread that is running during expression evaluation).
+When you specify the compiler mode, you can also specify a classloader (passing null is allowed).
+Compiled expressions are defined in a child classloader created under any that is supplied.
+It is important to ensure that, if a classloader is specified, it can see all the types involved in
+the expression evaluation process. If you do not specify a classloader, a default classloader is used
+(typically the context classloader for the thread that is running during expression evaluation).

 The second way to configure the compiler is for use when SpEL is embedded inside some
 other component and it may not be possible to configure it through a configuration
-object. In such cases, it is possible to set the `spring.expression.compiler.mode`
+object. In these cases, it is possible to set the `spring.expression.compiler.mode`
 property via a JVM system property (or via the
 xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism) to one of the
 `SpelCompilerMode` enum values (`off`, `immediate`, or `mixed`).
@@ -519,16 +499,18 @@ xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism) to
 [[expressions-compiler-limitations]]
 === Compiler Limitations

-Spring does not support compiling every kind of expression. The primary focus is on
-common expressions that are likely to be used in performance-critical contexts. The
-following kinds of expressions cannot be compiled.
+Since Spring Framework 4.1, the basic compilation framework is in place. However, the framework
+does not yet support compiling every kind of expression. The initial focus has been on the
+common expressions that are likely to be used in performance-critical contexts. The following
+kinds of expression cannot be compiled at the moment:

 * Expressions involving assignment
 * Expressions relying on the conversion service
 * Expressions using custom resolvers or accessors
-* Expressions using overloaded operators
-* Expressions using array construction syntax
 * Expressions using selection or projection

-Compilation of additional kinds of expressions may be supported in the future.
+More types of expressions will be compilable in the future.
+
+
+

@@ -3,11 +3,9 @@

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

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

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

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

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

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

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

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

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

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

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

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

-[CAUTION]
-====
-Any expression that constructs an array – for example, via `new int[4]` or
-`new int[] {1, 2, 3}` – cannot be compiled. See
-xref:core/expressions/evaluation.adoc#expressions-compiler-limitations[Compiler Limitations]
-for details.
-====
+
+
@@ -4,7 +4,7 @@
 Projection lets a collection drive the evaluation of a sub-expression, and the result is
 a new collection. The syntax for projection is `.![projectionExpression]`. For example,
 suppose we have a list of inventors but want the list of cities where they were born.
-Effectively, we want to evaluate `placeOfBirth.city` for every entry in the inventor
+Effectively, we want to evaluate 'placeOfBirth.city' for every entry in the inventor
 list. The following example uses projection to do so:

 [tabs]
@@ -13,18 +13,16 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	// evaluates to ["Smiljan", "Idvor"]
-	List placesOfBirth = parser.parseExpression("members.![placeOfBirth.city]")
-			.getValue(societyContext, List.class);
+	// returns ['Smiljan', 'Idvor' ]
+	List placesOfBirth = (List)parser.parseExpression("members.![placeOfBirth.city]");
 ----

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

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

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

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

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

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

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

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

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

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

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

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

@@ -12,27 +12,27 @@ Java::
 +
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 ----
-	Inventor einstein = parser.parseExpression(
-		"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
+	Inventor einstein = p.parseExpression(
+			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor.class);

 	// create new Inventor instance within the add() method of List
-	parser.parseExpression(
-		"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
-			.getValue(societyContext);
+	p.parseExpression(
+			"Members.add(new org.spring.samples.spel.inventor.Inventor(
+				'Albert Einstein', 'German'))").getValue(societyContext);
 ----

 Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-	val einstein = parser.parseExpression(
-		"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
+	val einstein = p.parseExpression(
+			"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')")
 			.getValue(Inventor::class.java)

 	// create new Inventor instance within the add() method of List
-	parser.parseExpression(
-		"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
+	p.parseExpression(
+			"Members.add(new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German'))")
 			.getValue(societyContext)
 ----
 ======
@@ -1,26 +1,10 @@
 [[expressions-ref-functions]]
 = Functions

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

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

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

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

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

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

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

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

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

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

-Consider the `String#formatted(Object...)` instance method, which produces a message
-according to a template and a variable number of arguments.
+Consider the `String#formatted(String, Object...)` instance method, which produces a
+message according to a template and a variable number of arguments.

 You can register and use the `formatted` method as a `MethodHandle`, as the following
 example shows:
@@ -129,9 +118,9 @@ Java::
 			MethodType.methodType(String.class, Object[].class));
 	context.setVariable("message", mh);

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

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

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

-As mentioned above, binding a `MethodHandle` and registering the bound `MethodHandle` is
-also supported. This is likely to be more performant if both the target and all the
-arguments are bound. In that case no arguments are necessary in the SpEL expression, as
-the following example shows:
+As hinted above, binding a `MethodHandle` and registering the bound `MethodHandle` is also
+supported. This is likely to be more performant if both the target and all the arguments
+are bound. In that case no arguments are necessary in the SpEL expression, as the
+following example shows:

 [tabs]
 ======
@@ -168,15 +156,14 @@ Java::
 	String template = "This is a %s message with %s words: <%s>";
 	Object varargs = new Object[] { "prerecorded", 3, "Oh Hello World!", "ignored" };
 	MethodHandle mh = MethodHandles.lookup().findVirtual(String.class, "formatted",
-		MethodType.methodType(String.class, Object[].class))
+			MethodType.methodType(String.class, Object[].class))
 			.bindTo(template)
-			// Here we have to provide the arguments in a single array binding:
-			.bindTo(varargs);
+			.bindTo(varargs); //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh);

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

 Kotlin::
@@ -190,13 +177,11 @@ Kotlin::
 	val varargs = arrayOf("prerecorded", 3, "Oh Hello World!", "ignored")

 	val mh = MethodHandles.lookup().findVirtual(String::class.java, "formatted",
-		MethodType.methodType(String::class.java, Array<Any>::class.java))
+			MethodType.methodType(String::class.java, Array<Any>::class.java))
 			.bindTo(template)
-			// Here we have to provide the arguments in a single array binding:
-			.bindTo(varargs)
+			.bindTo(varargs) //here we have to provide arguments in a single array binding
 	context.setVariable("message", mh)

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

 SpEL supports the following types of literal expressions.

-String ::
-  Strings can be delimited by single quotation marks (`'`) or double quotation marks
-  (`"`). To include a single quotation mark within a string literal enclosed in single
-  quotation marks, use two adjacent single quotation mark characters. Similarly, to
-  include a double quotation mark within a string literal enclosed in double quotation
-  marks, use two adjacent double quotation mark characters.
-Number ::
-  Numbers support the use of the negative sign, exponential notation, and decimal points.
-  * Integer: `int` or `long`
-  * Hexadecimal: `int` or `long`
-  * Real: `float` or `double`
-  ** By default, real numbers are parsed using `Double.parseDouble()`.
-Boolean ::
-  `true` or `false`
-Null ::
-  `null`
+- strings
+- numeric values: integer (`int` or `long`), hexadecimal (`int` or `long`), real (`float`
+  or `double`)
+- boolean values: `true` or `false`
+- null

-[NOTE]
-====
-Due to the design and implementation of the Spring Expression Language, literal numbers
-are always stored internally as positive numbers.
+Strings can delimited by single quotation marks (`'`) or double quotation marks (`"`). To
+include a single quotation mark within a string literal enclosed in single quotation
+marks, use two adjacent single quotation mark characters. Similarly, to include a double
+quotation mark within a string literal enclosed in double quotation marks, use two
+adjacent double quotation mark characters.

-For example, `-2` is stored internally as a positive `2` which is then negated while
-evaluating the expression (by calculating the value of `0 - 2`).
-
-This means that it is not possible to represent a negative literal number equal to the
-minimum value of that type of number in Java. For example, the minimum supported value
-for an `int` in Java is `Integer.MIN_VALUE` which has a value of `-2147483648`. However,
-if you include `-2147483648` in a SpEL expression, an exception will be thrown informing
-you that the value `2147483648` cannot be parsed as an `int` (because it exceeds the
-value of `Integer.MAX_VALUE` which is `2147483647`).
-
-If you need to use the minimum value for a particular type of number within a SpEL
-expression, you can either reference the `MIN_VALUE` constant for the respective wrapper
-type (such as `Integer.MIN_VALUE`, `Long.MIN_VALUE`, etc.) or calculate the minimum
-value. For example, to use the minimum integer value:
-
- `T(Integer).MIN_VALUE` -- requires a `StandardEvaluationContext`
- `-2^31` -- can be used with any type of `EvaluationContext`
-====
+Numbers support the use of the negative sign, exponential notation, and decimal points.
+By default, real numbers are parsed by using `Double.parseDouble()`.

 The following listing shows simple usage of literals. Typically, they are not used in
 isolation like this but, rather, as part of a more complex expression -- for example,
@@ -1,27 +1,12 @@
 [[expressions-operator-safe-navigation]]
 = Safe Navigation Operator

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

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

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

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

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

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

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


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

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

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


 [[expressions-operators-relational]]
@@ -18,7 +15,7 @@ The Spring Expression Language supports the following kinds of operators:
 The relational operators (equal, not equal, less than, less than or equal, greater than,
 and greater than or equal) are supported by using standard operator notation.
 These operators work on `Number` types as well as types implementing `Comparable`.
-The following listing shows a few examples of relational operators:
+The following listing shows a few examples of operators:

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

 [tabs]
@@ -196,7 +196,7 @@ Kotlin::

 When used as `org.springframework.validation.Validator`, `LocalValidatorFactoryBean`
 invokes the underlying `jakarta.validation.Validator`, and then adapts
-``ConstraintViolation``s to ``FieldError``s, and registers them with the `Errors` object
+``ContraintViolation``s to ``FieldError``s, and registers them with the `Errors` object
 passed into the `validate` method.


@@ -299,7 +299,7 @@ Java::
 	public class AppConfig {

 		@Bean
-		public static MethodValidationPostProcessor validationPostProcessor() {
+		public 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 `jakarta.validation.Validator`. As an alternative,
+``ConstraintViolation``s returned by `jakarata.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 static MethodValidationPostProcessor validationPostProcessor() {
+		public MethodValidationPostProcessor validationPostProcessor() {
 			MethodValidationPostProcessor processor = new MethodValidationPostProcessor();
 			processor.setAdaptConstraintViolations(true);
 			return processor;
@@ -429,9 +429,9 @@ Kotlin::
 ----
 ======

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

- Error codes `"Size.person.name"`, `"Size.name"`, `"Size.java.lang.String"`, and `"Size"`
+- Error codes `"Size.student.name"`, `"Size.name"`, `"Size.java.lang.String"`, and `"Size"`
 - Message arguments `"name"`, `10`, and `1` (the field name and the constraint attributes)
 - Default message "size must be between 1 and 10"

@@ -439,14 +439,14 @@ To customize the default message, you can add properties to
 xref:core/beans/context-introduction.adoc#context-functionality-messagesource[MessageSource]
 resource bundles using any of the above errors codes and message arguments. Note also that the
 message argument `"name"` is itself a `MessagreSourceResolvable` with error codes
-`"person.name"` and `"name"` and can customized too. For example:
+`"student.name"` and `"name"` and can customized too. For example:

 Properties::
 +
 [source,properties,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
-Size.person.name=Please, provide a {0} that is between {2} and {1} characters long
-person.name=username
+Size.student.name=Please, provide a {0} that is between {2} and {1} characters long
+student.name=username
 ----

 A `ConstraintViolation` on the `degrees` method parameter is adapted to a
@@ -280,11 +280,10 @@ Kotlin::

 A portable format annotation API exists in the `org.springframework.format.annotation`
 package. You can use `@NumberFormat` to format `Number` fields such as `Double` and
-`Long`, and `@DateTimeFormat` to format fields such as `java.util.Date`,
-`java.util.Calendar`, and `Long` (for millisecond timestamps) as well as JSR-310
-`java.time` types.
+`Long`, and `@DateTimeFormat` to format `java.util.Date`, `java.util.Calendar`, `Long`
+(for millisecond timestamps) as well as JSR-310 `java.time`.

-The following example uses `@DateTimeFormat` to format a `java.util.Date` as an ISO date
+The following example uses `@DateTimeFormat` to format a `java.util.Date` as an ISO Date
 (yyyy-MM-dd):

 [tabs]
@@ -310,28 +309,6 @@ Kotlin::
 ----
 ======

-For further details, see the javadoc for
-{spring-framework-api}/format/annotation/DateTimeFormat.html[`@DateTimeFormat`] and
-{spring-framework-api}/format/annotation/NumberFormat.html[`@NumberFormat`].
-
-[WARNING]
-====
-Style-based formatting and parsing rely on locale-sensitive patterns which may change
-depending on the Java runtime. Specifically, applications that rely on date, time, or
-number parsing and formatting may encounter incompatible changes in behavior when running
-on JDK 20 or higher.
-
-Using an ISO standardized format or a concrete pattern that you control allows for
-reliable system-independent and locale-independent parsing and formatting of date, time,
-and number values.
-
-For `@DateTimeFormat`, the use of fallback patterns can also help to address
-compatibility issues.
-
-For further details, see the
-https://github.com/spring-projects/spring-framework/wiki/Date-and-Time-Formatting-with-JDK-20-and-higher[Date and Time Formatting with JDK 20 and higher]
-page in the Spring Framework wiki.
-====

 [[format-FormatterRegistry-SPI]]
 == The `FormatterRegistry` SPI
@@ -198,7 +198,7 @@ methods it offers can be found in the {spring-framework-api}/validation/Errors.h
 Validators may also get locally invoked for the immediate validation of a given object,
 not involving a binding process. As of 6.1, this has been simplified through a new
 `Validator.validateObject(Object)` method which is available by default now, returning
-a simple `Errors` representation which can be inspected: typically calling `hasErrors()`
+a simple ´Errors` representation which can be inspected: typically calling `hasErrors()`
 or the new `failOnError` method for turning the error summary message into an exception
 (e.g. `validator.validateObject(myObject).failOnError(IllegalArgumentException::new)`).

@@ -211,28 +211,19 @@ 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 specific performance issue for your application.
+xref:appendix.adoc#appendix-spring-properties[`SpringProperties`] mechanism) if you encounter
+a performance issue (as reported on Oracle 12c, JBoss, and PostgreSQL).

-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.
+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.
 ====


@@ -717,7 +717,7 @@ For example, with positional parameters:

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

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

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

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

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

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

@@ -112,7 +112,7 @@ Java::
 		this.actorMappingQuery = new ActorMappingQuery(dataSource);
 	}

-	public Actor getActor(Long id) {
+	public Customer getCustomer(Long id) {
 		return actorMappingQuery.findObject(id);
 	}
 ----
@@ -123,11 +123,11 @@ Kotlin::
 ----
 	private val actorMappingQuery = ActorMappingQuery(dataSource)

-	fun getActor(id: Long) = actorMappingQuery.findObject(id)
+	fun getCustomer(id: Long) = actorMappingQuery.findObject(id)
 ----
 ======

-The method in the preceding example retrieves the actor with the `id` that is passed in as the
+The method in the preceding example retrieves the customer 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`
@@ -209,26 +209,141 @@ are passed in as a parameter to the stored procedure.

 The `SqlReturnType` interface has a single method (named `getTypeValue`) that must be
 implemented. This interface is used as part of the declaration of an `SqlOutParameter`.
-The following example shows returning the value of a `java.sql.Struct` object of the user
+The following example shows returning the value of an Oracle `STRUCT` object of the user
 declared type `ITEM_TYPE`:

-include-code::./TestItemStoredProcedure[]
+[tabs]
+======
+Java::
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	public class TestItemStoredProcedure extends StoredProcedure {
+
+		public TestItemStoredProcedure(DataSource dataSource) {
+			// ...
+			declareParameter(new SqlOutParameter("item", OracleTypes.STRUCT, "ITEM_TYPE",
+				(CallableStatement cs, int colIndx, int sqlType, String typeName) -> {
+					STRUCT struct = (STRUCT) cs.getObject(colIndx);
+					Object[] attr = struct.getAttributes();
+					TestItem item = new TestItem();
+					item.setId(((Number) attr[0]).longValue());
+					item.setDescription((String) attr[1]);
+					item.setExpirationDate((java.util.Date) attr[2]);
+					return item;
+				}));
+			// ...
+		}
+----
+
+Kotlin::
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	class TestItemStoredProcedure(dataSource: DataSource) : StoredProcedure() {
+
+		init {
+			// ...
+			declareParameter(SqlOutParameter("item", OracleTypes.STRUCT, "ITEM_TYPE") { cs, colIndx, sqlType, typeName ->
+				val struct = cs.getObject(colIndx) as STRUCT
+				val attr = struct.getAttributes()
+				TestItem((attr[0] as Long, attr[1] as String, attr[2] as Date)
+			})
+			// ...
+		}
+	}
+----
+======

 You can use `SqlTypeValue` to pass the value of a Java object (such as `TestItem`) to a
 stored procedure. The `SqlTypeValue` interface has a single method (named
 `createTypeValue`) that you must implement. The active connection is passed in, and you
-can use it to create database-specific objects, such as `java.sql.Struct` instances
-or `java.sql.Array` instances. The following example creates a `java.sql.Struct` instance:
+can use it to create database-specific objects, such as `StructDescriptor` instances
+or `ArrayDescriptor` instances. The following example creates a `StructDescriptor` instance:

-include-code::./SqlTypeValueFactory[tag=struct,indent=0]
+[tabs]
+======
+Java::
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	final TestItem testItem = new TestItem(123L, "A test item",
+			new SimpleDateFormat("yyyy-M-d").parse("2010-12-31"));
+
+	SqlTypeValue value = new AbstractSqlTypeValue() {
+		protected Object createTypeValue(Connection conn, int sqlType, String typeName) throws SQLException {
+			StructDescriptor itemDescriptor = new StructDescriptor(typeName, conn);
+			Struct item = new STRUCT(itemDescriptor, conn,
+			new Object[] {
+				testItem.getId(),
+				testItem.getDescription(),
+				new java.sql.Date(testItem.getExpirationDate().getTime())
+			});
+			return item;
+		}
+	};
+----
+
+Kotlin::
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	val (id, description, expirationDate) = TestItem(123L, "A test item",
+			SimpleDateFormat("yyyy-M-d").parse("2010-12-31"))
+
+	val value = object : AbstractSqlTypeValue() {
+		override fun createTypeValue(conn: Connection, sqlType: Int, typeName: String?): Any {
+			val itemDescriptor = StructDescriptor(typeName, conn)
+			return STRUCT(itemDescriptor, conn,
+					arrayOf(id, description, java.sql.Date(expirationDate.time)))
+		}
+	}
+----
+======

 You can now add this `SqlTypeValue` to the `Map` that contains the input parameters for the
 `execute` call of the stored procedure.

 Another use for the `SqlTypeValue` is passing in an array of values to an Oracle stored
-procedure. Oracle has an `createOracleArray` method on `OracleConnection` that you can
-access by unwrapping it. You can use the `SqlTypeValue` to create an array and populate
-it with values from the Java `java.sql.Array`, as the following example shows:
+procedure. Oracle has its own internal `ARRAY` class that must be used in this case, and
+you can use the `SqlTypeValue` to create an instance of the Oracle `ARRAY` and populate
+it with values from the Java `ARRAY`, as the following example shows:
+
+[tabs]
+======
+Java::
+
+[source,java,indent=0,subs="verbatim,quotes",role="primary"]
+----
+	final Long[] ids = new Long[] {1L, 2L};
+
+	SqlTypeValue value = new AbstractSqlTypeValue() {
+		protected Object createTypeValue(Connection conn, int sqlType, String typeName) throws SQLException {
+			ArrayDescriptor arrayDescriptor = new ArrayDescriptor(typeName, conn);
+			ARRAY idArray = new ARRAY(arrayDescriptor, conn, ids);
+			return idArray;
+		}
+	};
+----
+
+Kotlin::
+
+[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
+----
+	class TestItemStoredProcedure(dataSource: DataSource) : StoredProcedure() {
+
+		init {
+			val ids = arrayOf(1L, 2L)
+			val value = object : AbstractSqlTypeValue() {
+				override fun createTypeValue(conn: Connection, sqlType: Int, typeName: String?): Any {
+					val arrayDescriptor = ArrayDescriptor(typeName, conn)
+					return ARRAY(arrayDescriptor, conn, ids)
+				}
+			}
+		}
+	}
+----
+======
+

-include-code::./SqlTypeValueFactory[tag=oracle-array,indent=0]

@@ -323,12 +323,12 @@ use these alternative input classes.

 The `SimpleJdbcCall` class uses metadata in the database to look up names of `in`
 and `out` parameters so that you do not have to explicitly declare them. You can
-declare parameters if you prefer to do that or if you have parameters that do not
-have an automatic mapping to a Java class. The first example shows a simple procedure
-that returns only scalar values in `VARCHAR` and `DATE` format from a MySQL database.
-The example procedure reads a specified actor entry and returns `first_name`,
-`last_name`, and `birth_date` columns in the form of `out` parameters. The following
-listing shows the first example:
+declare parameters if you prefer to do that or if you have parameters (such as `ARRAY`
+or `STRUCT`) that do not have an automatic mapping to a Java class. The first example
+shows a simple procedure that returns only scalar values in `VARCHAR` and `DATE` format
+from a MySQL database. The example procedure reads a specified actor entry and returns
+`first_name`, `last_name`, and `birth_date` columns in the form of `out` parameters.
+The following listing shows the first example:

 [source,sql,indent=0,subs="verbatim,quotes"]
 ----
@@ -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]
 ======
@@ -440,8 +440,12 @@ Kotlin::
 +
 [source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
 ----
+	val tuples: MutableList<Array<Any>> = ArrayList()
+	tuples.add(arrayOf("John", 35))
+	tuples.add(arrayOf("Ann", 50))
+
 	client.sql("SELECT id, name, state FROM table WHERE age IN (:ages)")
-		    .bind("ages", arrayOf(35, 50))
+		    .bind("tuples", arrayOf(35, 50))
 ----
 ======

--- a/Show More
+++ b/Show More