Merge branch 'spring-operator-polish-urls-build-4.1.x' into 4.1.x

Closes gh-22518

.editorconfig

@@ -1,10 +0,0 @@
-root = true
-
-[*.{adoc,bat,groovy,html,java,js,jsp,kt,kts,md,properties,py,rb,sh,sql,svg,txt,xml,xsd}]
-charset = utf-8
-
-[*.{groovy,java,kt,kts,xml,xsd}]
-indent_style = tab
-indent_size = 4
-continuation_indent_size = 8
-end_of_line = lf

.gitattributes

@@ -1,16 +0,0 @@
-# Normalize line endings to LF.
-* text eol=lf
-
-# Ensure that line endings for multipart files in spring-web are not modified.
-*.multipart -text
-
-# Ensure that line endings for DOS batch files are not modified.
-*.bat -text
-
-# Ensure the following are treated as binary.
-*.gif   binary
-*.jar   binary
-*.jpeg  binary
-*.jpg   binary
-*.png   binary
-*.vsd   binary

.github/ISSUE_TEMPLATE.md

@@ -1,17 +0,0 @@
-<!--
-!!! For Security Vulnerabilities, please go to https://spring.io/security-policy !!!
--->
-**Affects:** \<Spring Framework version>
-
----
-<!--
-Thanks for taking the time to create an issue. Please read the following:
-
-- Questions should be asked on Stack Overflow.
-- For bugs, specify affected versions and explain what you are trying to do.
-- For enhancements, provide context and describe the problem.
-
-Issue or Pull Request? Create only one, not both. GitHub treats them as the same.
-If unsure, start with an issue, and if you submit a pull request later, the
-issue will be closed as superseded.
--->

.github/actions/await-http-resource/action.yml

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

.github/actions/build/action.yml

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

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

@@ -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@86958813a62af8fb223b3fd3b5152035504bcb83 #v0.0.12
-      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

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

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

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

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

.github/actions/print-jvm-thread-dumps/action.yml

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

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

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

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

@@ -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) }}

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

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

.github/workflows/backport-bot.yml

@@ -1,33 +0,0 @@
-name: Backport Bot
-on:
-  issues:
-    types: [labeled]
-  pull_request:
-    types: [labeled]
-  push:
-    branches:
-      - '*.x'
-permissions:
-  contents: read
-jobs:
-  build:
-    permissions:
-      contents: read
-      issues: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out code
-        uses: actions/checkout@v4
-      - name: Set up Java
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'liberica'
-          java-version: 17
-      - name: Download BackportBot
-        run: wget https://github.com/spring-io/backport-bot/releases/download/latest/backport-bot-0.0.1-SNAPSHOT.jar
-      - name: Backport
-        env:
-          GITHUB_EVENT: ${{ toJSON(github.event) }}
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: java -jar backport-bot-0.0.1-SNAPSHOT.jar --github.accessToken="$GITHUB_TOKEN" --github.event_name "$GITHUB_EVENT_NAME" --github.event "$GITHUB_EVENT"

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

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

.github/workflows/build-pull-request.yml

@@ -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/'

.github/workflows/ci.yml

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

.github/workflows/deploy-docs.yml

@@ -1,35 +0,0 @@
-name: Deploy Docs
-on:
-  push:
-    branches:
-      - 'main'
-      - '*.x'
-      - '!gh-pages'
-    tags:
-      - 'v*'
-  repository_dispatch:
-    types: request-build-reference # legacy
-  workflow_dispatch:
-permissions:
-  actions: write
-jobs:
-  build:
-    name: Dispatch docs deployment
-    if: ${{ github.repository == 'spring-projects/spring-framework' }}
-    runs-on: ubuntu-latest
-    steps:
-    - name: Check out code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 1
-        ref: docs-build
-    - name: Dispatch (partial build)
-      if: github.ref_type == 'branch'
-      env:
-        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: gh workflow run deploy-docs.yml -r $(git rev-parse --abbrev-ref HEAD) -f build-refname=${{ github.ref_name }}
-    - name: Dispatch (full build)
-      if: github.ref_type == 'tag'
-      env:
-        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: gh workflow run deploy-docs.yml -r $(git rev-parse --abbrev-ref HEAD)

.github/workflows/release.yml

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

.github/workflows/verify.yml

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

.gitignore

@@ -1,41 +1,31 @@
-# Miscellaneous
 *.java.hsp
 *.sonarj
 *.sw*
 .DS_Store
+.settings
+.springBeans
+bin
 build.sh
 integration-repo
 ivy-cache
-argfile*
-activemq-data/
-classes/
-
-# Log files
 jxl.log
 jmx.log
 derby.log
-
-# Gradle artifacts
+spring-test/test-output/
 .gradle
-.gradletasknamecache
+argfile*
+pom.xml
+activemq-data/
+
 /build
 buildSrc/build
 /spring-*/build
-/framework-*/build
-/integration-tests/build
 /src/asciidoc/build
-spring-test/test-output/
-
-# Maven artifacts
-pom.xml
-/target/
+target/
 
 # Eclipse artifacts, including WTP generated manifests
-bin
 .classpath
 .project
-.settings
-.springBeans
 spring-*/src/main/java/META-INF/MANIFEST.MF
 
 # IDEA artifacts and output dirs
@@ -46,10 +36,4 @@ spring-*/src/main/java/META-INF/MANIFEST.MF
 out
 test-output
 atlassian-ide-plugin.xml
-
-# VS Code
-.vscode/
-
-cached-antora-playbook.yml
-
-node_modules
+.gradletasknamecache

.mailmap

@@ -0,0 +1,23 @@
+Juergen Hoeller <jhoeller@pivotal.io> jhoeller <jhoeller@vmware.com>
+<jhoeller@pivotal.io> <jhoeller@vmware.com>
+<jhoeller@pivotal.io> <jhoeller@gopivotal.com>
+<rstoyanchev@pivotal.io> <rstoyanchev@vmware.com>
+<rstoyanchev@pivotal.io> <rstoyanchev@gopivotal.com>
+<pwebb@pivotal.io> <pwebb@vmware.com>
+<pwebb@pivotal.io> <pwebb@gopivotal.com>
+<cbeams@pivotal.io> <cbeams@vmware.com>
+<cbeams@pivotal.io> <cbeams@gopivotal.com>
+<cbeams@pivotal.io> <cbeams@gmail.com>
+<apoutsma@pivotal.io> <apoutsma@vmware.com>
+<apoutsma@pivotal.io> <apoutsma@gopivotal.com>
+<apoutsma@pivotal.io> <poutsma@mac.com>
+<ogierke@pivotal.io> <ogierke@vmware.com>
+<ogierke@pivotal.io> <ogierke@gopivotal.com>
+<dsyer@pivotal.io> <dsyer@vmware.com>
+<dsyer@pivotal.io> <dsyer@gopivotal.com>
+<dsyer@pivotal.io> <david_syer@hotmail.com>
+<aclement@pivotal.io> <aclement@vmware.com>
+<aclement@pivotal.io> <aclement@gopivotal.com>
+<aclement@pivotal.io> <andrew.clement@gmail.com>
+<dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
+Nick Williams <nicholas@nicholaswilliams.net> Nicholas Williams <nicholas@nicholaswilliams.net>

.sdkmanrc

@@ -1,3 +0,0 @@
-# Enable auto-env through the sdkman_auto_env config
-# Add key=value pairs of SDKs to use below
-java=17.0.13-librca

.settings/gradle/com.springsource.sts.gradle.core.import.prefs

@@ -0,0 +1,9 @@
+#com.springsource.sts.gradle.core.preferences.GradleImportPreferences
+#Thu Aug  9 11:34:43 CEST 2012
+enableAfterTasks=true
+afterTasks=afterEclipseImport;
+enableDependendencyManagement=false
+enableBeforeTasks=true
+projects=;spring-aop;spring-aspects;spring-beans;spring-context;spring-context-support;spring-core;spring-expression;spring-instrument;spring-instrument-tomcat;spring-jdbc;spring-jms;spring-orm;spring-oxm;spring-struts;spring-test;spring-tx;spring-web;spring-webmvc;spring-webmvc-portlet;
+enableDSLD=false
+beforeTasks=cleanEclipse;eclipse;\:spring-oxm\:compileTestJava;

.settings/gradle/com.springsource.sts.gradle.core.prefs

@@ -0,0 +1,5 @@
+#com.springsource.sts.gradle.core.preferences.GradleProjectPreferences
+#Tue Feb 21 14:38:31 CET 2012
+com.springsource.sts.gradle.classpath.enableSorting=false
+com.springsource.sts.gradle.rootprojectloc=
+com.springsource.sts.gradle.linkedresources=

.settings/gradle/com.springsource.sts.gradle.refresh.prefs

@@ -0,0 +1,9 @@
+#com.springsource.sts.gradle.core.actions.GradleRefreshPreferences
+#Thu Aug  9 11:34:43 CEST 2012
+enableAfterTasks=true
+afterTasks=afterEclipseImport;
+useHierarchicalNames=false
+enableBeforeTasks=true
+addResourceFilters=false
+enableDSLD=false
+beforeTasks=cleanEclipse;eclipse;\:spring-oxm\:compileTestJava;

CONTRIBUTING-DOCUMENTATION.adoc

@@ -0,0 +1,51 @@
+= How to contribute to the reference
+
+The Spring Framework reference now uses http://asciidoctor.org/[asciidoctor]. This
+document describes how to contribute documentation updates.
+
+== Building with Gradle
+
+You can build the documentation using gradle using the `reference` task. For example, from
+the project root execute the following command:
+
+	./gradlew reference
+
+the output will be available at `spring-framework/build/reference/htmlsingle/index.html`
+
+== Live editing
+
+One of the nice features about using asciidoctor is the support for live editing.
+
+You will find a Guardfile already present at `spring-framework/src/asciidoc/Guardfile`.
+Make sure first to follow the setup instructions within the
+http://asciidoctor.org/docs/editing-asciidoc-with-live-preview/[Editing AsciiDoc with Live Preview]
+document. Once you have done that, there are additional gems to install to make it work
+(assuming that you are using http://livereload.com/[LiveReload]):
+
+	gem install guard-rspec guard-livereload
+
+When running `guard start` within the `src/asciidoc/` folder, any changes to the
+`src/asciidoc/index.adoc` file will automatically be written at
+`src/asciidoc/build/index.html`.
+
+== Troubleshooting
+
+* If you are using LiveReload, make sure to select _Allow access to file URLs_ in the
+  LiveEdit plugin options of your browser.
+* The icon used to enable _LiveReload_ can be a bit confusing. The dot is empty when it is
+  disabled and full when the plugin is active. Make sure to enable it on the tab
+  displaying the `index.html` file.
+* Ensure you are _not_ running guard start at all as two instances could not run at the
+  same time. To exit a current session in a clean way, just type e in the shell.
+
+== Documentation notes
+
+Some notes on documentation
+
+* Documentation is wrapped at 90 chars, ensure that you manually wrap your edits
+* Tabs are used for indentation, do not use spaces
+* Follow the existing style when inserting `source` blocks
+* http://asciidoctor.org/docs/asciidoc-syntax-quick-reference/[Asciidoctor Quick Reference]
+* http://asciidoctor.org/docs/user-manual/[Asciidoctor Manual]
+* http://asciidoctor.org/docs/asciidoc-writers-guide/[Asciidoctor Writers Guide]
+

CONTRIBUTING.md

@@ -1,135 +1,307 @@
-# Contributing  to the Spring Framework
+_Have something you'd like to contribute to the framework?  We welcome pull
+requests but ask that you carefully read this document first to understand how
+best to submit them; what kind of changes are likely to be accepted; and what
+to expect from the Spring team when evaluating your submission._
 
-First off, thank you for taking the time to contribute! :+1: :tada: 
+_Please refer back to this document as a checklist before issuing any pull
+request; this will save time for everyone!_
 
-### Table of Contents
+## Take Your First Steps
 
-* [Code of Conduct](#code-of-conduct)
-* [How to Contribute](#how-to-contribute)
-  * [Ask questions](#ask-questions)
-  * [Create an Issue](#create-an-issue)
-  * [Issue Lifecycle](#issue-lifecycle)
-  * [Submit a Pull Request](#submit-a-pull-request)
-* [Build from Source](#build-from-source)
-* [Source Code Style](#source-code-style)
-* [Reference Docs](#reference-docs)
+### Understand the basics
 
-### 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.
-Please report unacceptable behavior to spring-code-of-conduct@spring.io.
-
-### How to Contribute
-
-#### Ask questions
-
-If you have a question, check Stack Overflow using
-[this list of tags](https://stackoverflow.com/questions/tagged/spring+or+spring-mvc+or+spring-aop+or+spring-jdbc+or+spring-transactions+or+spring-annotations+or+spring-jms+or+spring-el+or+spring-test+or+spring+or+spring-remoting+or+spring-orm+or+spring-jmx+or+spring-cache+or+spring-webflux?tab=Newest). Find an existing discussion, or start a new one if necessary.
-
-If you believe there is an issue, search through
-[existing issues](https://github.com/spring-projects/spring-framework/issues) trying a
-few different ways to find discussions, past or current, that are related to the issue.
-Reading those discussions helps you to learn about the issue, and helps us to make a
-decision.
+Not sure what a pull request is, or how to submit one? Take a look at GitHub's
+excellent [help documentation][] first.
 
 
-#### Create an Issue
+### Search JIRA first; create an issue if necessary
 
-Reporting an issue or making a feature request is a great way to contribute. Your feedback
-and the conversations that result from it provide a continuous flow of ideas. However,
-before creating a ticket, please take the time to [ask and research](#ask-questions) first.
+Is there already an issue that addresses your concern? Do a bit of searching
+in our [JIRA issue tracker][] to see if you can find something similar. If you
+do not find something similar, please create a new JIRA issue before submitting
+a pull request unless the change is truly trivial -- for example: typo fixes,
+removing compiler warnings, etc.
 
-If you create an issue after a discussion on Stack Overflow, please provide a description
-in the issue instead of simply referring to Stack Overflow. The issue tracker is an
-important place of record for design discussions and should be self-sufficient.
+### Sign the Contributor License Agreement
 
-Once you're ready, create an issue on [GitHub](https://github.com/spring-projects/spring-framework/issues).
+If you have not previously done so, please fill out and submit the
+[SpringSource CLA form][]. You'll receive a token when this process is complete.
+Keep track of this; you may be asked for it later!
 
-Many issues are caused by subtle behavior, typos, and unintended configuration.
-Creating a [Minimal Reproducible Example](https://stackoverflow.com/help/minimal-reproducible-example)
-(starting with https://start.spring.io for example) of the problem helps the team
-quickly triage your issue and get to the core of the problem.
+Note that emailing/postal mailing a signed copy is _not_ necessary. Submission
+of the web form is all that is required.
 
-#### Issue Lifecycle
+Once you've completed the web form, simply add the following in a comment on
+your pull request:
 
-When an issue is first created, it is flagged `waiting-for-triage` waiting for a team
-member to triage it. Once the issue has been reviewed, the team may ask for further
-information if needed, and based on the findings, the issue is either assigned a target
-milestone or is closed with a specific status.
+    I have signed and agree to the terms of the SpringSource Individual
+    Contributor License Agreement.
 
-When a fix is ready, the issue is closed and may still be re-opened until the fix is
-released. After that the issue will typically no longer be reopened. In rare cases if the
-issue was not at all fixed, the issue may be re-opened. In most cases however any
-follow-up reports will need to be created as new issues with a fresh description.
+You do not need to include your token/id. Please add the above statement to all
+future pull requests as well, simply so that the Spring Framework team knows
+immediately that this process is complete.
 
-#### Submit a Pull Request
+## Create a Branch
 
-1. If you have not previously done so, please sign the
-[Contributor License Agreement](https://cla.spring.io/sign/spring). You will be reminded
-automatically when you submit the PR.
+### Branch from `master`
 
-1. Should you create an issue first? No, just create the pull request and use the
-description to provide context and motivation, as you would for an issue. If you want
-to start a discussion first or have already created an issue, once a pull request is
-created, we will close the issue as superseded by the pull request, and the discussion
-about the issue will continue under the pull request.
+Master currently represents work toward Spring Framework 4.0. Please submit
+all pull requests there, even bug fixes and minor improvements. Backports to
+`3.2.x` will be considered on a case-by-case basis.
 
-1. Always check out the `main` branch and submit pull requests against it
-(for target version see [settings.gradle](settings.gradle)).
-Backports to prior versions will be considered on a case-by-case basis and reflected as
-the fix version in the issue tracker.
 
-1. Choose the granularity of your commits consciously and squash commits that represent
-multiple edits or corrections of the same logical change. See
-[Rewriting History section of Pro Git](https://git-scm.com/book/en/Git-Tools-Rewriting-History)
-for an overview of streamlining the commit history.
+### Use short branch names
 
-1. Format commit messages using 55 characters for the subject line, 72 characters per line
-for the description, followed by the issue fixed, e.g. `Closes gh-22276`. See the
-[Commit Guidelines section of Pro Git](https://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines)
-for best practices around commit messages, and use `git log` to see some examples.
+Branches used when submitting pull requests should preferably be named
+according to JIRA issues, e.g. 'SPR-1234'. Otherwise, use succinct, lower-case,
+dash (-) delimited names, such as 'fix-warnings', 'fix-typo', etc. In
+[fork-and-edit][] cases, the GitHub default 'patch-1' is fine as well. This is
+important, because branch names show up in the merge commits that result from
+accepting pull requests and should be as expressive and concise as possible.
 
-1. If there is a prior issue, reference the GitHub issue number in the description of the
-pull request.
+## Use Spring Framework Code Style
 
-If accepted, your contribution may be heavily modified as needed prior to merging.
-You will likely retain author attribution for your Git commits granted that the bulk of
-your changes remain intact. You may also be asked to rework the submission.
+The complete [Spring Framework Code Style][] reference is available on the wiki, but
+here's a quick summary:
 
-If asked to make corrections, simply push the changes against the same branch, and your
-pull request will be updated. In other words, you do not need to create a new pull request
-when asked to make changes.
+### Mind the whitespace
 
-#### Participate in Reviews
+Please carefully follow the whitespace and formatting conventions already
+present in the framework.
 
-Helping to review pull requests is another great way to contribute. Your feedback
-can help to shape the implementation of new features. When reviewing pull requests,
-however, please refrain from approving or rejecting a PR unless you are a core
-committer for the Spring Framework.
+1. Tabs, not spaces
+1. Unix (LF), not DOS (CRLF) line endings
+1. Eliminate all trailing whitespace
+1. Wrap Javadoc at 90 characters
+1. Aim to wrap code at 90 characters, but favor readability over wrapping
+1. Preserve existing formatting; i.e. do not reformat code for its own sake
+1. Search the codebase using `git grep` and other tools to discover common
+    naming conventions, etc.
+1. Latin-1 (ISO-8859-1) encoding for Java sources; use `native2ascii` to convert
+    if necessary
 
-### Build from Source
 
-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source)
-wiki page for instructions on how to check out, build, and import the Spring Framework
-source code into your IDE.
+### Add Apache license header to all new classes
 
-### Source Code Style
+```java
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
-The wiki pages
-[Code Style](https://github.com/spring-projects/spring-framework/wiki/Code-Style) and
-[IntelliJ IDEA Editor Settings](https://github.com/spring-projects/spring-framework/wiki/IntelliJ-IDEA-Editor-Settings)
-define the source file coding standards we use along with some IDEA editor settings we customize.
+package ...;
+```
 
-### Reference Docs
+### Update Apache license header in modified files as necessary
 
-The reference documentation is authored in [Asciidoctor](https://asciidoctor.org/) format
-using [Antora](https://docs.antora.org/antora/latest/). The source files for the documentation
-reside in the [framework-docs/modules/ROOT](framework-docs/modules/ROOT) directory. For
-trivial changes, you may be able to browse, edit source files, and submit directly from GitHub.
+Always check the date range in the license header. For example, if you've
+modified a file in 2014 whose header still reads:
 
-When making changes locally, execute `./gradlew antora` and then browse the results under
-`framework-docs/build/site/index.html`.
+```java
+ * Copyright 2002-2011 the original author or authors.
+```
 
-Asciidoctor also supports live editing. For more details see
-[AsciiDoc Tooling](https://docs.asciidoctor.org/asciidoctor/latest/tooling/).
+Then be sure to update it to 2014 accordingly:
+
+```java
+ * Copyright 2002-2014 the original author or authors.
+```
+
+### Use @since tags for newly-added public API types and methods
+
+For example:
+
+```java
+/**
+ * ...
+ *
+ * @author First Last
+ * @since 4.0
+ * @see ...
+ */
+```
+
+## Prepare Your Commit
+
+### Submit JUnit test cases for all behavior changes
+
+Search the codebase to find related tests and add additional `@Test` methods
+as appropriate. It is also acceptable to submit test cases on a per JIRA issue
+basis, for example:
+
+```java
+package org.springframework.beans.factory.support;
+
+/**
+ * Unit tests for SPR-8954, in which a custom {@link InstantiationAwareBeanPostProcessor}
+ * forces the predicted type of a FactoryBean, effectively preventing retrieval of the
+ * bean from calls to #getBeansOfType(FactoryBean.class). The implementation of
+ * {@link AbstractBeanFactory#isFactoryBean(String, RootBeanDefinition)} now ensures
+ * that not only the predicted bean type is considered, but also the original bean
+ * definition's beanClass.
+ *
+ * @author Chris Beams
+ */
+public class Spr8954Tests {
+
+    @Test
+    public void cornerSpr8954() {
+        // ...
+    }
+}
+```
+
+
+### Squash commits
+
+Use `git rebase --interactive --autosquash`, `git add --patch`, and other tools
+to "squash" multiple commits into a single atomic commit. In addition to the man
+pages for git, there are many resources online to help you understand how these
+tools work. The [Rewriting History section of Pro Git][] provides a good overview.
+
+
+### Use real name in git commits
+
+Please configure git to use your real first and last name for any commits you
+intend to submit as pull requests. For example, this is not acceptable:
+
+    Author: Nickname <user@mail.com>
+
+Rather, please include your first and last name, properly capitalized, as
+submitted against the SpringSource contributor license agreement:
+
+    Author: First Last <user@mail.com>
+
+This helps ensure traceability against the CLA and also goes a long way to
+ensuring useful output from tools like `git shortlog` and others.
+
+You can configure this via the account admin area in GitHub (useful for
+fork-and-edit cases); _globally_ on your machine with
+
+    git config --global user.name "First Last"
+    git config --global user.email user@mail.com
+
+or _locally_ for the `spring-framework` repository only by omitting the
+'--global' flag:
+
+    cd spring-framework
+    git config user.name "First Last"
+    git config user.email user@mail.com
+
+
+### Format commit messages
+
+Please read and follow the [Commit Guidelines section of Pro Git][].
+
+Most importantly, please format your commit messages in the following way
+(adapted from the commit template in the link above):
+
+    Short (50 chars or less) summary of changes
+
+    More detailed explanatory text, if necessary. Wrap it to about 72
+    characters or so. In some contexts, the first line is treated as the
+    subject of an email and the rest of the text as the body. The blank
+    line separating the summary from the body is critical (unless you omit
+    the body entirely); tools like rebase can get confused if you run the
+    two together.
+
+    Further paragraphs come after blank lines.
+
+     - Bullet points are okay, too
+
+     - Typically a hyphen or asterisk is used for the bullet, preceded by a
+       single space, with blank lines in between, but conventions vary here
+
+    Issue: SPR-1234, SPR-1235
+
+
+1. Use imperative statements in the subject line, e.g. "Fix broken Javadoc link"
+1. Begin the subject line with a capitalized verb, e.g. "Add, Prune, Fix,
+    Introduce, Avoid, etc."
+1. Do not end the subject line with a period
+1. Restrict the subject line to 50 characters or less if possible
+1. Wrap lines in the body at 72 characters or less
+1. Mention associated JIRA issue(s) at the end of the commit comment, prefixed
+    with "Issue: " as above
+1. In the body of the commit message, explain how things worked before this
+    commit, what has changed, and how things work now
+
+For examples of this style, issue a `git log --author=cbeams` in the
+`spring-framework` git repository. For convenience, here are several such commits:
+
+- https://github.com/spring-projects/spring-framework/commit/08e2669b84ec0faa2f7904441fe39ac70b65b078
+- https://github.com/spring-projects/spring-framework/commit/1d9d3e6ff79ce9f0eca03b02cd1df705925575da
+- https://github.com/spring-projects/spring-framework/commit/8e0b1c3a5f957af3049cfa0438317177e16d6de6
+- https://github.com/spring-projects/spring-framework/commit/b787a68f2050df179f7036b209aa741230a02477
+
+## Run the Final Checklist
+
+### Run all tests prior to submission
+
+See the [building from source][] section of the `README` for instructions. Make
+sure that all tests pass prior to submitting your pull request.
+
+
+### Submit your pull request
+
+Subject line:
+
+Follow the same conventions for pull request subject lines as mentioned above
+for commit message subject lines.
+
+In the body:
+
+1. Explain your use case. What led you to submit this change? Why were existing
+    mechanisms in the framework insufficient? Make a case that this is a
+    general-purpose problem and that yours is a general-purpose solution, etc.
+1. Add any additional information and ask questions; start a conversation or
+    continue one from JIRA
+1. Mention the JIRA issue ID
+1. Also mention that you have submitted the CLA as described above
+
+Note that for pull requests containing a single commit, GitHub will default the
+subject line and body of the pull request to match the subject line and body of
+the commit message. This is fine, but please also include the items above in the
+body of the request.
+
+
+### Mention your pull request on the associated JIRA issue
+
+Add a comment to the associated JIRA issue(s) linking to your new pull request.
+
+
+### Expect discussion and rework
+
+The Spring team takes a very conservative approach to accepting contributions to
+the framework. This is to keep code quality and stability as high as possible,
+and to keep complexity at a minimum. Your changes, if accepted, may be heavily
+modified prior to merging. You will retain "Author:" attribution for your Git
+commits granted that the bulk of your changes remain intact. You may be asked to
+rework the submission for style (as explained above) and/or substance. Again, we
+strongly recommend discussing any serious submissions with the Spring Framework 
+team _prior_ to engaging in serious development work.
+
+Note that you can always force push (`git push -f`) reworked / rebased commits
+against the branch used to submit your pull request. In other words, you do not
+need to issue a new pull request when asked to make changes.
+
+[help documentation]: http://help.github.com/send-pull-requests
+[JIRA issue tracker]: https://jira.spring.io/browse/SPR
+[spring-framework-contrib]: https://groups.google.com/forum/#!forum/spring-framework-contrib
+[SpringSource CLA form]: https://support.springsource.com/spring_committer_signup
+[fork-and-edit]: https://github.com/blog/844-forking-with-the-edit-button
+[Spring Framework Code Style]: https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Code-Style
+[Rewriting History section of Pro Git]: http://git-scm.com/book/en/Git-Tools-Rewriting-History
+[Commit Guidelines section of Pro Git]: http://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines
+[building from source]: https://github.com/spring-projects/spring-framework#building-from-source

LICENSE.txt

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        https://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       https://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

README.md

@@ -1,38 +1,101 @@
-# <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)
+## Spring Framework
+The Spring Framework provides a comprehensive programming and configuration
+model for modern Java-based enterprise applications - on any kind of deployment
+platform. A key element of Spring is infrastructural support at the application
+level: Spring focuses on the "plumbing" of enterprise applications so that teams
+can focus on application-level business logic, without unnecessary ties to
+specific deployment environments.
 
-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". 
+The framework also serves as the foundation for [Spring Integration][], [Spring
+Batch][] and the rest of the Spring [family of projects][]. Browse the repositories
+under the [Spring organization][] on GitHub for a full list.
 
-Spring provides everything required beyond the Java programming language for creating enterprise applications for a wide range of scenarios and architectures. Please read the [Overview](https://docs.spring.io/spring-framework/reference/overview.html) section of the reference documentation for a more complete introduction.
-
-## 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.
-
-## Access to Binaries
-
-For access to artifacts or a distribution zip, see the [Spring Framework Artifacts](https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Artifacts) wiki page.
+## Downloading Artifacts
+See [downloading Spring artifacts][] for Maven repository information. Unable to
+use Maven or other transitive dependency management tools? See [building a
+distribution with dependencies][].
 
 ## Documentation
+See the current [Javadoc][] and [reference docs][].
 
-The Spring Framework maintains reference documentation ([published](https://docs.spring.io/spring-framework/reference/) and [source](framework-docs/modules/ROOT)), GitHub [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
-[API reference](https://docs.spring.io/spring-framework/docs/current/javadoc-api/). There are also [guides and tutorials](https://spring.io/guides) across Spring projects.
+## Getting Support
+Check out the [Spring forums][] and the [spring][spring tag] and
+[spring-mvc][spring-mvc tag] tags on [Stack Overflow][]. [Commercial support][]
+is available too.
 
-## Micro-Benchmarks
+## Issue Tracking
+Report issues via the [Spring Framework JIRA]. Understand our issue management
+process by reading about [the lifecycle of an issue][]. Think you've found a
+bug? Please consider submitting a reproduction project via the
+[spring-framework-issues][] GitHub repository. The [readme][] there provides
+simple step-by-step instructions.
 
-See the [Micro-Benchmarks](https://github.com/spring-projects/spring-framework/wiki/Micro-Benchmarks) wiki page.
+## Building from Source
+The Spring Framework uses a [Gradle][]-based build system. In the instructions
+below, [`./gradlew`][] is invoked from the root of the source tree and serves as
+a cross-platform, self-contained bootstrap mechanism for the build.
 
-## Build from Source
+### Prerequisites
 
-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source) wiki page and the [CONTRIBUTING.md](CONTRIBUTING.md) file.
+[Git][] and [JDK 8 update 20 or later][JDK8 build]
 
-## Continuous Integration Builds
+Be sure that your `JAVA_HOME` environment variable points to the `jdk1.8.0` folder
+extracted from the JDK download.
 
-Information regarding CI builds can be found in the [Spring Framework Concourse pipeline](ci/README.adoc) documentation.
+### Check out sources
+`git clone git@github.com:spring-projects/spring-framework.git`
 
-## Stay in Touch
+### Import sources into your IDE
+Run `./import-into-eclipse.sh` or read `import-into-idea.md` as appropriate.
+> **Note:** Per the prerequisites above, ensure that you have JDK 8 configured properly in your IDE.
 
-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).
+### Install all spring-\* jars into your local Maven cache
+`./gradlew install`
+
+### Compile and test; build all jars, distribution zips, and docs
+`./gradlew build`
+
+... and discover more commands with `./gradlew tasks`. See also the [Gradle
+build and release FAQ][].
+
+## Contributing
+[Pull requests][] are welcome; see the [contributor guidelines][] for details.
+
+## Staying in Touch
+Follow [@SpringCentral][] as well as [@SpringFramework][] and its [team members][]
+on Twitter. In-depth articles can be found at [The Spring Blog][], and releases
+are announced via our [news feed][].
 
 ## License
+The Spring Framework is released under version 2.0 of the [Apache License][].
 
-The Spring Framework is released under version 2.0 of the [Apache License](https://www.apache.org/licenses/LICENSE-2.0).
+[Spring Integration]: https://github.com/spring-projects/spring-integration
+[Spring Batch]: https://github.com/spring-projects/spring-batch
+[family of projects]: http://spring.io/projects
+[Spring organization]: https://github.com/spring-projects
+[downloading Spring artifacts]: https://github.com/spring-projects/spring-framework/wiki/Downloading-Spring-artifacts
+[building a distribution with dependencies]: https://github.com/spring-projects/spring-framework/wiki/Building-a-distribution-with-dependencies
+[Javadoc]: http://docs.spring.io/spring-framework/docs/current/javadoc-api/
+[reference docs]: http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/
+[Spring forums]: http://forum.spring.io/
+[spring tag]: http://stackoverflow.com/questions/tagged/spring
+[spring-mvc tag]: http://stackoverflow.com/questions/tagged/spring-mvc
+[Stack Overflow]: http://stackoverflow.com/faq
+[Commercial support]: http://spring.io/services
+[Spring Framework JIRA]: https://jira.spring.io/browse/SPR
+[the lifecycle of an issue]: https://github.com/spring-projects/spring-framework/wiki/The-Lifecycle-of-an-Issue
+[spring-framework-issues]: https://github.com/spring-projects/spring-framework-issues#readme
+[readme]: https://github.com/spring-projects/spring-framework-issues#readme
+[Gradle]: http://gradle.org
+[`./gradlew`]: http://vimeo.com/34436402
+[Git]: http://help.github.com/set-up-git-redirect
+[JDK8 build]: http://www.oracle.com/technetwork/java/javase/downloads
+[Gradle build and release FAQ]: https://github.com/spring-projects/spring-framework/wiki/Gradle-build-and-release-FAQ
+[Pull requests]: http://help.github.com/send-pull-requests
+[contributor guidelines]: https://github.com/spring-projects/spring-framework/blob/master/CONTRIBUTING.md
+[@SpringFramework]: https://twitter.com/springframework
+[@SpringCentral]: https://twitter.com/springcentral
+[team members]: https://twitter.com/springframework/lists/team/members
+[The Spring Blog]: http://spring.io/blog/
+[news feed]: http://spring.io/blog/category/news
+[Apache License]: http://www.apache.org/licenses/LICENSE-2.0

SECURITY.md

@@ -1,16 +0,0 @@
-# Security Policy
-
-## JAR signing
-
-Spring Framework JARs released on Maven Central are signed.
-You'll find more information about the key here: https://spring.io/GPG-KEY-spring.txt
-
-## Supported Versions
-
-Please see the
-[Spring Framework Versions](https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Versions)
-wiki page.
-
-## Reporting a Vulnerability
-
-Please see https://spring.io/security-policy.

buildSrc/README.md

@@ -1,60 +0,0 @@
-# Spring Framework Build
-
-This folder contains the custom plugins and conventions for the Spring Framework build.
-They are declared in the `build.gradle` file in this folder.
-
-## Build Conventions
-
-The `org.springframework.build.conventions` plugin applies all conventions to the Framework build:
-
-* Configuring the Java compiler, see `JavaConventions`
-* Configuring the Kotlin compiler, see `KotlinConventions`
-* Configuring testing in the build with `TestConventions` 
-
-
-## Build Plugins
-
-### Optional dependencies
-
-The `org.springframework.build.optional-dependencies` plugin creates a new `optional`
-Gradle configuration - it adds the dependencies to the project's compile and runtime classpath
-but doesn't affect the classpath of dependent projects.
-This plugin does not provide a `provided` configuration, as the native `compileOnly` and `testCompileOnly`
-configurations are preferred.
-
-
-### RuntimeHints Java Agent
-
-The `spring-core-test` project module contributes the `RuntimeHintsAgent` Java agent.
-
-The `RuntimeHintsAgentPlugin` Gradle plugin creates a dedicated `"runtimeHintsTest"` test task for each project.
-This task will detect and execute [tests tagged](https://junit.org/junit5/docs/current/user-guide/#running-tests-build-gradle)
-with the `"RuntimeHintsTests"` [JUnit tag](https://junit.org/junit5/docs/current/user-guide/#running-tests-tags).
-In the Spring Framework test suite, those are usually annotated with the `@EnabledIfRuntimeHintsAgent` annotation.
-
-By default, the agent will instrument all classes located in the `"org.springframework"` package, as they are loaded.
-The `RuntimeHintsAgentExtension` allows to customize this using a DSL:
-
-```groovy
-// this applies the `RuntimeHintsAgentPlugin` to the project
-plugins {
-	id 'org.springframework.build.runtimehints-agent'
-}
-
-// You can configure the agent to include and exclude packages from the instrumentation process.
-runtimeHintsAgent {
-	includedPackages = ["org.springframework", "io.spring"]
-	excludedPackages = ["org.example"]
-}
-
-dependencies {
-    // to use the test infrastructure, the project should also depend on the "spring-core-test" module
-	testImplementation(project(":spring-core-test"))
-}
-```
-
-With this configuration, `./gradlew runtimeHintsTest` will run all tests instrumented by this java agent.
-The global `./gradlew check` task depends on `runtimeHintsTest`.            
-
-NOTE: the "spring-core-test" module doesn't shade "spring-core" by design, so the agent should never instrument
-code that doesn't have "spring-core" on its classpath.

buildSrc/build.gradle

@@ -1,48 +0,0 @@
-plugins {
-	id 'java-gradle-plugin'
-	id 'checkstyle'
-}
-
-repositories {
-	mavenCentral()
-	gradlePluginPortal()
-}
-
-ext {
-	def propertiesFile = new File(new File("$projectDir").parentFile, "gradle.properties")
-	propertiesFile.withInputStream {
-		def properties = new Properties()
-		properties.load(it)
-		set("kotlinVersion", properties["kotlinVersion"])
-	}
-}
-
-dependencies {
-	checkstyle "io.spring.javaformat:spring-javaformat-checkstyle:${javaFormatVersion}"
-	implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
-	implementation "org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}"
-	implementation "org.gradle:test-retry-gradle-plugin:1.5.6"
-	implementation "io.spring.javaformat:spring-javaformat-gradle-plugin:${javaFormatVersion}"
-	implementation "io.spring.nohttp:nohttp-gradle:0.0.11"
-}
-
-gradlePlugin {
-	plugins {
-		conventionsPlugin {
-			id = "org.springframework.build.conventions"
-			implementationClass = "org.springframework.build.ConventionsPlugin"
-		}
-		localDevPlugin {
-			id = "org.springframework.build.localdev"
-			implementationClass = "org.springframework.build.dev.LocalDevelopmentPlugin"
-		}
-		optionalDependenciesPlugin {
-			id = "org.springframework.build.optional-dependencies"
-			implementationClass = "org.springframework.build.optional.OptionalDependenciesPlugin"
-		}
-		runtimeHintsAgentPlugin {
-			id = "org.springframework.build.runtimehints-agent"
-			implementationClass = "org.springframework.build.hint.RuntimeHintsAgentPlugin"
-		}
-	}
-}

buildSrc/config/checkstyle/checkstyle.xml

@@ -1,27 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN" "https://checkstyle.org/dtds/configuration_1_3.dtd">
-<module name="com.puppycrawl.tools.checkstyle.Checker">
-
-	<!-- Root Checks -->
-	<module name="io.spring.javaformat.checkstyle.check.SpringHeaderCheck">
-		<property name="fileExtensions" value="java"/>
-		<property name="headerType" value="apache2"/>
-		<property name="headerCopyrightPattern" value="20\d\d-20\d\d"/>
-		<property name="packageInfoHeaderType" value="none"/>
-	</module>
-	<module name="com.puppycrawl.tools.checkstyle.checks.NewlineAtEndOfFileCheck"/>
-
-	<!-- TreeWalker Checks -->
-	<module name="com.puppycrawl.tools.checkstyle.TreeWalker">
-
-		<!-- Imports -->
-		<module name="com.puppycrawl.tools.checkstyle.checks.imports.UnusedImportsCheck">
-			<property name="processJavadoc" value="true"/>
-		</module>
-
-		<!-- Modifiers -->
-		<module name="com.puppycrawl.tools.checkstyle.checks.modifier.ModifierOrderCheck"/>
-
-	</module>
-
-</module>

buildSrc/gradle.properties

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

buildSrc/src/main/groovy/org/springframework/build/gradle/DetectSplitPackagesPlugin.groovy

@@ -0,0 +1,158 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.TaskAction
+
+
+/**
+ * Gradle plugin that detects identically named, non-empty packages split across multiple
+ * subprojects, e.g. "org.springframework.context.annotation" existing in both spring-core
+ * and spring-aspects. Adds a 'detectSplitPackages' task to the current project's task
+ * collection. If the project already contains a 'check' task (i.e. is a typical Gradle
+ * project with the "java" plugin applied), the 'check' task will be updated to depend on
+ * the execution of 'detectSplitPackages'.
+ *
+ * By default, all subprojects will be scanned. Use the 'projectsToScan' task property to
+ * modify this value. Example usage:
+ *
+ *     apply plugin: 'detect-split-packages // typically applied to root project
+ *
+ *     detectSplitPackages {
+ *         packagesToScan -= project(":spring-xyz") // scan every project but spring-xyz
+ *     }
+ *
+ * @author Rob Winch
+ * @author Glyn Normington
+ * @author Chris Beams
+ */
+public class DetectSplitPackagesPlugin implements Plugin<Project> {
+	public void apply(Project project) {
+		def tasks = project.tasks
+		Task detectSplitPackages = tasks.create("detectSplitPackages", DetectSplitPackagesTask.class)
+		if (tasks.asMap.containsKey("check")) {
+			tasks.getByName("check").dependsOn detectSplitPackages
+		}
+	}
+}
+
+public class DetectSplitPackagesTask extends DefaultTask {
+
+	private static final String JAVA_FILE_SUFFIX = ".java"
+	private static final String PACKAGE_SEPARATOR = "."
+	private static final String HIDDEN_DIRECTORY_PREFIX = "."
+
+	@Input
+	Set<Project> projectsToScan = project.subprojects
+
+	public DetectSplitPackagesTask() {
+		this.group = "Verification"
+		this.description = "Detects packages split across two or more subprojects."
+	}
+
+	@TaskAction
+	public void detectSplitPackages() {
+		def splitPackages = doDetectSplitPackages()
+		if (!splitPackages.isEmpty()) {
+			def message = "The following split package(s) have been detected:\n"
+			splitPackages.each { pkg, mod ->
+				message += " - ${pkg} (split across ${mod[0].name} and ${mod[1].name})\n"
+			}
+			throw new GradleException(message)
+		}
+	}
+
+	private Map<String, List<Project>> doDetectSplitPackages() {
+		def splitPackages = [:]
+		def mergedProjects = findMergedProjects()
+		def packagesByProject = mapPackagesByProject()
+
+		def projects = packagesByProject.keySet().toArray()
+		def nProjects = projects.length
+
+		for (int i = 0; i < nProjects - 1; i++) {
+			for (int j = i + 1; j < nProjects - 1; j++) {
+				def prj_i = projects[i]
+				def prj_j = projects[j]
+
+				def pkgs_i = new HashSet(packagesByProject.get(prj_i))
+				def pkgs_j = packagesByProject.get(prj_j)
+				pkgs_i.retainAll(pkgs_j)
+
+				if (!pkgs_i.isEmpty()
+						&& mergedProjects.get(prj_i) != prj_j
+						&& mergedProjects.get(prj_j) != prj_i) {
+					pkgs_i.each { pkg ->
+						def readablePkg = pkg.substring(1).replaceAll(File.separator, PACKAGE_SEPARATOR)
+						splitPackages[readablePkg] = [prj_i, prj_j]
+					}
+				}
+			}
+		}
+		return splitPackages;
+	}
+
+	private Map<Project, Set<String>> mapPackagesByProject() {
+		def packagesByProject = [:]
+		this.projectsToScan.each { Project p ->
+			def packages = new HashSet<String>()
+			p.sourceSets.main.java.srcDirs.each { File dir ->
+				findPackages(packages, dir, "")
+			}
+			if (!packages.isEmpty()) {
+				packagesByProject.put(p, packages)
+			}
+		}
+		return packagesByProject;
+	}
+
+	private Map<Project, Project> findMergedProjects() {
+		def mergedProjects = [:]
+		this.projectsToScan.findAll { p ->
+			p.plugins.findPlugin(MergePlugin)
+		}.findAll { p ->
+			p.merge.into
+		}.each { p ->
+			mergedProjects.put(p, p.merge.into)
+		}
+		return mergedProjects
+	}
+
+	private static void findPackages(Set<String> packages, File dir, String packagePath) {
+		def scanDir = new File(dir, packagePath)
+		def File[] javaFiles = scanDir.listFiles({ file ->
+			!file.isDirectory() && file.name.endsWith(JAVA_FILE_SUFFIX)
+		} as FileFilter)
+
+		if (javaFiles != null && javaFiles.length != 0) {
+			packages.add(packagePath)
+		}
+
+		scanDir.listFiles({ File file ->
+			file.isDirectory() && !file.name.startsWith(HIDDEN_DIRECTORY_PREFIX)
+		} as FileFilter).each { File subDir ->
+			findPackages(packages, dir, packagePath + File.separator + subDir.name)
+		}
+	}
+}
+

buildSrc/src/main/groovy/org/springframework/build/gradle/MergePlugin.groovy

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.*
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.ProjectDependency;
+import org.gradle.api.artifacts.maven.Conf2ScopeMapping
+import org.gradle.api.plugins.MavenPlugin
+import org.gradle.plugins.ide.eclipse.EclipsePlugin
+import org.gradle.plugins.ide.idea.IdeaPlugin
+import org.gradle.api.invocation.*
+
+/**
+ * Gradle plugin that allows projects to merged together. Primarily developed to
+ * allow Spring to support multiple incompatible versions of third-party
+ * dependencies (for example Hibernate v3 and v4).
+ * <p>
+ * The 'merge' extension should be used to define how projects are merged, for example:
+ * <pre class="code">
+ * configure(subprojects) {
+ *     apply plugin: MergePlugin
+ * }
+ *
+ * project("myproject") {
+ * }
+ *
+ * project("myproject-extra") {
+ *     merge.into = project("myproject")
+ * }
+ * </pre>
+ * <p>
+ * This plugin adds two new configurations:
+ * <ul>
+ * <li>merging - Contains the projects being merged into this project<li>
+ * <li>runtimeMerge - Contains all dependencies that are merge projects. These are used
+ * to allow an IDE to reference merge projects.</li>
+ * <ul>
+ *
+ * @author Rob Winch
+ * @author Phillip Webb
+ */
+class MergePlugin implements Plugin<Project> {
+
+	private static boolean attachedProjectsEvaluated;
+
+	public void apply(Project project) {
+		project.plugins.apply(MavenPlugin)
+		project.plugins.apply(EclipsePlugin)
+		project.plugins.apply(IdeaPlugin)
+
+		MergeModel model = project.extensions.create("merge", MergeModel)
+		project.configurations.create("merging")
+		Configuration runtimeMerge = project.configurations.create("runtimeMerge")
+
+		// Ensure the IDE can reference merged projects
+		project.eclipse.classpath.plusConfigurations += [ runtimeMerge ]
+		project.idea.module.scopes.PROVIDED.plus += [ runtimeMerge ]
+
+		// Hook to perform the actual merge logic
+		project.afterEvaluate{
+			if (it.merge.into != null) {
+				setup(it)
+			}
+		}
+
+		// Hook to build runtimeMerge dependencies
+		if (!attachedProjectsEvaluated) {
+			project.gradle.projectsEvaluated{
+				postProcessProjects(it)
+			}
+			attachedProjectsEvaluated  = true;
+		}
+	}
+
+	private void setup(Project project) {
+		project.merge.into.dependencies.add("merging", project)
+		project.dependencies.add("provided", project.merge.into.sourceSets.main.output)
+		project.dependencies.add("runtimeMerge", project.merge.into)
+		setupTaskDependencies(project)
+		setupMaven(project)
+	}
+
+	private void setupTaskDependencies(Project project) {
+		// invoking a task will invoke the task with the same name on 'into' project
+		["sourcesJar", "jar", "javadocJar", "javadoc", "install", "artifactoryPublish"].each {
+			def task = project.tasks.findByPath(it)
+			if (task) {
+				task.enabled = false
+				task.dependsOn(project.merge.into.tasks.findByPath(it))
+			}
+		}
+
+		// update 'into' project artifacts to contain the source artifact contents
+		project.merge.into.sourcesJar.from(project.sourcesJar.source)
+		project.merge.into.jar.from(project.sourceSets.main.output)
+		project.merge.into.javadoc {
+			source += project.javadoc.source
+			classpath += project.javadoc.classpath
+		}
+	}
+
+	private void setupMaven(Project project) {
+		project.configurations.each { configuration ->
+			Conf2ScopeMapping mapping = project.conf2ScopeMappings.getMapping([configuration])
+			if (mapping.scope) {
+				Configuration intoConfiguration = project.merge.into.configurations.create(
+					project.name + "-" + configuration.name)
+				configuration.excludeRules.each {
+					configuration.exclude([
+						(ExcludeRule.GROUP_KEY) : it.group,
+						(ExcludeRule.MODULE_KEY) : it.module])
+				}
+				configuration.dependencies.each {
+					def intoCompile = project.merge.into.configurations.getByName("compile")
+					// Protect against changing a compile scope dependency (SPR-10218)
+					if (!intoCompile.dependencies.contains(it)) {
+						intoConfiguration.dependencies.add(it)
+					}
+				}
+				project.merge.into.install.repositories.mavenInstaller.pom.scopeMappings.addMapping(
+					mapping.priority + 100, intoConfiguration, mapping.scope)
+			}
+		}
+	}
+
+	private postProcessProjects(Gradle gradle) {
+		gradle.allprojects(new Action<Project>() {
+			public void execute(Project project) {
+				project.configurations.getByName("runtime").allDependencies.withType(ProjectDependency).each{
+					Configuration dependsOnMergedFrom = it.dependencyProject.configurations.getByName("merging");
+					dependsOnMergedFrom.dependencies.each{ dep ->
+						project.dependencies.add("runtimeMerge", dep.dependencyProject)
+					}
+				}
+			}
+		});
+	}
+}
+
+class MergeModel {
+	Project into;
+}

buildSrc/src/main/groovy/org/springframework/build/gradle/TestSourceSetDependenciesPlugin.groovy

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ProjectDependency;
+
+/**
+ * Gradle plugin that automatically updates testCompile dependencies to include
+ * the test source sets of project dependencies.
+ *
+ * @author Phillip Webb
+ */
+class TestSourceSetDependenciesPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.afterEvaluate {
+			Set<ProjectDependency> projectDependencies = new LinkedHashSet<ProjectDependency>()
+			collectProjectDependencies(projectDependencies, project)
+			projectDependencies.each {
+				project.dependencies.add("testCompile", it.dependencyProject.sourceSets.test.output)
+			}
+		}
+	}
+
+	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies, Project project) {
+		for (def configurationName in ["compile", "optional", "provided", "testCompile"]) {
+			Configuration configuration = project.getConfigurations().findByName(configurationName)
+			if (configuration) {
+				configuration.dependencies.findAll { it instanceof ProjectDependency }.each {
+					projectDependencies.add(it)
+					collectProjectDependencies(projectDependencies, it.dependencyProject)
+				}
+			}
+		}
+	}
+
+}

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

@@ -1,79 +0,0 @@
-/*
- * Copyright 2002-2025 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build;
-
-import java.io.File;
-import java.nio.file.Path;
-import java.util.List;
-
-import io.spring.javaformat.gradle.SpringJavaFormatPlugin;
-import io.spring.nohttp.gradle.NoHttpExtension;
-import io.spring.nohttp.gradle.NoHttpPlugin;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.DependencySet;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.quality.Checkstyle;
-import org.gradle.api.plugins.quality.CheckstyleExtension;
-import org.gradle.api.plugins.quality.CheckstylePlugin;
-
-/**
- * {@link Plugin} that applies conventions for checkstyle.
- *
- * @author Brian Clozel
- */
-public class CheckstyleConventions {
-
-	/**
-	 * Applies the Spring Java Format and Checkstyle plugins with the project conventions.
-	 * @param project the current project
-	 */
-	public void apply(Project project) {
-		project.getPlugins().withType(JavaBasePlugin.class, (java) -> {
-			if (project.getRootProject() == project) {
-				configureNoHttpPlugin(project);
-			}
-			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.22.0");
-			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));
-		});
-	}
-
-	private static void configureNoHttpPlugin(Project project) {
-		project.getPlugins().apply(NoHttpPlugin.class);
-		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/**", "buildSrc/build/**");
-		List<String> buildFolders = List.of("bin", "build", "out");
-		project.allprojects(subproject -> {
-			Path rootPath = project.getRootDir().toPath();
-			Path projectPath = rootPath.relativize(subproject.getProjectDir().toPath());
-			for (String buildFolder : buildFolders) {
-				Path innerBuildDir = projectPath.resolve(buildFolder);
-				noHttp.getSource().exclude(innerBuildDir + File.separator + "**");
-			}
-		});
-	}
-
-}

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

@@ -1,45 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin;
-
-/**
- * Plugin to apply conventions to projects that are part of Spring Framework's build.
- * Conventions are applied in response to various plugins being applied.
- *
- * <p>When the {@link JavaBasePlugin} is applied, the conventions in {@link CheckstyleConventions},
- * {@link TestConventions} and {@link JavaConventions} are applied.
- * When the {@link KotlinBasePlugin} is applied, the conventions in {@link KotlinConventions}
- * are applied.
- *
- * @author Brian Clozel
- */
-public class ConventionsPlugin implements Plugin<Project> {
-
-	@Override
-	public void apply(Project project) {
-		new CheckstyleConventions().apply(project);
-		new JavaConventions().apply(project);
-		new KotlinConventions().apply(project);
-		new TestConventions().apply(project);
-	}
-
-}

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

@@ -1,93 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginExtension;
-import org.gradle.api.tasks.compile.JavaCompile;
-import org.gradle.jvm.toolchain.JavaLanguageVersion;
-import org.gradle.jvm.toolchain.JvmVendorSpec;
-
-/**
- * {@link Plugin} that applies conventions for compiling Java sources in Spring Framework.
- *
- * @author Brian Clozel
- * @author Sam Brannen
- * @author Sebastien Deleuze
- */
-public class JavaConventions {
-
-	private static final List<String> COMPILER_ARGS;
-
-	private static final List<String> TEST_COMPILER_ARGS;
-
-	static {
-		List<String> commonCompilerArgs = Arrays.asList(
-				"-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
-				"-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
-				"-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options",
-				"-parameters"
-		);
-		COMPILER_ARGS = new ArrayList<>();
-		COMPILER_ARGS.addAll(commonCompilerArgs);
-		COMPILER_ARGS.addAll(Arrays.asList(
-				"-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes", "-Xlint:deprecation",
-				"-Xlint:unchecked", "-Werror"
-		));
-		TEST_COMPILER_ARGS = new ArrayList<>();
-		TEST_COMPILER_ARGS.addAll(commonCompilerArgs);
-		TEST_COMPILER_ARGS.addAll(Arrays.asList("-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
-				"-Xlint:-deprecation", "-Xlint:-unchecked"));
-	}
-
-	public void apply(Project project) {
-		project.getPlugins().withType(JavaBasePlugin.class, javaPlugin -> applyJavaCompileConventions(project));
-	}
-
-	/**
-	 * Applies the common Java compiler options for main sources, test fixture sources, and
-	 * test sources.
-	 * @param project the current project
-	 */
-	private void applyJavaCompileConventions(Project project) {
-		project.getExtensions().getByType(JavaPluginExtension.class).toolchain(toolchain -> {
-			toolchain.getVendor().set(JvmVendorSpec.BELLSOFT);
-			toolchain.getLanguageVersion().set(JavaLanguageVersion.of(17));
-		});
-		project.getTasks().withType(JavaCompile.class)
-				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_JAVA_TASK_NAME))
-				.forEach(compileTask -> {
-					compileTask.getOptions().setCompilerArgs(COMPILER_ARGS);
-					compileTask.getOptions().setEncoding("UTF-8");
-				});
-		project.getTasks().withType(JavaCompile.class)
-				.matching(compileTask -> compileTask.getName().equals(JavaPlugin.COMPILE_TEST_JAVA_TASK_NAME)
-						|| compileTask.getName().equals("compileTestFixturesJava"))
-				.forEach(compileTask -> {
-					compileTask.getOptions().setCompilerArgs(TEST_COMPILER_ARGS);
-					compileTask.getOptions().setEncoding("UTF-8");
-				});
-	}
-
-}

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

@@ -1,48 +0,0 @@
-/*
- * Copyright 2002-2022 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.gradle.api.Project;
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmOptions;
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile;
-
-/**
- * @author Brian Clozel
- */
-public class KotlinConventions {
-
-	void apply(Project project) {
-		project.getPlugins().withId("org.jetbrains.kotlin.jvm",
-				(plugin) -> project.getTasks().withType(KotlinCompile.class, this::configure));
-	}
-
-	private void configure(KotlinCompile compile) {
-		KotlinJvmOptions kotlinOptions = compile.getKotlinOptions();
-		kotlinOptions.setApiVersion("1.7");
-		kotlinOptions.setLanguageVersion("1.7");
-		kotlinOptions.setJvmTarget("17");
-		kotlinOptions.setJavaParameters(true);
-		kotlinOptions.setAllWarningsAsErrors(true);
-		List<String> freeCompilerArgs = new ArrayList<>(compile.getKotlinOptions().getFreeCompilerArgs());
-		freeCompilerArgs.addAll(List.of("-Xsuppress-version-warnings", "-Xjsr305=strict", "-opt-in=kotlin.RequiresOptIn"));
-		compile.getKotlinOptions().setFreeCompilerArgs(freeCompilerArgs);
-	}
-
-}

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

@@ -1,84 +0,0 @@
-/*
- * Copyright 2002-2024 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build;
-
-import java.util.Map;
-
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.tasks.testing.Test;
-import org.gradle.testretry.TestRetryPlugin;
-import org.gradle.testretry.TestRetryTaskExtension;
-
-/**
- * Conventions that are applied in the presence of the {@link JavaBasePlugin}. When the
- * plugin is applied:
- * <ul>
- * <li>The {@link TestRetryPlugin Test Retry} plugin is applied so that flaky tests
- * are retried 3 times when running on the CI server.
- * </ul>
- *
- * @author Brian Clozel
- * @author Andy Wilkinson
- */
-class TestConventions {
-
-	void apply(Project project) {
-		project.getPlugins().withType(JavaBasePlugin.class, (java) -> configureTestConventions(project));
-	}
-
-	private void configureTestConventions(Project project) {
-		project.getTasks().withType(Test.class,
-				test -> {
-					configureTests(project, test);
-					configureTestRetryPlugin(project, test);
-				});
-	}
-
-	private void configureTests(Project project, Test test) {
-		test.useJUnitPlatform();
-		test.include("**/*Tests.class", "**/*Test.class");
-		test.setSystemProperties(Map.of(
-				"java.awt.headless", "true",
-				"io.netty.leakDetection.level", "paranoid",
-				"io.netty5.leakDetectionLevel", "paranoid",
-				"io.netty5.leakDetection.targetRecords", "32",
-				"io.netty5.buffer.lifecycleTracingEnabled", "true"
-		));
-		if (project.hasProperty("testGroups")) {
-			test.systemProperty("testGroups", project.getProperties().get("testGroups"));
-		}
-		test.jvmArgs(
-				"--add-opens=java.base/java.lang=ALL-UNNAMED",
-				"--add-opens=java.base/java.util=ALL-UNNAMED",
-				"-Xshare:off"
-		);
-	}
-
-	private void configureTestRetryPlugin(Project project, Test test) {
-		project.getPlugins().withType(TestRetryPlugin.class, testRetryPlugin -> {
-			TestRetryTaskExtension testRetry = test.getExtensions().getByType(TestRetryTaskExtension.class);
-			testRetry.getFailOnPassedAfterRetry().set(true);
-			testRetry.getMaxRetries().set(isCi() ? 3 : 0);
-		});
-	}
-
-	private boolean isCi() {
-		return Boolean.parseBoolean(System.getenv("CI"));
-	}
-
-}

buildSrc/src/main/java/org/springframework/build/dev/LocalDevelopmentPlugin.java

@@ -1,49 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.dev;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaBasePlugin;
-
-/**
- * {@link Plugin} that skips documentation tasks when the {@code "-PskipDocs"} property is defined.
- *
- * @author Brian Clozel
- */
-public class LocalDevelopmentPlugin implements Plugin<Project> {
-
-	private static final String SKIP_DOCS_PROPERTY = "skipDocs";
-
-	@Override
-	public void apply(Project target) {
-		if (target.hasProperty(SKIP_DOCS_PROPERTY)) {
-			skipDocumentationTasks(target);
-			target.subprojects(this::skipDocumentationTasks);
-		}
-	}
-
-	private void skipDocumentationTasks(Project project) {
-		project.afterEvaluate(p -> {
-			p.getTasks().matching(task -> {
-						return JavaBasePlugin.DOCUMENTATION_GROUP.equals(task.getGroup())
-								|| "distribution".equals(task.getGroup());
-					})
-					.forEach(task -> task.setEnabled(false));
-		});
-	}
-}

buildSrc/src/main/java/org/springframework/build/hint/RuntimeHintsAgentArgumentProvider.java

@@ -1,48 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.hint;
-
-import java.util.Collections;
-
-import org.gradle.api.file.ConfigurableFileCollection;
-import org.gradle.api.provider.SetProperty;
-import org.gradle.api.tasks.Classpath;
-import org.gradle.api.tasks.Input;
-import org.gradle.process.CommandLineArgumentProvider;
-
-/**
- * Argument provider for registering the runtime hints agent with a Java process.
- */
-public interface RuntimeHintsAgentArgumentProvider extends CommandLineArgumentProvider {
-
-	@Classpath
-	ConfigurableFileCollection getAgentJar();
-
-    @Input
-    SetProperty<String> getIncludedPackages();
-
-    @Input
-    SetProperty<String> getExcludedPackages();
-
-    @Override
-    default Iterable<String> asArguments() {
-        StringBuilder packages = new StringBuilder();
-        getIncludedPackages().get().forEach(packageName -> packages.append('+').append(packageName).append(','));
-        getExcludedPackages().get().forEach(packageName -> packages.append('-').append(packageName).append(','));
-        return Collections.singleton("-javaagent:" + getAgentJar().getSingleFile() + "=" + packages);
-    }
-}

buildSrc/src/main/java/org/springframework/build/hint/RuntimeHintsAgentExtension.java

@@ -1,30 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.hint;
-
-import org.gradle.api.provider.SetProperty;
-
-/**
- * Entry point to the DSL extension for the {@link RuntimeHintsAgentPlugin} Gradle plugin.
- * @author Brian Clozel
- */
-public interface RuntimeHintsAgentExtension {
-
-	SetProperty<String> getIncludedPackages();
-
-	SetProperty<String> getExcludedPackages();
-}

buildSrc/src/main/java/org/springframework/build/hint/RuntimeHintsAgentPlugin.java

@@ -1,100 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.hint;
-
-import org.gradle.api.JavaVersion;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.attributes.Bundling;
-import org.gradle.api.attributes.Category;
-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;
-
-/**
- * {@link Plugin} that configures the {@code RuntimeHints} Java agent to test tasks.
- *
- * @author Brian Clozel
- * @author Sebastien Deleuze
- */
-public class RuntimeHintsAgentPlugin implements Plugin<Project> {
-
-	public static final String RUNTIMEHINTS_TEST_TASK = "runtimeHintsTest";
-	private static final String EXTENSION_NAME = "runtimeHintsAgent";
-	private static final String CONFIGURATION_NAME = "testRuntimeHintsAgentJar";
-
-
-	@Override
-	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 -> {
-					options.includeTags("RuntimeHintsTests");
-				});
-				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));
-			project.getDependencies().add(CONFIGURATION_NAME, project.project(":spring-core-test"));
-		});
-	}
-
-	private static RuntimeHintsAgentExtension createRuntimeHintsAgentExtension(Project project) {
-		RuntimeHintsAgentExtension agentExtension = project.getExtensions().create(EXTENSION_NAME, RuntimeHintsAgentExtension.class);
-		agentExtension.getIncludedPackages().convention(Collections.singleton("org.springframework"));
-		agentExtension.getExcludedPackages().convention(Collections.emptySet());
-		return agentExtension;
-	}
-
-	private static RuntimeHintsAgentArgumentProvider createRuntimeHintsAgentArgumentProvider(
-			Project project, RuntimeHintsAgentExtension agentExtension) {
-		RuntimeHintsAgentArgumentProvider agentArgumentProvider = project.getObjects().newInstance(RuntimeHintsAgentArgumentProvider.class);
-		agentArgumentProvider.getAgentJar().from(createRuntimeHintsAgentConfiguration(project));
-		agentArgumentProvider.getIncludedPackages().set(agentExtension.getIncludedPackages());
-		agentArgumentProvider.getExcludedPackages().set(agentExtension.getExcludedPackages());
-		return agentArgumentProvider;
-	}
-
-	private static Configuration createRuntimeHintsAgentConfiguration(Project project) {
-		return project.getConfigurations().create(CONFIGURATION_NAME, configuration -> {
-			configuration.setCanBeConsumed(false);
-			configuration.setTransitive(false); // Only the built artifact is required
-			configuration.attributes(attributes -> {
-				attributes.attribute(Bundling.BUNDLING_ATTRIBUTE, project.getObjects().named(Bundling.class, Bundling.EXTERNAL));
-				attributes.attribute(Category.CATEGORY_ATTRIBUTE, project.getObjects().named(Category.class, Category.LIBRARY));
-				attributes.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.getObjects().named(LibraryElements.class, LibraryElements.JAR));
-				attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, Integer.valueOf(JavaVersion.current().getMajorVersion()));
-				attributes.attribute(Usage.USAGE_ATTRIBUTE, project.getObjects().named(Usage.class, Usage.JAVA_RUNTIME));
-			});
-		});
-	}
-}

buildSrc/src/main/java/org/springframework/build/optional/OptionalDependenciesPlugin.java

@@ -1,56 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.optional;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.JavaPluginExtension;
-import org.gradle.api.tasks.SourceSetContainer;
-
-/**
- * A {@code Plugin} that adds support for Maven-style optional dependencies. Creates a new
- * {@code optional} configuration. The {@code optional} configuration is part of the
- * project's compile and runtime classpaths but does not affect the classpath of
- * dependent projects.
- *
- * @author Andy Wilkinson
- */
-public class OptionalDependenciesPlugin implements Plugin<Project> {
-
-	/**
-	 * Name of the {@code optional} configuration.
-	 */
-	public static final String OPTIONAL_CONFIGURATION_NAME = "optional";
-
-	@Override
-	public void apply(Project project) {
-		Configuration optional = project.getConfigurations().create(OPTIONAL_CONFIGURATION_NAME);
-		optional.setCanBeConsumed(false);
-		optional.setCanBeResolved(false);
-		project.getPlugins().withType(JavaBasePlugin.class, (javaBasePlugin) -> {
-			SourceSetContainer sourceSets = project.getExtensions().getByType(JavaPluginExtension.class)
-					.getSourceSets();
-			sourceSets.all((sourceSet) -> {
-				project.getConfigurations().getByName(sourceSet.getCompileClasspathConfigurationName()).extendsFrom(optional);
-				project.getConfigurations().getByName(sourceSet.getRuntimeClasspathConfigurationName()).extendsFrom(optional);
-			});
-		});
-	}
-
-}

buildSrc/src/main/java/org/springframework/build/shadow/ShadowSource.java

@@ -1,191 +0,0 @@
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.build.shadow;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-
-import org.gradle.api.DefaultTask;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.component.ModuleComponentSelector;
-import org.gradle.api.artifacts.query.ArtifactResolutionQuery;
-import org.gradle.api.artifacts.result.ArtifactResolutionResult;
-import org.gradle.api.artifacts.result.ComponentArtifactsResult;
-import org.gradle.api.artifacts.result.DependencyResult;
-import org.gradle.api.artifacts.result.ResolutionResult;
-import org.gradle.api.artifacts.result.ResolvedArtifactResult;
-import org.gradle.api.file.DirectoryProperty;
-import org.gradle.api.file.FileCopyDetails;
-import org.gradle.api.file.FileTree;
-import org.gradle.api.tasks.Classpath;
-import org.gradle.api.tasks.Input;
-import org.gradle.api.tasks.Nested;
-import org.gradle.api.tasks.Optional;
-import org.gradle.api.tasks.OutputDirectory;
-import org.gradle.api.tasks.TaskAction;
-import org.gradle.jvm.JvmLibrary;
-import org.gradle.language.base.artifact.SourcesArtifact;
-
-/**
- * Gradle task to add source from shadowed jars into our own source jars.
- *
- * @author Phillip Webb
- * @author Andy Wilkinson
- */
-public class ShadowSource extends DefaultTask {
-
-	private final DirectoryProperty outputDirectory = getProject().getObjects().directoryProperty();
-
-	private List<Configuration> configurations = new ArrayList<>();
-
-	private final List<Relocation> relocations = new ArrayList<>();
-
-
-	@Classpath
-	@Optional
-	public List<Configuration> getConfigurations() {
-		return this.configurations;
-	}
-
-	public void setConfigurations(List<Configuration> configurations) {
-		this.configurations = configurations;
-	}
-
-	@Nested
-	public List<Relocation> getRelocations() {
-		return this.relocations;
-	}
-
-	public void relocate(String pattern, String destination) {
-		this.relocations.add(new Relocation(pattern, destination));
-	}
-
-	@OutputDirectory
-	DirectoryProperty getOutputDirectory() {
-		return this.outputDirectory;
-	}
-
-	@TaskAction
-	void syncSourceJarFiles() {
-		sync(getSourceJarFiles());
-	}
-
-	private List<File> getSourceJarFiles() {
-		List<File> sourceJarFiles = new ArrayList<>();
-		for (Configuration configuration : this.configurations) {
-			ResolutionResult resolutionResult = configuration.getIncoming().getResolutionResult();
-			resolutionResult.getRootComponent().get().getDependencies().forEach(dependency -> {
-				Set<ComponentArtifactsResult> artifactsResults = resolveSourceArtifacts(dependency);
-				for (ComponentArtifactsResult artifactResult : artifactsResults) {
-					artifactResult.getArtifacts(SourcesArtifact.class).forEach(sourceArtifact -> {
-						sourceJarFiles.add(((ResolvedArtifactResult) sourceArtifact).getFile());
-					});
-				}
-			});
-		}
-		return Collections.unmodifiableList(sourceJarFiles);
-	}
-
-	private Set<ComponentArtifactsResult> resolveSourceArtifacts(DependencyResult dependency) {
-		ModuleComponentSelector componentSelector = (ModuleComponentSelector) dependency.getRequested();
-		ArtifactResolutionQuery query = getProject().getDependencies().createArtifactResolutionQuery()
-				.forModule(componentSelector.getGroup(), componentSelector.getModule(), componentSelector.getVersion());
-		return executeQuery(query).getResolvedComponents();
-	}
-
-	@SuppressWarnings("unchecked")
-	private ArtifactResolutionResult executeQuery(ArtifactResolutionQuery query) {
-		return query.withArtifacts(JvmLibrary.class, SourcesArtifact.class).execute();
-	}
-
-	private void sync(List<File> sourceJarFiles) {
-		getProject().sync(spec -> {
-			spec.into(this.outputDirectory);
-			spec.eachFile(this::relocateFile);
-			spec.filter(this::transformContent);
-			spec.exclude("META-INF/**");
-			spec.setIncludeEmptyDirs(false);
-			sourceJarFiles.forEach(sourceJar -> spec.from(zipTree(sourceJar)));
-		});
-	}
-
-	private void relocateFile(FileCopyDetails details) {
-		String path = details.getPath();
-		for (Relocation relocation : this.relocations) {
-			path = relocation.relocatePath(path);
-		}
-		details.setPath(path);
-	}
-
-	private String transformContent(String content) {
-		for (Relocation relocation : this.relocations) {
-			content = relocation.transformContent(content);
-		}
-		return content;
-	}
-
-	private FileTree zipTree(File sourceJar) {
-		return getProject().zipTree(sourceJar);
-	}
-
-
-	/**
-	 * A single relocation.
-	 */
-	static class Relocation {
-
-		private final String pattern;
-
-		private final String pathPattern;
-
-		private final String destination;
-
-		private final String pathDestination;
-
-
-		Relocation(String pattern, String destination) {
-			this.pattern = pattern;
-			this.pathPattern = pattern.replace('.', '/');
-			this.destination = destination;
-			this.pathDestination = destination.replace('.', '/');
-		}
-
-
-		@Input
-		public String getPattern() {
-			return this.pattern;
-		}
-
-		@Input
-		public String getDestination() {
-			return this.destination;
-		}
-
-		String relocatePath(String path) {
-			return path.replace(this.pathPattern, this.pathDestination);
-		}
-
-		public String transformContent(String content) {
-			return content.replaceAll("\\b" + this.pattern, this.destination);
-		}
-
-	}
-
-}

buildSrc/src/main/resources/META-INF/gradle-plugins/detect-split-packages.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.DetectSplitPackagesPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/merge.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.MergePlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/test-source-set-dependencies.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.TestSourceSetDependenciesPlugin

framework-api/framework-api.gradle

@@ -1,119 +0,0 @@
-plugins {
-	id 'java-platform'
-	id 'io.freefair.aggregate-javadoc' version '8.3'
-}
-
-description = "Spring Framework API Docs"
-
-apply from: "${rootDir}/gradle/publications.gradle"
-
-repositories {
-	maven {
-		url "https://repo.spring.io/release"
-	}
-}
-
-dependencies {
-	moduleProjects.each { moduleProject ->
-		javadoc moduleProject
-	}
-}
-
-javadoc {
-	title = "${rootProject.description} ${version} API"
-	options {
-		encoding = "UTF-8"
-		memberLevel = JavadocMemberLevel.PROTECTED
-		author = true
-		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
-		splitIndex = true
-		links(rootProject.ext.javadocLinks)
-		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
-		addBooleanOption('Werror', true) // fail build on Javadoc warnings
-	}
-	maxMemory = "1024m"
-	doFirst {
-		classpath += files(
-				// ensure the javadoc process can resolve types compiled from .aj sources
-				project(":spring-aspects").sourceSets.main.output
-		)
-		classpath += files(moduleProjects.collect { it.sourceSets.main.compileClasspath })
-	}
-}
-
-/**
- * Produce KDoc for all Spring Framework modules in "build/docs/kdoc"
- */
-rootProject.tasks.dokkaHtmlMultiModule.configure {
-	dependsOn {
-		tasks.named("javadoc")
-	}
-	moduleName.set("spring-framework")
-	outputDirectory.set(project.java.docsDir.dir("kdoc-api").get().asFile)
-	includes.from("$rootProject.rootDir/framework-docs/src/docs/api/dokka-overview.md")
-}
-
-/**
- * Zip all Java docs (javadoc & kdoc) into a single archive
- */
-tasks.register('docsZip', Zip) {
-	dependsOn = ['javadoc', rootProject.tasks.dokkaHtmlMultiModule]
-	group = "distribution"
-	description = "Builds -${archiveClassifier} archive containing api and reference " +
-			"for deployment at https://docs.spring.io/spring-framework/docs/."
-
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("docs")
-	from("src/dist") {
-		include "changelog.txt"
-	}
-	from(javadoc) {
-		into "javadoc-api"
-	}
-	from(rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
-		into "kdoc-api"
-	}
-}
-
-/**
- * Zip all Spring Framework schemas into a single archive
- */
-tasks.register('schemaZip', Zip) {
-	group = "distribution"
-	archiveBaseName.set("spring-framework")
-	archiveClassifier.set("schema")
-	description = "Builds -${archiveClassifier} archive containing all " +
-			"XSDs for deployment at https://springframework.org/schema."
-	duplicatesStrategy DuplicatesStrategy.EXCLUDE
-	moduleProjects.each { module ->
-		def Properties schemas = new Properties();
-
-		module.sourceSets.main.resources.find {
-			(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
-		}?.withInputStream { schemas.load(it) }
-
-		for (def key : schemas.keySet()) {
-			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
-			assert shortName != key
-			File xsdFile = module.sourceSets.main.resources.find {
-				(it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/', '\\\\')))
-			}
-			assert xsdFile != null
-			into(shortName) {
-				from xsdFile.path
-			}
-		}
-	}
-}
-
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			artifact docsZip
-			artifact schemaZip
-		}
-	}
-}

framework-bom/framework-bom.gradle

@@ -1,23 +0,0 @@
-description = "Spring Framework (Bill of Materials)"
-
-apply plugin: 'java-platform'
-apply from: "$rootDir/gradle/publications.gradle"
-
-group = "org.springframework"
-
-dependencies {
-	constraints {
-		parent.moduleProjects.sort { "$it.name" }.each {
-			api it
-		}
-	}
-}
-
-publishing {
-	publications {
-		mavenJava(MavenPublication) {
-			artifactId = 'spring-framework-bom'
-			from components.javaPlatform
-		}
-	}
-}

framework-docs/antora-playbook.yml

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

framework-docs/antora.yml

@@ -1,95 +0,0 @@
-name: framework
-version: true
-title: Spring Framework
-nav:
-  - modules/ROOT/nav.adoc
-ext:
-  collector:
-    run:
-      command: gradlew -q -PbuildSrc.skipTests=true "-Dorg.gradle.jvmargs=-Xmx3g -XX:+HeapDumpOnOutOfMemoryError" :framework-docs:generateAntoraResources
-      local: true
-    scan:
-      dir: ./build/generated-antora-resources
-
-asciidoc:
-  attributes:
-    attribute-missing: 'warn'
-    # FIXME: the copyright is not removed
-    # 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"
-    spring-site-guides: '{spring-site}/guides'
-    spring-site-projects: '{spring-site}/projects'
-    spring-site-tools: "{spring-site}/tools"
-    spring-org: 'spring-projects'
-    spring-github-org: "https://github.com/{spring-org}"
-    spring-framework-github: "https://github.com/{spring-org}/spring-framework"
-    spring-framework-code: '{spring-framework-github}/tree/main'
-    spring-framework-issues: '{spring-framework-github}/issues'
-    spring-framework-wiki: '{spring-framework-github}/wiki'
-    # Docs
-    docs-site: 'https://docs.spring.io'
-    spring-framework-docs-root: '{docs-site}/spring-framework/docs'
-    spring-framework-api: '{spring-framework-docs-root}/{spring-version}/javadoc-api/org/springframework'
-    spring-framework-api-kdoc: '{spring-framework-docs-root}/{spring-version}/kdoc-api'
-    spring-framework-reference: '{spring-framework-docs-root}/{spring-version}/reference'
-    #
-    # Other Spring portfolio projects
-    spring-boot-docs: '{docs-site}/spring-boot/docs/current/reference/html'
-    spring-boot-issues: '{spring-github-org}/spring-boot/issues'
-    # TODO add more projects / links or just build up on {docs-site}?
-    # TODO rename the below using new conventions
-    docs-spring-gemfire: '{docs-site}/spring-gemfire/docs/current/reference'
-    docs-spring-security: '{docs-site}/spring-security/reference'
-    docs-spring-session: '{docs-site}/spring-session/reference'
-    #
-    # External projects URLs and related attributes
-    aspectj-site: 'https://www.eclipse.org/aspectj'
-    aspectj-docs: "{aspectj-site}/doc/released"
-    aspectj-api: "{aspectj-docs}/runtime-api"
-    aspectj-docs-devguide: "{aspectj-docs}/devguide"
-    aspectj-docs-progguide: "{aspectj-docs}/progguide"
-    assertj-docs: 'https://assertj.github.io/doc'
-    baeldung-blog: 'https://www.baeldung.com'
-    bean-validation-site: 'https://beanvalidation.org'
-    graalvm-docs: 'https://www.graalvm.org/22.3/reference-manual'
-    hibernate-validator-site: 'https://hibernate.org/validator/'
-    jackson-docs: 'https://fasterxml.github.io'
-    jackson-github-org: 'https://github.com/FasterXML'
-    java-api: 'https://docs.oracle.com/en/java/javase/17/docs/api'
-    java-tutorial: 'https://docs.oracle.com/javase/tutorial'
-    JSR: 'https://www.jcp.org/en/jsr/detail?id='
-    kotlin-site: 'https://kotlinlang.org'
-    kotlin-docs: '{kotlin-site}/docs'
-    kotlin-api: '{kotlin-site}/api/latest'
-    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'
-    reactor-site: 'https://projectreactor.io'
-    rsocket-github-org: 'https://github.com/rsocket'
-    rsocket-java: '{rsocket-github-org}/rsocket-java'
-    rsocket-java-code: '{rsocket-java}/tree/master/'
-    rsocket-protocol-extensions: '{rsocket-github-org}/rsocket/tree/master/Extensions'
-    rsocket-site: 'https://rsocket.io'
-    rfc-site: 'https://datatracker.ietf.org/doc/html'
-    sockjs-client: 'https://github.com/sockjs/sockjs-client'
-    sockjs-protocol: 'https://github.com/sockjs/sockjs-protocol'
-    sockjs-protocol-site: "https://sockjs.github.io/sockjs-protocol"
-    stackoverflow-site: 'https://stackoverflow.com'
-    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'

framework-docs/framework-docs.gradle

@@ -1,58 +0,0 @@
-plugins {
-	id 'kotlin'
-	id 'io.spring.antora.generate-antora-yml' version '0.0.1'
-	id 'org.antora' version '1.0.0'
-}
-
-description = "Spring Framework Docs"
-
-apply from: "${rootDir}/gradle/ide.gradle"
-apply from: "${rootDir}/gradle/publications.gradle"
-
-antora {
-	options = [clean: true, fetch: !project.gradle.startParameter.offline, stacktrace: true]
-	environment = [
-			'BUILD_REFNAME': 'HEAD',
-			'BUILD_VERSION': project.version,
-	]
-}
-
-tasks.named("generateAntoraYml") {
-	asciidocAttributes = project.provider( {
-		return  ["spring-version": project.version ]
-	} )
-}
-
-tasks.register("generateAntoraResources") {
-	dependsOn 'generateAntoraYml'
-}
-
-jar {
-	enabled = false
-}
-
-javadoc {
-	enabled = false
-}
-
-repositories {
-	maven {
-		url "https://repo.spring.io/release"
-	}
-}
-
-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")
-}

framework-docs/modules/ROOT/assets/images/mvc-context-hierarchy.svg

@@ -1,612 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Generated by Microsoft Visio 11.0, SVG Export, v1.0 spring-overview.svg Page-1 -->
-
-<svg
-   xmlns:v="http://schemas.microsoft.com/visio/2003/SVGExtensions/"
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="6.4728541in"
-   height="5.9522467in"
-   viewBox="0 0 466.04561 428.56238"
-   xml:space="preserve"
-   class="st5"
-   id="svg5499"
-   version="1.1"
-   inkscape:version="0.91 r13725"
-   sodipodi:docname="mvc-splitted-contexts.svg"
-   style="font-size:12px;overflow:visible;color-interpolation-filters:sRGB;fill:none;fill-rule:evenodd;stroke-linecap:square;stroke-miterlimit:3"
-   inkscape:export-filename="/Users/seb/Workspace/spring-framework/src/asciidoc/images/mvc-splitted-contexts.png"
-   inkscape:export-xdpi="90"
-   inkscape:export-ydpi="90"><metadata
-     id="metadata5713"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="https://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
-     id="defs5711"><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker9162"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path9164" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker8834"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path8836" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker8518"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path8520" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker8214"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path8216" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker7922"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path7924" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker7641"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path7644" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker7373"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path7375" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker7117"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path7119" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker6873"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path6875" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker6641"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path6643" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker6421"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path6423" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker6213"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path6215" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker6017"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path6019" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker5833"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path5835" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker5661"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path5663" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker5501"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path5503" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker5353"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path5355" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker5217"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path5219" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker5093"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path5095" /></marker><marker
-       inkscape:isstock="true"
-       style="overflow:visible;"
-       id="marker4981"
-       refX="0.0"
-       refY="0.0"
-       orient="auto"
-       inkscape:stockid="Arrow2Mend"><path
-         transform="scale(0.6) rotate(180) translate(0,0)"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         id="path4983" /></marker><marker
-       inkscape:stockid="Arrow2Mend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow2Mend"
-       style="overflow:visible;"
-       inkscape:isstock="true"
-       inkscape:collect="always"><path
-         id="path7394"
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         transform="scale(0.6) rotate(180) translate(0,0)" /></marker><marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="marker8121"
-       style="overflow:visible;"
-       inkscape:isstock="true"><path
-         id="path8123"
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         transform="scale(1.1) rotate(180) translate(1,0)" /></marker><marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="marker8033"
-       style="overflow:visible;"
-       inkscape:isstock="true"><path
-         id="path8035"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         transform="scale(0.4) rotate(180) translate(10,0)" /></marker><marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="marker7957"
-       style="overflow:visible;"
-       inkscape:isstock="true"><path
-         id="path7959"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         transform="scale(0.4) rotate(180) translate(10,0)" /></marker><marker
-       inkscape:stockid="Arrow1Mend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow1Mend"
-       style="overflow:visible;"
-       inkscape:isstock="true"><path
-         id="path7376"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         transform="scale(0.4) rotate(180) translate(10,0)" /></marker><marker
-       inkscape:stockid="Arrow2Lend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow2Lend"
-       style="overflow:visible;"
-       inkscape:isstock="true"><path
-         id="path7388"
-         style="fill-rule:evenodd;stroke-width:0.625;stroke-linejoin:round;stroke:#000000;stroke-opacity:1"
-         d="M 8.7185878,4.0337352 L -2.2072895,0.016013256 L 8.7185884,-4.0017078 C 6.9730900,-1.6296469 6.9831476,1.6157441 8.7185878,4.0337352 z "
-         transform="scale(1.1) rotate(180) translate(1,0)" /></marker><marker
-       inkscape:stockid="Arrow1Lend"
-       orient="auto"
-       refY="0.0"
-       refX="0.0"
-       id="Arrow1Lend"
-       style="overflow:visible;"
-       inkscape:isstock="true"><path
-         id="path7370"
-         d="M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
-         style="fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1;fill:#000000;fill-opacity:1"
-         transform="scale(0.8) rotate(180) translate(12.5,0)" /></marker></defs><sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1680"
-     inkscape:window-height="1005"
-     id="namedview5709"
-     showgrid="false"
-     inkscape:zoom="1.1640492"
-     inkscape:cx="134.86698"
-     inkscape:cy="203.59898"
-     inkscape:window-x="84"
-     inkscape:window-y="176"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="g5503"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0" /><v:documentProperties
-     v:langID="1033"
-     v:viewMarkup="false" /><style
-     type="text/css"
-     id="style5501"><![CDATA[
-		.st1 {fill:#969696;stroke:#000000;stroke-linecap:round;stroke-linejoin:round;stroke-width:0.24}
-		.st2 {fill:#dde2cd;stroke:#000000;stroke-linecap:round;stroke-linejoin:round;stroke-width:0.24}
-		.st3 {fill:#000000;font-family:Arial;font-size:2.50001em;font-weight:bold}
-		.st4 {font-size:0.333333em;font-weight:normal}
-		.st5 {fill:none;fill-rule:evenodd;font-size:12;overflow:visible;stroke-linecap:square;stroke-miterlimit:3}
-	]]></style><g
-     v:mID="0"
-     v:index="1"
-     v:groupContext="foregroundPage"
-     id="g5503"
-     transform="matrix(0.99998201,0,0,1.0824094,-40.812382,-98.908648)"><rect
-       style="fill:#dde2cd;fill-opacity:1;stroke:#000000;stroke-width:1.53790233;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1"
-       id="rect6599"
-       width="382.68423"
-       height="146.09897"
-       x="87.884865"
-       y="148.26482" /><v:userDefs><v:ud
-         v:nameU="SchemeName"
-         v:val="VT4(Default)" /></v:userDefs><rect
-       style="fill:none;fill-opacity:1;stroke:#000000;stroke-width:1.53790233;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1"
-       id="rect5725"
-       width="464.31128"
-       height="374.11411"
-       x="41.684383"
-       y="112.3262" /><title
-       id="title5505">Page-1</title><v:pageProperties
-       v:drawingScale="0.0393701"
-       v:pageScale="0.0393701"
-       v:drawingUnits="24"
-       v:shadowOffsetX="8.50394"
-       v:shadowOffsetY="-8.50394" /><v:layer
-       v:name="Connector"
-       v:index="0" /><rect
-       style="fill:#dde2cd;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1.53790233;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1"
-       id="rect5715"
-       width="322.8194"
-       height="43.63184"
-       x="119.95335"
-       y="-135.66222"
-       transform="scale(1,-1)" /><text
-       xml:space="preserve"
-       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:30.7580471px;line-height:125%;font-family:sans-serif;-inkscape-font-specification:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       x="168.843"
-       y="124.32391"
-       id="text5717"
-       sodipodi:linespacing="125%"
-       transform="scale(1.0403984,0.96117025)"><tspan
-         sodipodi:role="line"
-         id="tspan5719"
-         x="168.843"
-         y="124.32391"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:23.06853676px;font-family:sans-serif;-inkscape-font-specification:sans-serif">DispatcherServlet</tspan></text>
-<text
-       xml:space="preserve"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       x="89.770851"
-       y="181.20923"
-       id="text6589"
-       sodipodi:linespacing="125%"
-       transform="scale(1.0403984,0.96117025)"><tspan
-         sodipodi:role="line"
-         id="tspan6591"
-         x="89.770851"
-         y="181.20923"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:23.06853676px;font-family:sans-serif;-inkscape-font-specification:sans-serif">Servlet WebApplicationContext</tspan></text>
-<text
-       xml:space="preserve"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       x="260.00443"
-       y="198.41273"
-       id="text6593"
-       sodipodi:linespacing="125%"
-       transform="scale(1.0403984,0.96117025)"><tspan
-         sodipodi:role="line"
-         id="tspan6595"
-         x="260.00443"
-         y="198.41273"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.53426838px;font-family:sans-serif;-inkscape-font-specification:sans-serif;text-align:center;text-anchor:middle">(containing controllers, view resolvers,</tspan><tspan
-         sodipodi:role="line"
-         x="260.00443"
-         y="212.83057"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.53426838px;font-family:sans-serif;-inkscape-font-specification:sans-serif;text-align:center;text-anchor:middle"
-         id="tspan6597">and other web-related beans)</tspan></text>
-<rect
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.86203903;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1"
-       id="rect6620"
-       width="82.040657"
-       height="36.72575"
-       x="114.52653"
-       y="-259.43161"
-       transform="scale(1,-1)" /><rect
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.89166164;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1"
-       id="rect6622"
-       width="87.843979"
-       height="36.697304"
-       x="223.39864"
-       y="-287.19809"
-       transform="scale(1,-1)" /><rect
-       transform="scale(1,-1)"
-       y="-264.81918"
-       x="117.92834"
-       height="36.72575"
-       width="82.040657"
-       id="rect6614"
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.86203903;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1" /><text
-       xml:space="preserve"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       x="121.24728"
-       y="260.14957"
-       id="text6616"
-       sodipodi:linespacing="125%"
-       transform="scale(1.0403984,0.96117025)"><tspan
-         sodipodi:role="line"
-         id="tspan6618"
-         x="121.24728"
-         y="260.14957"
-         style="font-size:11.53426838px">Controllers</tspan></text>
-<text
-       transform="scale(1.0403984,0.96117025)"
-       sodipodi:linespacing="125%"
-       id="text6624"
-       y="282.70709"
-       x="219.61203"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       xml:space="preserve"><tspan
-         style="font-size:11.53426838px"
-         y="282.70709"
-         x="219.61203"
-         id="tspan6626"
-         sodipodi:role="line">ViewResolver</tspan></text>
-<rect
-       transform="scale(1,-1)"
-       y="-259.30249"
-       x="332.5405"
-       height="36.577778"
-       width="114.4539"
-       id="rect6628"
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:1.0161339;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1" /><text
-       xml:space="preserve"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       x="327.51276"
-       y="255.28464"
-       id="text6630"
-       sodipodi:linespacing="125%"
-       transform="scale(1.0403984,0.96117025)"><tspan
-         sodipodi:role="line"
-         id="tspan6632"
-         x="327.51276"
-         y="255.28464"
-         style="font-size:11.53426838px">HandlerMapping</tspan></text>
-<rect
-       y="338.69724"
-       x="87.803261"
-       height="121.5683"
-       width="382.84744"
-       id="rect6634"
-       style="fill:#dde2cd;fill-opacity:1;stroke:#000000;stroke-width:1.53790233;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1" /><text
-       transform="scale(1.0403984,0.96117025)"
-       sodipodi:linespacing="125%"
-       id="text6636"
-       y="376.61673"
-       x="108.61351"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       xml:space="preserve"><tspan
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:23.06853676px;font-family:sans-serif;-inkscape-font-specification:sans-serif"
-         y="376.61673"
-         x="108.61351"
-         id="tspan6638"
-         sodipodi:role="line">Root WebApplicationContext</tspan></text>
-<text
-       transform="scale(1.0403984,0.96117025)"
-       sodipodi:linespacing="125%"
-       id="text6640"
-       y="395.35812"
-       x="260.93863"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       xml:space="preserve"><tspan
-         id="tspan6644"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.53426838px;font-family:sans-serif;-inkscape-font-specification:sans-serif;text-align:center;text-anchor:middle"
-         y="395.35812"
-         x="260.93863"
-         sodipodi:role="line">(containing middle-tier services, datasources, etc.)</tspan></text>
-<rect
-       transform="scale(1,-1)"
-       y="-440.06805"
-       x="164.32933"
-       height="36.72575"
-       width="82.040657"
-       id="rect6648"
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.86203903;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1" /><rect
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.86203903;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1"
-       id="rect6650"
-       width="82.040657"
-       height="36.72575"
-       x="167.73116"
-       y="-445.45563"
-       transform="scale(1,-1)" /><text
-       transform="scale(1.0403984,0.96117025)"
-       sodipodi:linespacing="125%"
-       id="text6652"
-       y="448.55054"
-       x="175.87148"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       xml:space="preserve"><tspan
-         style="font-size:11.53426838px"
-         y="448.55054"
-         x="175.87148"
-         id="tspan6654"
-         sodipodi:role="line">Services</tspan></text>
-<rect
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.88435173;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1"
-       id="rect6656"
-       width="86.393044"
-       height="36.704323"
-       x="306.86328"
-       y="-439.60837"
-       transform="scale(1,-1)" /><rect
-       transform="scale(1,-1)"
-       y="-444.99475"
-       x="310.26624"
-       height="36.701977"
-       width="86.876686"
-       id="rect6658"
-       style="fill:#ffffff;fill-opacity:1;stroke:#000000;stroke-width:0.88679528;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1" /><text
-       xml:space="preserve"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       x="305.30771"
-       y="448.55054"
-       id="text6660"
-       sodipodi:linespacing="125%"
-       transform="scale(1.0403984,0.96117025)"><tspan
-         sodipodi:role="line"
-         id="tspan6662"
-         x="305.30771"
-         y="448.55054"
-         style="font-size:11.53426838px">Repositories</tspan></text>
-<path
-       style="fill:none;fill-rule:evenodd;stroke:#000000;stroke-width:0.76895118px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       d="m 265.33234,295.60379 c 0,42.65169 0,42.65169 0,0 z"
-       id="path7643"
-       inkscape:connector-curvature="0" /><path
-       style="fill:#000000;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:3.46028023;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:3;stroke-dasharray:none;stroke-opacity:1;marker-end:url(#Arrow2Mend)"
-       d="m 270.43505,294.70585 c 0,39.4721 0,39.87903 0,39.87903"
-       id="path7645"
-       inkscape:connector-curvature="0" /><text
-       xml:space="preserve"
-       style="font-style:normal;font-weight:normal;font-size:30.7580471px;line-height:125%;font-family:Sans;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
-       x="352.55331"
-       y="333.03622"
-       id="text4963"
-       sodipodi:linespacing="125%"
-       transform="scale(1.0403984,0.96117025)"><tspan
-         sodipodi:role="line"
-         x="352.55331"
-         y="333.03622"
-         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:11.53426838px;font-family:sans-serif;-inkscape-font-specification:sans-serif;text-align:center;text-anchor:middle"
-         id="tspan4965">Delegates if no bean found</tspan></text>
-</g></svg>

framework-docs/modules/ROOT/examples/docs-src

@@ -1 +0,0 @@
-../../../src

framework-docs/modules/ROOT/nav.adoc

@@ -1,443 +0,0 @@
-* xref:overview.adoc[Overview]
-* xref:core.adoc[]
-** xref:core/beans.adoc[]
-*** xref:core/beans/introduction.adoc[]
-*** xref:core/beans/basics.adoc[]
-*** xref:core/beans/definition.adoc[]
-*** xref:core/beans/dependencies.adoc[]
-**** xref:core/beans/dependencies/factory-collaborators.adoc[]
-**** xref:core/beans/dependencies/factory-properties-detailed.adoc[]
-**** xref:core/beans/dependencies/factory-dependson.adoc[]
-**** xref:core/beans/dependencies/factory-lazy-init.adoc[]
-**** xref:core/beans/dependencies/factory-autowire.adoc[]
-**** xref:core/beans/dependencies/factory-method-injection.adoc[]
-*** xref:core/beans/factory-scopes.adoc[]
-*** xref:core/beans/factory-nature.adoc[]
-*** xref:core/beans/child-bean-definitions.adoc[]
-*** xref:core/beans/factory-extension.adoc[]
-*** xref:core/beans/annotation-config.adoc[]
-**** xref:core/beans/annotation-config/autowired.adoc[]
-**** xref:core/beans/annotation-config/autowired-primary.adoc[]
-**** xref:core/beans/annotation-config/autowired-qualifiers.adoc[]
-**** xref:core/beans/annotation-config/generics-as-qualifiers.adoc[]
-**** xref:core/beans/annotation-config/custom-autowire-configurer.adoc[]
-**** xref:core/beans/annotation-config/resource.adoc[]
-**** xref:core/beans/annotation-config/value-annotations.adoc[]
-**** xref:core/beans/annotation-config/postconstruct-and-predestroy-annotations.adoc[]
-*** xref:core/beans/classpath-scanning.adoc[]
-*** xref:core/beans/standard-annotations.adoc[]
-*** xref:core/beans/java.adoc[]
-**** xref:core/beans/java/basic-concepts.adoc[]
-**** xref:core/beans/java/instantiating-container.adoc[]
-**** xref:core/beans/java/bean-annotation.adoc[]
-**** xref:core/beans/java/configuration-annotation.adoc[]
-**** xref:core/beans/java/composing-configuration-classes.adoc[]
-*** xref:core/beans/environment.adoc[]
-*** xref:core/beans/context-load-time-weaver.adoc[]
-*** xref:core/beans/context-introduction.adoc[]
-*** xref:core/beans/beanfactory.adoc[]
-** 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/convert.adoc[]
-*** xref:core/validation/format.adoc[]
-*** xref:core/validation/format-configuring-formatting-globaldatetimeformat.adoc[]
-*** xref:core/validation/beanvalidation.adoc[]
-** xref:core/expressions.adoc[]
-*** xref:core/expressions/evaluation.adoc[]
-*** xref:core/expressions/beandef.adoc[]
-*** xref:core/expressions/language-ref.adoc[]
-**** xref:core/expressions/language-ref/literal.adoc[]
-**** xref:core/expressions/language-ref/properties-arrays.adoc[]
-**** xref:core/expressions/language-ref/inline-lists.adoc[]
-**** xref:core/expressions/language-ref/inline-maps.adoc[]
-**** xref:core/expressions/language-ref/array-construction.adoc[]
-**** xref:core/expressions/language-ref/methods.adoc[]
-**** xref:core/expressions/language-ref/operators.adoc[]
-**** xref:core/expressions/language-ref/types.adoc[]
-**** xref:core/expressions/language-ref/constructors.adoc[]
-**** xref:core/expressions/language-ref/variables.adoc[]
-**** xref:core/expressions/language-ref/functions.adoc[]
-**** xref:core/expressions/language-ref/bean-references.adoc[]
-**** xref:core/expressions/language-ref/operator-ternary.adoc[]
-**** xref:core/expressions/language-ref/operator-elvis.adoc[]
-**** xref:core/expressions/language-ref/operator-safe-navigation.adoc[]
-**** xref:core/expressions/language-ref/collection-selection.adoc[]
-**** xref:core/expressions/language-ref/collection-projection.adoc[]
-**** xref:core/expressions/language-ref/templating.adoc[]
-*** xref:core/expressions/example-classes.adoc[]
-** xref:core/aop.adoc[]
-*** xref:core/aop/introduction-defn.adoc[]
-*** xref:core/aop/introduction-spring-defn.adoc[]
-*** xref:core/aop/introduction-proxies.adoc[]
-*** xref:core/aop/ataspectj.adoc[]
-**** xref:core/aop/ataspectj/aspectj-support.adoc[]
-**** xref:core/aop/ataspectj/at-aspectj.adoc[]
-**** xref:core/aop/ataspectj/pointcuts.adoc[]
-**** xref:core/aop/ataspectj/advice.adoc[]
-**** xref:core/aop/ataspectj/introductions.adoc[]
-**** xref:core/aop/ataspectj/instantiation-models.adoc[]
-**** xref:core/aop/ataspectj/example.adoc[]
-*** xref:core/aop/schema.adoc[]
-*** xref:core/aop/choosing.adoc[]
-*** xref:core/aop/mixing-styles.adoc[]
-*** xref:core/aop/proxying.adoc[]
-*** xref:core/aop/aspectj-programmatic.adoc[]
-*** xref:core/aop/using-aspectj.adoc[]
-*** xref:core/aop/resources.adoc[]
-** xref:core/aop-api.adoc[]
-*** xref:core/aop-api/pointcuts.adoc[]
-*** xref:core/aop-api/advice.adoc[]
-*** xref:core/aop-api/advisor.adoc[]
-*** xref:core/aop-api/pfb.adoc[]
-*** xref:core/aop-api/concise-proxy.adoc[]
-*** xref:core/aop-api/prog.adoc[]
-*** xref:core/aop-api/advised.adoc[]
-*** xref:core/aop-api/autoproxy.adoc[]
-*** xref:core/aop-api/targetsource.adoc[]
-*** xref:core/aop-api/extensibility.adoc[]
-** xref:core/null-safety.adoc[]
-** xref:core/databuffer-codec.adoc[]
-** xref:core/spring-jcl.adoc[]
-** xref:core/aot.adoc[]
-** xref:core/appendix.adoc[]
-*** xref:core/appendix/xsd-schemas.adoc[]
-*** xref:core/appendix/xml-custom.adoc[]
-*** xref:core/appendix/application-startup-steps.adoc[]
-* xref:testing.adoc[]
-** xref:testing/introduction.adoc[]
-** xref:testing/unit.adoc[]
-** xref:testing/integration.adoc[]
-** xref:testing/support-jdbc.adoc[]
-** xref:testing/testcontext-framework.adoc[]
-*** xref:testing/testcontext-framework/key-abstractions.adoc[]
-*** xref:testing/testcontext-framework/bootstrapping.adoc[]
-*** xref:testing/testcontext-framework/tel-config.adoc[]
-*** xref:testing/testcontext-framework/application-events.adoc[]
-*** xref:testing/testcontext-framework/test-execution-events.adoc[]
-*** xref:testing/testcontext-framework/ctx-management.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/xml.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/groovy.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/javaconfig.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/mixed-config.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/context-customizers.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/initializers.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/inheritance.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/env-profiles.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/property-sources.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/dynamic-property-sources.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/web.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/web-mocks.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/caching.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[]
-**** xref:testing/testcontext-framework/ctx-management/hierarchies.adoc[]
-*** xref:testing/testcontext-framework/fixture-di.adoc[]
-*** xref:testing/testcontext-framework/web-scoped-beans.adoc[]
-*** xref:testing/testcontext-framework/tx.adoc[]
-*** xref:testing/testcontext-framework/executing-sql.adoc[]
-*** xref:testing/testcontext-framework/parallel-test-execution.adoc[]
-*** xref:testing/testcontext-framework/support-classes.adoc[]
-*** xref:testing/testcontext-framework/aot.adoc[]
-** xref:testing/webtestclient.adoc[]
-** xref:testing/spring-mvc-test-framework.adoc[]
-*** xref:testing/spring-mvc-test-framework/server.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-static-imports.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-setup-options.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-setup-steps.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-performing-requests.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-defining-expectations.adoc[]
-*** xref:testing/spring-mvc-test-framework/async-requests.adoc[]
-*** xref:testing/spring-mvc-test-framework/vs-streaming-response.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-filters.adoc[]
-*** xref:testing/spring-mvc-test-framework/vs-end-to-end-integration-tests.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-resources.adoc[]
-*** xref:testing/spring-mvc-test-framework/server-htmlunit.adoc[]
-**** xref:testing/spring-mvc-test-framework/server-htmlunit/why.adoc[]
-**** xref:testing/spring-mvc-test-framework/server-htmlunit/mah.adoc[]
-**** xref:testing/spring-mvc-test-framework/server-htmlunit/webdriver.adoc[]
-**** xref:testing/spring-mvc-test-framework/server-htmlunit/geb.adoc[]
-** xref:testing/spring-mvc-test-client.adoc[]
-** xref:testing/appendix.adoc[]
-*** xref:testing/annotations.adoc[]
-**** xref:testing/annotations/integration-standard.adoc[]
-**** xref:testing/annotations/integration-spring.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-bootstrapwith.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-contextconfiguration.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-webappconfiguration.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-contexthierarchy.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-contextcustomizerfactories.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-activeprofiles.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-testpropertysource.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-dynamicpropertysource.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-dirtiescontext.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-testexecutionlisteners.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-recordapplicationevents.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-commit.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-rollback.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-beforetransaction.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-aftertransaction.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-sql.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-sqlconfig.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-sqlmergemode.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-sqlgroup.adoc[]
-***** xref:testing/annotations/integration-spring/annotation-disabledinaotmode.adoc[]
-**** xref:testing/annotations/integration-junit4.adoc[]
-**** xref:testing/annotations/integration-junit-jupiter.adoc[]
-**** xref:testing/annotations/integration-meta.adoc[]
-*** xref:testing/resources.adoc[]
-* xref:data-access.adoc[]
-** xref:data-access/transaction.adoc[]
-*** xref:data-access/transaction/motivation.adoc[]
-*** xref:data-access/transaction/strategies.adoc[]
-*** xref:data-access/transaction/tx-resource-synchronization.adoc[]
-*** xref:data-access/transaction/declarative.adoc[]
-**** xref:data-access/transaction/declarative/tx-decl-explained.adoc[]
-**** xref:data-access/transaction/declarative/first-example.adoc[]
-**** xref:data-access/transaction/declarative/rolling-back.adoc[]
-**** xref:data-access/transaction/declarative/diff-tx.adoc[]
-**** xref:data-access/transaction/declarative/txadvice-settings.adoc[]
-**** xref:data-access/transaction/declarative/annotations.adoc[]
-**** xref:data-access/transaction/declarative/tx-propagation.adoc[]
-**** xref:data-access/transaction/declarative/applying-more-than-just-tx-advice.adoc[]
-**** xref:data-access/transaction/declarative/aspectj.adoc[]
-*** xref:data-access/transaction/programmatic.adoc[]
-*** xref:data-access/transaction/tx-decl-vs-prog.adoc[]
-*** xref:data-access/transaction/event.adoc[]
-*** xref:data-access/transaction/application-server-integration.adoc[]
-*** xref:data-access/transaction/solutions-to-common-problems.adoc[]
-*** xref:data-access/transaction/resources.adoc[]
-** xref:data-access/dao.adoc[]
-** xref:data-access/jdbc.adoc[]
-*** xref:data-access/jdbc/choose-style.adoc[]
-*** xref:data-access/jdbc/packages.adoc[]
-*** xref:data-access/jdbc/core.adoc[]
-*** xref:data-access/jdbc/connections.adoc[]
-*** xref:data-access/jdbc/advanced.adoc[]
-*** xref:data-access/jdbc/simple.adoc[]
-*** xref:data-access/jdbc/object.adoc[]
-*** xref:data-access/jdbc/parameter-handling.adoc[]
-*** xref:data-access/jdbc/embedded-database-support.adoc[]
-*** xref:data-access/jdbc/initializing-datasource.adoc[]
-** xref:data-access/r2dbc.adoc[]
-** xref:data-access/orm.adoc[]
-*** xref:data-access/orm/introduction.adoc[]
-*** xref:data-access/orm/general.adoc[]
-*** xref:data-access/orm/hibernate.adoc[]
-*** xref:data-access/orm/jpa.adoc[]
-** xref:data-access/oxm.adoc[]
-** xref:data-access/appendix.adoc[]
-* xref:web.adoc[]
-** xref:web/webmvc.adoc[]
-*** xref:web/webmvc/mvc-servlet.adoc[]
-**** xref:web/webmvc/mvc-servlet/context-hierarchy.adoc[]
-**** xref:web/webmvc/mvc-servlet/special-bean-types.adoc[]
-**** xref:web/webmvc/mvc-servlet/config.adoc[]
-**** xref:web/webmvc/mvc-servlet/container-config.adoc[]
-**** xref:web/webmvc/mvc-servlet/sequence.adoc[]
-**** xref:web/webmvc/mvc-servlet/handlermapping-path.adoc[]
-**** xref:web/webmvc/mvc-servlet/handlermapping-interceptor.adoc[]
-**** xref:web/webmvc/mvc-servlet/exceptionhandlers.adoc[]
-**** xref:web/webmvc/mvc-servlet/viewresolver.adoc[]
-**** xref:web/webmvc/mvc-servlet/localeresolver.adoc[]
-**** xref:web/webmvc/mvc-servlet/themeresolver.adoc[]
-**** xref:web/webmvc/mvc-servlet/multipart.adoc[]
-**** xref:web/webmvc/mvc-servlet/logging.adoc[]
-*** xref:web/webmvc/filters.adoc[]
-*** xref:web/webmvc/mvc-controller.adoc[]
-**** xref:web/webmvc/mvc-controller/ann.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-requestmapping.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-methods.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/arguments.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/return-types.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/typeconversion.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/matrix-variables.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/requestparam.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/requestheader.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/cookievalue.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/modelattrib-method-args.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/sessionattributes.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/sessionattribute.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/requestattrib.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/redirecting-passing-data.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/flash-attributes.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/multipart-forms.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/requestbody.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/httpentity.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/responsebody.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/responseentity.adoc[]
-***** xref:web/webmvc/mvc-controller/ann-methods/jackson.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-modelattrib-methods.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-initbinder.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-validation.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-exceptionhandler.adoc[]
-**** xref:web/webmvc/mvc-controller/ann-advice.adoc[]
-*** xref:web/webmvc-functional.adoc[]
-*** xref:web/webmvc/mvc-uri-building.adoc[]
-*** xref:web/webmvc/mvc-ann-async.adoc[]
-*** xref:web/webmvc-cors.adoc[]
-*** xref:web/webmvc/mvc-ann-rest-exceptions.adoc[]
-*** xref:web/webmvc/mvc-security.adoc[]
-*** xref:web/webmvc/mvc-caching.adoc[]
-*** xref:web/webmvc-view.adoc[]
-**** xref:web/webmvc-view/mvc-thymeleaf.adoc[]
-**** xref:web/webmvc-view/mvc-freemarker.adoc[]
-**** xref:web/webmvc-view/mvc-groovymarkup.adoc[]
-**** xref:web/webmvc-view/mvc-script.adoc[]
-**** xref:web/webmvc-view/mvc-jsp.adoc[]
-**** xref:web/webmvc-view/mvc-feeds.adoc[]
-**** xref:web/webmvc-view/mvc-document.adoc[]
-**** xref:web/webmvc-view/mvc-jackson.adoc[]
-**** xref:web/webmvc-view/mvc-xml-marshalling.adoc[]
-**** xref:web/webmvc-view/mvc-xslt.adoc[]
-*** xref:web/webmvc/mvc-config.adoc[]
-**** xref:web/webmvc/mvc-config/enable.adoc[]
-**** xref:web/webmvc/mvc-config/customize.adoc[]
-**** xref:web/webmvc/mvc-config/conversion.adoc[]
-**** xref:web/webmvc/mvc-config/validation.adoc[]
-**** xref:web/webmvc/mvc-config/interceptors.adoc[]
-**** xref:web/webmvc/mvc-config/content-negotiation.adoc[]
-**** xref:web/webmvc/mvc-config/message-converters.adoc[]
-**** xref:web/webmvc/mvc-config/view-controller.adoc[]
-**** xref:web/webmvc/mvc-config/view-resolvers.adoc[]
-**** xref:web/webmvc/mvc-config/static-resources.adoc[]
-**** xref:web/webmvc/mvc-config/default-servlet-handler.adoc[]
-**** xref:web/webmvc/mvc-config/path-matching.adoc[]
-**** xref:web/webmvc/mvc-config/advanced-java.adoc[]
-**** xref:web/webmvc/mvc-config/advanced-xml.adoc[]
-*** xref:web/webmvc/mvc-http2.adoc[]
-** xref:web/webmvc-client.adoc[]
-** xref:web/webmvc-test.adoc[]
-** xref:web/websocket.adoc[]
-*** xref:web/websocket/server.adoc[]
-*** xref:web/websocket/fallback.adoc[]
-*** xref:web/websocket/stomp.adoc[]
-**** xref:web/websocket/stomp/overview.adoc[]
-**** xref:web/websocket/stomp/benefits.adoc[]
-**** xref:web/websocket/stomp/enable.adoc[]
-**** xref:web/websocket/stomp/server-config.adoc[]
-**** xref:web/websocket/stomp/message-flow.adoc[]
-**** xref:web/websocket/stomp/handle-annotations.adoc[]
-**** xref:web/websocket/stomp/handle-send.adoc[]
-**** xref:web/websocket/stomp/handle-simple-broker.adoc[]
-**** xref:web/websocket/stomp/handle-broker-relay.adoc[]
-**** xref:web/websocket/stomp/handle-broker-relay-configure.adoc[]
-**** xref:web/websocket/stomp/destination-separator.adoc[]
-**** xref:web/websocket/stomp/authentication.adoc[]
-**** xref:web/websocket/stomp/authentication-token-based.adoc[]
-**** xref:web/websocket/stomp/authorization.adoc[]
-**** xref:web/websocket/stomp/user-destination.adoc[]
-**** xref:web/websocket/stomp/ordered-messages.adoc[]
-**** xref:web/websocket/stomp/application-context-events.adoc[]
-**** xref:web/websocket/stomp/interceptors.adoc[]
-**** xref:web/websocket/stomp/client.adoc[]
-**** xref:web/websocket/stomp/scope.adoc[]
-**** xref:web/websocket/stomp/configuration-performance.adoc[]
-**** xref:web/websocket/stomp/stats.adoc[]
-**** xref:web/websocket/stomp/testing.adoc[]
-** xref:web/integration.adoc[]
-* xref:web-reactive.adoc[]
-** xref:web/webflux.adoc[]
-*** xref:web/webflux/new-framework.adoc[]
-*** xref:web/webflux/reactive-spring.adoc[]
-*** xref:web/webflux/dispatcher-handler.adoc[]
-*** xref:web/webflux/controller.adoc[]
-**** xref:web/webflux/controller/ann.adoc[]
-**** xref:web/webflux/controller/ann-requestmapping.adoc[]
-**** xref:web/webflux/controller/ann-methods.adoc[]
-***** xref:web/webflux/controller/ann-methods/arguments.adoc[]
-***** xref:web/webflux/controller/ann-methods/return-types.adoc[]
-***** xref:web/webflux/controller/ann-methods/typeconversion.adoc[]
-***** xref:web/webflux/controller/ann-methods/matrix-variables.adoc[]
-***** xref:web/webflux/controller/ann-methods/requestparam.adoc[]
-***** xref:web/webflux/controller/ann-methods/requestheader.adoc[]
-***** xref:web/webflux/controller/ann-methods/cookievalue.adoc[]
-***** xref:web/webflux/controller/ann-methods/modelattrib-method-args.adoc[]
-***** xref:web/webflux/controller/ann-methods/sessionattributes.adoc[]
-***** xref:web/webflux/controller/ann-methods/sessionattribute.adoc[]
-***** xref:web/webflux/controller/ann-methods/requestattrib.adoc[]
-***** xref:web/webflux/controller/ann-methods/multipart-forms.adoc[]
-***** xref:web/webflux/controller/ann-methods/requestbody.adoc[]
-***** xref:web/webflux/controller/ann-methods/httpentity.adoc[]
-***** xref:web/webflux/controller/ann-methods/responsebody.adoc[]
-***** xref:web/webflux/controller/ann-methods/responseentity.adoc[]
-***** xref:web/webflux/controller/ann-methods/jackson.adoc[]
-**** xref:web/webflux/controller/ann-modelattrib-methods.adoc[]
-**** xref:web/webflux/controller/ann-initbinder.adoc[]
-**** xref:web/webflux/controller/ann-validation.adoc[]
-**** xref:web/webflux/controller/ann-exceptions.adoc[]
-**** xref:web/webflux/controller/ann-advice.adoc[]
-*** xref:web/webflux-functional.adoc[]
-*** xref:web/webflux/uri-building.adoc[]
-*** xref:web/webflux-cors.adoc[]
-*** xref:web/webflux/ann-rest-exceptions.adoc[]
-*** xref:web/webflux/security.adoc[]
-*** xref:web/webflux/caching.adoc[]
-*** xref:web/webflux-view.adoc[]
-*** xref:web/webflux/config.adoc[]
-*** xref:web/webflux/http2.adoc[]
-** xref:web/webflux-webclient.adoc[]
-*** xref:web/webflux-webclient/client-builder.adoc[]
-*** xref:web/webflux-webclient/client-retrieve.adoc[]
-*** xref:web/webflux-webclient/client-exchange.adoc[]
-*** xref:web/webflux-webclient/client-body.adoc[]
-*** xref:web/webflux-webclient/client-filter.adoc[]
-*** xref:web/webflux-webclient/client-attributes.adoc[]
-*** xref:web/webflux-webclient/client-context.adoc[]
-*** xref:web/webflux-webclient/client-synchronous.adoc[]
-*** xref:web/webflux-webclient/client-testing.adoc[]
-** xref:web/webflux-http-interface-client.adoc[]
-** xref:web/webflux-websocket.adoc[]
-** xref:web/webflux-test.adoc[]
-** xref:rsocket.adoc[]
-** xref:web/webflux-reactive-libraries.adoc[]
-* xref:integration.adoc[]
-** xref:integration/rest-clients.adoc[]
-** xref:integration/jms.adoc[]
-*** xref:integration/jms/using.adoc[]
-*** xref:integration/jms/sending.adoc[]
-*** xref:integration/jms/receiving.adoc[]
-*** xref:integration/jms/jca-message-endpoint-manager.adoc[]
-*** xref:integration/jms/annotated.adoc[]
-*** xref:integration/jms/namespace.adoc[]
-** xref:integration/jmx.adoc[]
-*** xref:integration/jmx/exporting.adoc[]
-*** xref:integration/jmx/interface.adoc[]
-*** xref:integration/jmx/naming.adoc[]
-*** xref:integration/jmx/jsr160.adoc[]
-*** xref:integration/jmx/proxy.adoc[]
-*** xref:integration/jmx/notifications.adoc[]
-*** xref:integration/jmx/resources.adoc[]
-** xref:integration/email.adoc[]
-** xref:integration/scheduling.adoc[]
-** xref:integration/cache.adoc[]
-*** xref:integration/cache/strategies.adoc[]
-*** xref:integration/cache/annotations.adoc[]
-*** xref:integration/cache/jsr-107.adoc[]
-*** xref:integration/cache/declarative-xml.adoc[]
-*** xref:integration/cache/store-configuration.adoc[]
-*** xref:integration/cache/plug.adoc[]
-*** xref:integration/cache/specific-config.adoc[]
-** xref:integration/observability.adoc[]
-** xref:integration/checkpoint-restore.adoc[]
-** xref:integration/cds.adoc[]
-** xref:integration/appendix.adoc[]
-* xref:languages.adoc[]
-** xref:languages/kotlin.adoc[]
-*** xref:languages/kotlin/requirements.adoc[]
-*** xref:languages/kotlin/extensions.adoc[]
-*** xref:languages/kotlin/null-safety.adoc[]
-*** xref:languages/kotlin/classes-interfaces.adoc[]
-*** xref:languages/kotlin/annotations.adoc[]
-*** xref:languages/kotlin/bean-definition-dsl.adoc[]
-*** xref:languages/kotlin/web.adoc[]
-*** xref:languages/kotlin/coroutines.adoc[]
-*** xref:languages/kotlin/spring-projects-in.adoc[]
-*** xref:languages/kotlin/getting-started.adoc[]
-*** xref:languages/kotlin/resources.adoc[]
-** xref:languages/groovy.adoc[]
-** xref:languages/dynamic.adoc[]
-* xref:appendix.adoc[]
-* {spring-framework-wiki}[Wiki]
-

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

@@ -1,123 +0,0 @@
-[[appendix]]
-= Appendix
-
-This part of the reference documentation covers topics that apply to multiple modules
-within the core Spring Framework.
-
-
-[[appendix-spring-properties]]
-== Spring Properties
-
-{spring-framework-api}/core/SpringProperties.html[`SpringProperties`] is a static holder
-for properties that control certain low-level aspects of the Spring Framework. Users can
-configure these properties via JVM system properties or programmatically via the
-`SpringProperties.setProperty(String key, String value)` method. The latter may be
-necessary if the deployment environment disallows custom JVM system properties. As an
-alternative, these properties may be configured in a `spring.properties` file in the root
-of the classpath -- for example, deployed within the application's JAR file.
-
-The following table lists all currently supported Spring properties.
-
-.Supported Spring Properties
-[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`]
-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].
-
-| `spring.getenv.ignore`
-| Instructs Spring to ignore operating system environment variables if a Spring
-`Environment` property -- for example, a placeholder in a configuration String -- isn't
-resolvable otherwise. See
-{spring-framework-api}++/core/env/AbstractEnvironment.html#IGNORE_GETENV_PROPERTY_NAME++[`AbstractEnvironment`]
-for details.
-
-| `spring.jdbc.getParameterType.ignore`
-| Instructs Spring to ignore `java.sql.ParameterMetaData.getParameterType` completely.
-See the note in xref:data-access/jdbc/advanced.adoc#jdbc-batch-list[Batch Operations with a List of Objects].
-
-| `spring.jndi.ignore`
-| Instructs Spring to ignore a default JNDI environment, as an optimization for scenarios
-where nothing is ever to be found for such JNDI fallback searches to begin with, avoiding
-the repeated JNDI lookup overhead. See
-{spring-framework-api}++/jndi/JndiLocatorDelegate.html#IGNORE_JNDI_PROPERTY_NAME++[`JndiLocatorDelegate`]
-for details.
-
-| `spring.objenesis.ignore`
-| Instructs Spring to ignore Objenesis, not even attempting to use it. See
-{spring-framework-api}++/objenesis/SpringObjenesis.html#IGNORE_OBJENESIS_PROPERTY_NAME++[`SpringObjenesis`]
-for details.
-
-| `spring.test.aot.processing.failOnError`
-| A boolean flag that controls whether errors encountered during AOT processing in the
-_Spring TestContext Framework_ should result in an exception that fails the overall process.
-See xref:testing/testcontext-framework/aot.adoc[Ahead of Time Support for Tests].
-
-| `spring.test.constructor.autowire.mode`
-| The default _test constructor autowire mode_ to use if `@TestConstructor` is not present
-on a test class. See xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-testconstructor[Changing the default test constructor autowire mode].
-
-| `spring.test.context.cache.maxSize`
-| The maximum size of the context cache in the _Spring TestContext Framework_. See
-xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching].
-
-| `spring.test.context.failure.threshold`
-| The failure threshold for errors encountered while attempting to load an `ApplicationContext`
-in the _Spring TestContext Framework_. See
-xref:testing/testcontext-framework/ctx-management/failure-threshold.adoc[Context Failure Threshold].
-
-| `spring.test.enclosing.configuration`
-| The default _enclosing configuration inheritance mode_ to use if
-`@NestedTestConfiguration` is not present on a test class. See
-xref:testing/annotations/integration-junit-jupiter.adoc#integration-testing-annotations-nestedtestconfiguration[Changing the default enclosing configuration inheritance mode].
-
-|===

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

@@ -1,30 +0,0 @@
-[[spring-core]]
-= Core Technologies
-
-This part of the reference documentation covers all the technologies that are
-absolutely integral to the Spring Framework.
-
-Foremost amongst these is the Spring Framework's Inversion of Control (IoC) container.
-A thorough treatment of the Spring Framework's IoC container is closely followed by
-comprehensive coverage of Spring's Aspect-Oriented Programming (AOP) technologies.
-The Spring Framework has its own AOP framework, which is conceptually easy to
-understand and which successfully addresses the 80% sweet spot of AOP requirements
-in Java enterprise programming.
-
-Coverage of Spring's integration with AspectJ (currently the richest -- in terms of
-features -- and certainly most mature AOP implementation in the Java enterprise space)
-is also provided.
-
-AOT processing can be used to optimize your application ahead-of-time. It is typically
-used for native image deployment using GraalVM.
-
-
-
-
-
-
-
-
-
-
-

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

@@ -1,12 +0,0 @@
-[[aop-api]]
-= Spring AOP APIs
-:page-section-summary-toc: 1
-
-The previous chapter described the Spring's support for AOP with @AspectJ and schema-based
-aspect definitions. In this chapter, we discuss the lower-level Spring AOP APIs. For common
-applications, we recommend the use of Spring AOP with AspectJ pointcuts as described in the
-previous chapter.
-
-
-
-

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

@@ -1,592 +0,0 @@
-[[aop-api-advice]]
-= Advice API in Spring
-
-Now we can examine how Spring AOP handles advice.
-
-
-
-[[aop-api-advice-lifecycle]]
-== Advice Lifecycles
-
-Each advice is a Spring bean. An advice instance can be shared across all advised
-objects or be unique to each advised object. This corresponds to per-class or
-per-instance advice.
-
-Per-class advice is used most often. It is appropriate for generic advice, such as
-transaction advisors. These do not depend on the state of the proxied object or add new
-state. They merely act on the method and arguments.
-
-Per-instance advice is appropriate for introductions, to support mixins. In this case,
-the advice adds state to the proxied object.
-
-You can use a mix of shared and per-instance advice in the same AOP proxy.
-
-
-
-[[aop-api-advice-types]]
-== Advice Types in Spring
-
-Spring provides several advice types and is extensible to support
-arbitrary advice types. This section describes the basic concepts and standard advice types.
-
-
-[[aop-api-advice-around]]
-=== Interception Around Advice
-
-The most fundamental advice type in Spring is interception around advice.
-
-Spring is compliant with the AOP `Alliance` interface for around advice that uses method
-interception. Classes that implement `MethodInterceptor` and that implement around advice should also implement the
-following interface:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface MethodInterceptor extends Interceptor {
-
-		Object invoke(MethodInvocation invocation) throws Throwable;
-	}
-----
-
-The `MethodInvocation` argument to the `invoke()` method exposes the method being
-invoked, the target join point, the AOP proxy, and the arguments to the method. The
-`invoke()` method should return the invocation's result: the return value of the join
-point.
-
-The following example shows a simple `MethodInterceptor` implementation:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class DebugInterceptor implements MethodInterceptor {
-
-		public Object invoke(MethodInvocation invocation) throws Throwable {
-			System.out.println("Before: invocation=[" + invocation + "]");
-			Object rval = invocation.proceed();
-			System.out.println("Invocation returned");
-			return rval;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class DebugInterceptor : MethodInterceptor {
-
-		override fun invoke(invocation: MethodInvocation): Any {
-			println("Before: invocation=[$invocation]")
-			val rval = invocation.proceed()
-			println("Invocation returned")
-			return rval
-		}
-	}
-----
-======
-
-Note the call to the `proceed()` method of `MethodInvocation`. This proceeds down the
-interceptor chain towards the join point. Most interceptors invoke this method and
-return its return value. However, a `MethodInterceptor`, like any around advice, can
-return a different value or throw an exception rather than invoke the proceed method.
-However, you do not want to do this without good reason.
-
-NOTE: `MethodInterceptor` implementations offer interoperability with other AOP Alliance-compliant AOP
-implementations. The other advice types discussed in the remainder of this section
-implement common AOP concepts but in a Spring-specific way. While there is an advantage
-in using the most specific advice type, stick with `MethodInterceptor` around advice if
-you are likely to want to run the aspect in another AOP framework. Note that pointcuts
-are not currently interoperable between frameworks, and the AOP Alliance does not
-currently define pointcut interfaces.
-
-
-[[aop-api-advice-before]]
-=== Before Advice
-
-A simpler advice type is a before advice. This does not need a `MethodInvocation`
-object, since it is called only before entering the method.
-
-The main advantage of a before advice is that there is no need to invoke the `proceed()`
-method and, therefore, no possibility of inadvertently failing to proceed down the
-interceptor chain.
-
-The following listing shows the `MethodBeforeAdvice` interface:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface MethodBeforeAdvice extends BeforeAdvice {
-
-		void before(Method m, Object[] args, Object target) throws Throwable;
-	}
-----
-
-(Spring's API design would allow for
-field before advice, although the usual objects apply to field interception and it is
-unlikely for Spring to ever implement it.)
-
-Note that the return type is `void`. Before advice can insert custom behavior before the join
-point runs but cannot change the return value. If a before advice throws an
-exception, it stops further execution of the interceptor chain. The exception
-propagates back up the interceptor chain. If it is unchecked or on the signature of
-the invoked method, it is passed directly to the client. Otherwise, it is
-wrapped in an unchecked exception by the AOP proxy.
-
-The following example shows a before advice in Spring, which counts all method invocations:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class CountingBeforeAdvice implements MethodBeforeAdvice {
-
-		private int count;
-
-		public void before(Method m, Object[] args, Object target) throws Throwable {
-			++count;
-		}
-
-		public int getCount() {
-			return count;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class CountingBeforeAdvice : MethodBeforeAdvice {
-
-		var count: Int = 0
-
-		override fun before(m: Method, args: Array<Any>, target: Any?) {
-			++count
-		}
-	}
-----
-======
-
-TIP: Before advice can be used with any pointcut.
-
-
-[[aop-api-advice-throws]]
-=== Throws Advice
-
-Throws advice is invoked after the return of the join point if the join point threw
-an exception. Spring offers typed throws advice. Note that this means that the
-`org.springframework.aop.ThrowsAdvice` interface does not contain any methods. It is a
-tag interface identifying that the given object implements one or more typed throws
-advice methods. These should be in the following form:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	afterThrowing([Method, args, target], subclassOfThrowable)
-----
-
-Only the last argument is required. The method signatures may have either one or four
-arguments, depending on whether the advice method is interested in the method and
-arguments. The next two listing show classes that are examples of throws advice.
-
-The following advice is invoked if a `RemoteException` is thrown (including from subclasses):
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class RemoteThrowsAdvice implements ThrowsAdvice {
-
-		public void afterThrowing(RemoteException ex) throws Throwable {
-			// Do something with remote exception
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class RemoteThrowsAdvice : ThrowsAdvice {
-
-		fun afterThrowing(ex: RemoteException) {
-			// Do something with remote exception
-		}
-	}
-----
-======
-
-Unlike the preceding
-advice, the next example declares four arguments, so that it has access to the invoked method, method
-arguments, and target object. The following advice is invoked if a `ServletException` is thrown:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class ServletThrowsAdviceWithArguments implements ThrowsAdvice {
-
-		public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {
-			// Do something with all arguments
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class ServletThrowsAdviceWithArguments : ThrowsAdvice {
-
-		fun afterThrowing(m: Method, args: Array<Any>, target: Any, ex: ServletException) {
-			// Do something with all arguments
-		}
-	}
-----
-======
-
-The final example illustrates how these two methods could be used in a single class
-that handles both `RemoteException` and `ServletException`. Any number of throws advice
-methods can be combined in a single class. The following listing shows the final example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public static class CombinedThrowsAdvice implements ThrowsAdvice {
-
-		public void afterThrowing(RemoteException ex) throws Throwable {
-			// Do something with remote exception
-		}
-
-		public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {
-			// Do something with all arguments
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class CombinedThrowsAdvice : ThrowsAdvice {
-
-		fun afterThrowing(ex: RemoteException) {
-			// Do something with remote exception
-		}
-
-		fun afterThrowing(m: Method, args: Array<Any>, target: Any, ex: ServletException) {
-			// Do something with all arguments
-		}
-	}
-----
-======
-
-NOTE: If a throws-advice method throws an exception itself, it overrides the
-original exception (that is, it changes the exception thrown to the user). The overriding
-exception is typically a RuntimeException, which is compatible with any method
-signature. However, if a throws-advice method throws a checked exception, it must
-match the declared exceptions of the target method and is, hence, to some degree
-coupled to specific target method signatures. _Do not throw an undeclared checked
-exception that is incompatible with the target method's signature!_
-
-TIP: Throws advice can be used with any pointcut.
-
-
-[[aop-api-advice-after-returning]]
-=== After Returning Advice
-
-An after returning advice in Spring must implement the
-`org.springframework.aop.AfterReturningAdvice` interface, which the following listing shows:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface AfterReturningAdvice extends Advice {
-
-		void afterReturning(Object returnValue, Method m, Object[] args, Object target)
-				throws Throwable;
-	}
-----
-
-An after returning advice has access to the return value (which it cannot modify),
-the invoked method, the method's arguments, and the target.
-
-The following after returning advice counts all successful method invocations that have
-not thrown exceptions:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class CountingAfterReturningAdvice implements AfterReturningAdvice {
-
-		private int count;
-
-		public void afterReturning(Object returnValue, Method m, Object[] args, Object target)
-				throws Throwable {
-			++count;
-		}
-
-		public int getCount() {
-			return count;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class CountingAfterReturningAdvice : AfterReturningAdvice {
-
-		var count: Int = 0
-			private set
-
-		override fun afterReturning(returnValue: Any?, m: Method, args: Array<Any>, target: Any?) {
-			++count
-		}
-	}
-----
-======
-
-This advice does not change the execution path. If it throws an exception, it is
-thrown up the interceptor chain instead of the return value.
-
-TIP: After returning advice can be used with any pointcut.
-
-
-[[aop-api-advice-introduction]]
-=== Introduction Advice
-
-Spring treats introduction advice as a special kind of interception advice.
-
-Introduction requires an `IntroductionAdvisor` and an `IntroductionInterceptor` that
-implement the following interface:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface IntroductionInterceptor extends MethodInterceptor {
-
-		boolean implementsInterface(Class intf);
-	}
-----
-
-The `invoke()` method inherited from the AOP Alliance `MethodInterceptor` interface must
-implement the introduction. That is, if the invoked method is on an introduced
-interface, the introduction interceptor is responsible for handling the method call -- it
-cannot invoke `proceed()`.
-
-Introduction advice cannot be used with any pointcut, as it applies only at the class,
-rather than the method, level. You can only use introduction advice with the
-`IntroductionAdvisor`, which has the following methods:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
-
-		ClassFilter getClassFilter();
-
-		void validateInterfaces() throws IllegalArgumentException;
-	}
-
-	public interface IntroductionInfo {
-
-		Class<?>[] getInterfaces();
-	}
-----
-
-There is no `MethodMatcher` and, hence, no `Pointcut` associated with introduction
-advice. Only class filtering is logical.
-
-The `getInterfaces()` method returns the interfaces introduced by this advisor.
-
-The `validateInterfaces()` method is used internally to see whether or not the
-introduced interfaces can be implemented by the configured `IntroductionInterceptor`.
-
-Consider an example from the Spring test suite and suppose we want to
-introduce the following interface to one or more objects:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public interface Lockable {
-		void lock();
-		void unlock();
-		boolean locked();
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	interface Lockable {
-		fun lock()
-		fun unlock()
-		fun locked(): Boolean
-	}
-----
-======
-
-This illustrates a mixin. We want to be able to cast advised objects to `Lockable`,
-whatever their type and call lock and unlock methods. If we call the `lock()` method, we
-want all setter methods to throw a `LockedException`. Thus, we can add an aspect that
-provides the ability to make objects immutable without them having any knowledge of it:
-a good example of AOP.
-
-First, we need an `IntroductionInterceptor` that does the heavy lifting. In this
-case, we extend the `org.springframework.aop.support.DelegatingIntroductionInterceptor`
-convenience class. We could implement `IntroductionInterceptor` directly, but using
-`DelegatingIntroductionInterceptor` is best for most cases.
-
-The `DelegatingIntroductionInterceptor` is designed to delegate an introduction to an
-actual implementation of the introduced interfaces, concealing the use of interception
-to do so. You can set the delegate to any object using a constructor argument. The
-default delegate (when the no-argument constructor is used) is `this`. Thus, in the next example,
-the delegate is the `LockMixin` subclass of `DelegatingIntroductionInterceptor`.
-Given a delegate (by default, itself), a `DelegatingIntroductionInterceptor` instance
-looks for all interfaces implemented by the delegate (other than
-`IntroductionInterceptor`) and supports introductions against any of them.
-Subclasses such as `LockMixin` can call the `suppressInterface(Class intf)`
-method to suppress interfaces that should not be exposed. However, no matter how many
-interfaces an `IntroductionInterceptor` is prepared to support, the
-`IntroductionAdvisor` used controls which interfaces are actually exposed. An
-introduced interface conceals any implementation of the same interface by the target.
-
-Thus, `LockMixin` extends `DelegatingIntroductionInterceptor` and implements `Lockable`
-itself. The superclass automatically picks up that `Lockable` can be supported for
-introduction, so we do not need to specify that. We could introduce any number of
-interfaces in this way.
-
-Note the use of the `locked` instance variable. This effectively adds additional state
-to that held in the target object.
-
-The following example shows the example `LockMixin` class:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class LockMixin extends DelegatingIntroductionInterceptor implements Lockable {
-
-		private boolean locked;
-
-		public void lock() {
-			this.locked = true;
-		}
-
-		public void unlock() {
-			this.locked = false;
-		}
-
-		public boolean locked() {
-			return this.locked;
-		}
-
-		public Object invoke(MethodInvocation invocation) throws Throwable {
-			if (locked() && invocation.getMethod().getName().indexOf("set") == 0) {
-				throw new LockedException();
-			}
-			return super.invoke(invocation);
-		}
-
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class LockMixin : DelegatingIntroductionInterceptor(), Lockable {
-
-		private var locked: Boolean = false
-
-		fun lock() {
-			this.locked = true
-		}
-
-		fun unlock() {
-			this.locked = false
-		}
-
-		fun locked(): Boolean {
-			return this.locked
-		}
-
-		override fun invoke(invocation: MethodInvocation): Any? {
-			if (locked() && invocation.method.name.indexOf("set") == 0) {
-				throw LockedException()
-			}
-			return super.invoke(invocation)
-		}
-
-	}
-----
-======
-
-Often, you need not override the `invoke()` method. The
-`DelegatingIntroductionInterceptor` implementation (which calls the `delegate` method if
-the method is introduced, otherwise proceeds towards the join point) usually
-suffices. In the present case, we need to add a check: no setter method can be invoked
-if in locked mode.
-
-The required introduction only needs to hold a distinct
-`LockMixin` instance and specify the introduced interfaces (in this case, only
-`Lockable`). A more complex example might take a reference to the introduction
-interceptor (which would be defined as a prototype). In this case, there is no
-configuration relevant for a `LockMixin`, so we create it by using `new`.
-The following example shows our `LockMixinAdvisor` class:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	public class LockMixinAdvisor extends DefaultIntroductionAdvisor {
-
-		public LockMixinAdvisor() {
-			super(new LockMixin(), Lockable.class);
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class LockMixinAdvisor : DefaultIntroductionAdvisor(LockMixin(), Lockable::class.java)
-----
-======
-
-We can apply this advisor very simply, because it requires no configuration. (However, it
-is impossible to use an `IntroductionInterceptor` without an
-`IntroductionAdvisor`.) As usual with introductions, the advisor must be per-instance,
-as it is stateful. We need a different instance of `LockMixinAdvisor`, and hence
-`LockMixin`, for each advised object. The advisor comprises part of the advised object's
-state.
-
-We can apply this advisor programmatically by using the `Advised.addAdvisor()` method or
-(the recommended way) in XML configuration, as any other advisor. All proxy creation
-choices discussed below, including "`auto proxy creators,`" correctly handle introductions
-and stateful mixins.
-
-
-
-
-

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

@@ -1,148 +0,0 @@
-[[aop-api-advised]]
-= Manipulating Advised Objects
-
-However you create AOP proxies, you can manipulate them BY using the
-`org.springframework.aop.framework.Advised` interface. Any AOP proxy can be cast to this
-interface, no matter which other interfaces it implements. This interface includes the
-following methods:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	Advisor[] getAdvisors();
-
-	void addAdvice(Advice advice) throws AopConfigException;
-
-	void addAdvice(int pos, Advice advice) throws AopConfigException;
-
-	void addAdvisor(Advisor advisor) throws AopConfigException;
-
-	void addAdvisor(int pos, Advisor advisor) throws AopConfigException;
-
-	int indexOf(Advisor advisor);
-
-	boolean removeAdvisor(Advisor advisor) throws AopConfigException;
-
-	void removeAdvisor(int index) throws AopConfigException;
-
-	boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;
-
-	boolean isFrozen();
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	fun getAdvisors(): Array<Advisor>
-
-	@Throws(AopConfigException::class)
-	fun addAdvice(advice: Advice)
-
-	@Throws(AopConfigException::class)
-	fun addAdvice(pos: Int, advice: Advice)
-
-	@Throws(AopConfigException::class)
-	fun addAdvisor(advisor: Advisor)
-
-	@Throws(AopConfigException::class)
-	fun addAdvisor(pos: Int, advisor: Advisor)
-
-	fun indexOf(advisor: Advisor): Int
-
-	@Throws(AopConfigException::class)
-	fun removeAdvisor(advisor: Advisor): Boolean
-
-	@Throws(AopConfigException::class)
-	fun removeAdvisor(index: Int)
-
-	@Throws(AopConfigException::class)
-	fun replaceAdvisor(a: Advisor, b: Advisor): Boolean
-
-	fun isFrozen(): Boolean
-----
-======
-
-The `getAdvisors()` method returns an `Advisor` for every advisor, interceptor, or
-other advice type that has been added to the factory. If you added an `Advisor`, the
-returned advisor at this index is the object that you added. If you added an
-interceptor or other advice type, Spring wrapped this in an advisor with a
-pointcut that always returns `true`. Thus, if you added a `MethodInterceptor`, the advisor
-returned for this index is a `DefaultPointcutAdvisor` that returns your
-`MethodInterceptor` and a pointcut that matches all classes and methods.
-
-The `addAdvisor()` methods can be used to add any `Advisor`. Usually, the advisor holding
-pointcut and advice is the generic `DefaultPointcutAdvisor`, which you can use with
-any advice or pointcut (but not for introductions).
-
-By default, it is possible to add or remove advisors or interceptors even once a proxy
-has been created. The only restriction is that it is impossible to add or remove an
-introduction advisor, as existing proxies from the factory do not show the interface
-change. (You can obtain a new proxy from the factory to avoid this problem.)
-
-The following example shows casting an AOP proxy to the `Advised` interface and examining and
-manipulating its advice:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	Advised advised = (Advised) myObject;
-	Advisor[] advisors = advised.getAdvisors();
-	int oldAdvisorCount = advisors.length;
-	System.out.println(oldAdvisorCount + " advisors");
-
-	// Add an advice like an interceptor without a pointcut
-	// Will match all proxied methods
-	// Can use for interceptors, before, after returning or throws advice
-	advised.addAdvice(new DebugInterceptor());
-
-	// Add selective advice using a pointcut
-	advised.addAdvisor(new DefaultPointcutAdvisor(mySpecialPointcut, myAdvice));
-
-	assertEquals("Added two advisors", oldAdvisorCount + 2, advised.getAdvisors().length);
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val advised = myObject as Advised
-	val advisors = advised.advisors
-	val oldAdvisorCount = advisors.size
-	println("$oldAdvisorCount advisors")
-
-	// Add an advice like an interceptor without a pointcut
-	// Will match all proxied methods
-	// Can use for interceptors, before, after returning or throws advice
-	advised.addAdvice(DebugInterceptor())
-
-	// Add selective advice using a pointcut
-	advised.addAdvisor(DefaultPointcutAdvisor(mySpecialPointcut, myAdvice))
-
-	assertEquals("Added two advisors", oldAdvisorCount + 2, advised.advisors.size)
-----
-======
-
-NOTE: It is questionable whether it is advisable (no pun intended) to modify advice on a
-business object in production, although there are, no doubt, legitimate usage cases.
-However, it can be very useful in development (for example, in tests). We have sometimes
-found it very useful to be able to add test code in the form of an interceptor or other
-advice, getting inside a method invocation that we want to test. (For example, the advice can
-get inside a transaction created for that method, perhaps to run SQL to check that
-a database was correctly updated, before marking the transaction for roll back.)
-
-Depending on how you created the proxy, you can usually set a `frozen` flag. In that
-case, the `Advised` `isFrozen()` method returns `true`, and any attempts to modify
-advice through addition or removal results in an `AopConfigException`. The ability
-to freeze the state of an advised object is useful in some cases (for example, to
-prevent calling code removing a security interceptor).
-
-
-
-

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

@@ -1,20 +0,0 @@
-[[aop-api-advisor]]
-= The Advisor API in Spring
-:page-section-summary-toc: 1
-
-In Spring, an Advisor is an aspect that contains only a single advice object associated
-with a pointcut expression.
-
-Apart from the special case of introductions, any advisor can be used with any advice.
-`org.springframework.aop.support.DefaultPointcutAdvisor` is the most commonly used
-advisor class. It can be used with a `MethodInterceptor`, `BeforeAdvice`, or
-`ThrowsAdvice`.
-
-It is possible to mix advisor and advice types in Spring in the same AOP proxy. For
-example, you could use an interception around advice, throws advice, and before advice in
-one proxy configuration. Spring automatically creates the necessary interceptor
-chain.
-
-
-
-

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

@@ -1,131 +0,0 @@
-[[aop-autoproxy]]
-= Using the "auto-proxy" facility
-
-So far, we have considered explicit creation of AOP proxies by using a `ProxyFactoryBean` or
-similar factory bean.
-
-Spring also lets us use "`auto-proxy`" bean definitions, which can automatically
-proxy selected bean definitions. This is built on Spring's "`bean post processor`"
-infrastructure, which enables modification of any bean definition as the container loads.
-
-In this model, you set up some special bean definitions in your XML bean definition file
-to configure the auto-proxy infrastructure. This lets you declare the targets
-eligible for auto-proxying. You need not use `ProxyFactoryBean`.
-
-There are two ways to do this:
-
-* By using an auto-proxy creator that refers to specific beans in the current context.
-* A special case of auto-proxy creation that deserves to be considered separately:
-  auto-proxy creation driven by source-level metadata attributes.
-
-
-
-[[aop-autoproxy-choices]]
-== Auto-proxy Bean Definitions
-
-This section covers the  auto-proxy creators provided by the
-`org.springframework.aop.framework.autoproxy` package.
-
-
-[[aop-api-autoproxy]]
-=== `BeanNameAutoProxyCreator`
-
-The `BeanNameAutoProxyCreator` class is a `BeanPostProcessor` that automatically creates
-AOP proxies for beans with names that match literal values or wildcards. The following
-example shows how to create a `BeanNameAutoProxyCreator` bean:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
-		<property name="beanNames" value="jdk*,onlyJdk"/>
-		<property name="interceptorNames">
-			<list>
-				<value>myInterceptor</value>
-			</list>
-		</property>
-	</bean>
-----
-
-As with `ProxyFactoryBean`, there is an `interceptorNames` property rather than a list
-of interceptors, to allow correct behavior for prototype advisors. Named "`interceptors`"
-can be advisors or any advice type.
-
-As with auto-proxying in general, the main point of using `BeanNameAutoProxyCreator` is
-to apply the same configuration consistently to multiple objects, with minimal volume of
-configuration. It is a popular choice for applying declarative transactions to multiple
-objects.
-
-Bean definitions whose names match, such as `jdkMyBean` and `onlyJdk` in the preceding
-example, are plain old bean definitions with the target class. An AOP proxy is
-automatically created by the `BeanNameAutoProxyCreator`. The same advice is applied
-to all matching beans. Note that, if advisors are used (rather than the interceptor in
-the preceding example), the pointcuts may apply differently to different beans.
-
-
-[[aop-api-autoproxy-default]]
-=== `DefaultAdvisorAutoProxyCreator`
-
-A more general and extremely powerful auto-proxy creator is
-`DefaultAdvisorAutoProxyCreator`. This automagically applies eligible advisors in the
-current context, without the need to include specific bean names in the auto-proxy
-advisor's bean definition. It offers the same merit of consistent configuration and
-avoidance of duplication as `BeanNameAutoProxyCreator`.
-
-Using this mechanism involves:
-
-* Specifying a `DefaultAdvisorAutoProxyCreator` bean definition.
-* Specifying any number of advisors in the same or related contexts. Note that these
-  must be advisors, not interceptors or other advice. This is necessary,
-  because there must be a pointcut to evaluate, to check the eligibility of each advice
-  to candidate bean definitions.
-
-The `DefaultAdvisorAutoProxyCreator` automatically evaluates the pointcut contained
-in each advisor, to see what (if any) advice it should apply to each business object
-(such as `businessObject1` and `businessObject2` in the example).
-
-This means that any number of advisors can be applied automatically to each business
-object. If no pointcut in any of the advisors matches any method in a business object,
-the object is not proxied. As bean definitions are added for new business objects,
-they are automatically proxied if necessary.
-
-Auto-proxying in general has the advantage of making it impossible for callers or
-dependencies to obtain an un-advised object. Calling `getBean("businessObject1")` on this
-`ApplicationContext` returns an AOP proxy, not the target business object. (The "`inner
-bean`" idiom shown earlier also offers this benefit.)
-
-The following example creates a `DefaultAdvisorAutoProxyCreator` bean and the other
-elements discussed in this section:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
-
-	<bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
-		<property name="transactionInterceptor" ref="transactionInterceptor"/>
-	</bean>
-
-	<bean id="customAdvisor" class="com.mycompany.MyAdvisor"/>
-
-	<bean id="businessObject1" class="com.mycompany.BusinessObject1">
-		<!-- Properties omitted -->
-	</bean>
-
-	<bean id="businessObject2" class="com.mycompany.BusinessObject2"/>
-----
-
-The `DefaultAdvisorAutoProxyCreator` is very useful if you want to apply the same advice
-consistently to many business objects. Once the infrastructure definitions are in place,
-you can add new business objects without including specific proxy configuration.
-You can also easily drop in additional aspects (for example, tracing or
-performance monitoring aspects) with minimal change to configuration.
-
-The `DefaultAdvisorAutoProxyCreator` offers support for filtering (by using a naming
-convention so that only certain advisors are evaluated, which allows the use of multiple,
-differently configured, AdvisorAutoProxyCreators in the same factory) and ordering.
-Advisors can implement the `org.springframework.core.Ordered` interface to ensure
-correct ordering if this is an issue. The `TransactionAttributeSourceAdvisor` used in the
-preceding example has a configurable order value. The default setting is unordered.
-
-
-
-

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

@@ -1,71 +0,0 @@
-[[aop-concise-proxy]]
-= Concise Proxy Definitions
-
-Especially when defining transactional proxies, you may end up with many similar proxy
-definitions. The use of parent and child bean definitions, along with inner bean
-definitions, can result in much cleaner and more concise proxy definitions.
-
-First, we create a parent, template, bean definition for the proxy, as follows:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="txProxyTemplate" abstract="true"
-			class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
-		<property name="transactionManager" ref="transactionManager"/>
-		<property name="transactionAttributes">
-			<props>
-				<prop key="*">PROPAGATION_REQUIRED</prop>
-			</props>
-		</property>
-	</bean>
-----
-
-This is never instantiated itself, so it can actually be incomplete. Then, each proxy
-that needs to be created is a child bean definition, which wraps the target of the
-proxy as an inner bean definition, since the target is never used on its own anyway.
-The following example shows such a child bean:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="myService" parent="txProxyTemplate">
-		<property name="target">
-			<bean class="org.springframework.samples.MyServiceImpl">
-			</bean>
-		</property>
-	</bean>
-----
-
-You can override properties from the parent template. In the following example,
-we override the transaction propagation settings:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="mySpecialService" parent="txProxyTemplate">
-		<property name="target">
-			<bean class="org.springframework.samples.MySpecialServiceImpl">
-			</bean>
-		</property>
-		<property name="transactionAttributes">
-			<props>
-				<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
-				<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
-				<prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
-				<prop key="store*">PROPAGATION_REQUIRED</prop>
-			</props>
-		</property>
-	</bean>
-----
-
-Note that in the parent bean example, we explicitly marked the parent bean definition as
-being abstract by setting the `abstract` attribute to `true`, as described
-xref:core/beans/child-bean-definitions.adoc[previously], so that it may not actually ever be
-instantiated. Application contexts (but not simple bean factories), by default,
-pre-instantiate all singletons. Therefore, it is important (at least for singleton beans)
-that, if you have a (parent) bean definition that you intend to use only as a template,
-and this definition specifies a class, you must make sure to set the `abstract`
-attribute to `true`. Otherwise, the application context actually tries to
-pre-instantiate it.
-
-
-
-

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

@@ -1,16 +0,0 @@
-[[aop-extensibility]]
-= Defining New Advice Types
-:page-section-summary-toc: 1
-
-Spring AOP is designed to be extensible. While the interception implementation strategy
-is presently used internally, it is possible to support arbitrary advice types in
-addition to the interception around advice, before, throws advice, and
-after returning advice.
-
-The `org.springframework.aop.framework.adapter` package is an SPI package that lets
-support for new custom advice types be added without changing the core framework.
-The only constraint on a custom `Advice` type is that it must implement the
-`org.aopalliance.aop.Advice` marker interface.
-
-See the {spring-framework-api}/aop/framework/adapter/package-summary.html[`org.springframework.aop.framework.adapter`]
-javadoc for further information.

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

@@ -1,331 +0,0 @@
-[[aop-pfb]]
-= Using the `ProxyFactoryBean` to Create AOP Proxies
-
-If you use the Spring IoC container (an `ApplicationContext` or `BeanFactory`) for your
-business objects (and you should be!), you want to use one of Spring's AOP
-`FactoryBean` implementations. (Remember that a factory bean introduces a layer of indirection, letting
-it create objects of a different type.)
-
-NOTE: The Spring AOP support also uses factory beans under the covers.
-
-The basic way to create an AOP proxy in Spring is to use the
-`org.springframework.aop.framework.ProxyFactoryBean`. This gives complete control over
-the pointcuts, any advice that applies, and their ordering. However, there are simpler
-options that are preferable if you do not need such control.
-
-
-
-[[aop-pfb-1]]
-== Basics
-
-The `ProxyFactoryBean`, like other Spring `FactoryBean` implementations, introduces a
-level of indirection. If you define a `ProxyFactoryBean` named `foo`, objects that
-reference `foo` do not see the `ProxyFactoryBean` instance itself but an object
-created by the implementation of the `getObject()` method in the `ProxyFactoryBean` . This
-method creates an AOP proxy that wraps a target object.
-
-One of the most important benefits of using a `ProxyFactoryBean` or another IoC-aware
-class to create AOP proxies is that advice and pointcuts can also be
-managed by IoC. This is a powerful feature, enabling certain approaches that are hard to
-achieve with other AOP frameworks. For example, an advice may itself reference
-application objects (besides the target, which should be available in any AOP
-framework), benefiting from all the pluggability provided by Dependency Injection.
-
-
-
-[[aop-pfb-2]]
-== JavaBean Properties
-
-In common with most `FactoryBean` implementations provided with Spring, the
-`ProxyFactoryBean` class is itself a JavaBean. Its properties are used to:
-
-* Specify the target you want to proxy.
-* Specify whether to use CGLIB (described later and see also xref:core/aop-api/pfb.adoc#aop-pfb-proxy-types[JDK- and CGLIB-based proxies]).
-
-Some key properties are inherited from `org.springframework.aop.framework.ProxyConfig`
-(the superclass for all AOP proxy factories in Spring). These key properties include
-the following:
-
-* `proxyTargetClass`: `true` if the target class is to be proxied, rather than the
-  target class's interfaces. If this property value is set to `true`, then CGLIB proxies
-  are created (but see also xref:core/aop-api/pfb.adoc#aop-pfb-proxy-types[JDK- and CGLIB-based proxies]).
-* `optimize`: Controls whether or not aggressive optimizations are applied to proxies
-  created through CGLIB. You should not blithely use this setting unless you fully
-  understand how the relevant AOP proxy handles optimization. This is currently used
-  only for CGLIB proxies. It has no effect with JDK dynamic proxies.
-* `frozen`: If a proxy configuration is `frozen`, changes to the configuration are
-  no longer allowed. This is useful both as a slight optimization and for those cases
-  when you do not want callers to be able to manipulate the proxy (through the `Advised`
-  interface) after the proxy has been created. The default value of this property is
-  `false`, so changes (such as adding additional advice) are allowed.
-* `exposeProxy`: Determines whether or not the current proxy should be exposed in a
-  `ThreadLocal` so that it can be accessed by the target. If a target needs to obtain
-  the proxy and the `exposeProxy` property is set to `true`, the target can use the
-  `AopContext.currentProxy()` method.
-
-Other properties specific to `ProxyFactoryBean` include the following:
-
-* `proxyInterfaces`: An array of `String` interface names. If this is not supplied, a CGLIB
-  proxy for the target class is used (but see also xref:core/aop-api/pfb.adoc#aop-pfb-proxy-types[JDK- and CGLIB-based proxies]).
-* `interceptorNames`: A `String` array of `Advisor`, interceptor, or other advice names to
-  apply. Ordering is significant, on a first come-first served basis. That is to say
-  that the first interceptor in the list is the first to be able to intercept the
-  invocation.
-+
-The names are bean names in the current factory, including bean names from ancestor
-factories. You cannot mention bean references here, since doing so results in the
-`ProxyFactoryBean` ignoring the singleton setting of the advice.
-+
-You can append an interceptor name with an asterisk (`*`). Doing so results in the
-application of all advisor beans with names that start with the part before the asterisk
-to be applied. You can find an example of using this feature in xref:core/aop-api/pfb.adoc#aop-global-advisors[Using "`Global`" Advisors].
-
-* singleton: Whether or not the factory should return a single object, no matter how
-  often the `getObject()` method is called. Several `FactoryBean` implementations offer
-  such a method. The default value is `true`. If you want to use stateful advice - for
-  example, for stateful mixins - use prototype advice along with a singleton value of
-  `false`.
-
-
-
-[[aop-pfb-proxy-types]]
-== JDK- and CGLIB-based proxies
-
-This section serves as the definitive documentation on how the `ProxyFactoryBean`
-chooses to create either a JDK-based proxy or a CGLIB-based proxy for a particular target
-object (which is to be proxied).
-
-NOTE: The behavior of the `ProxyFactoryBean` with regard to creating JDK- or CGLIB-based
-proxies changed between versions 1.2.x and 2.0 of Spring. The `ProxyFactoryBean` now
-exhibits similar semantics with regard to auto-detecting interfaces as those of the
-`TransactionProxyFactoryBean` class.
-
-If the class of a target object that is to be proxied (hereafter simply referred to as
-the target class) does not implement any interfaces, a CGLIB-based proxy is
-created. This is the easiest scenario, because JDK proxies are interface-based, and no
-interfaces means JDK proxying is not even possible. You can plug in the target bean
-and specify the list of interceptors by setting the `interceptorNames` property. Note that a
-CGLIB-based proxy is created even if the `proxyTargetClass` property of the
-`ProxyFactoryBean` has been set to `false`. (Doing so makes no sense and is best
-removed from the bean definition, because it is, at best, redundant, and, at worst
-confusing.)
-
-If the target class implements one (or more) interfaces, the type of proxy that is
-created depends on the configuration of the `ProxyFactoryBean`.
-
-If the `proxyTargetClass` property of the `ProxyFactoryBean` has been set to `true`,
-a CGLIB-based proxy is created. This makes sense and is in keeping with the
-principle of least surprise. Even if the `proxyInterfaces` property of the
-`ProxyFactoryBean` has been set to one or more fully qualified interface names, the fact
-that the `proxyTargetClass` property is set to `true` causes CGLIB-based
-proxying to be in effect.
-
-If the `proxyInterfaces` property of the `ProxyFactoryBean` has been set to one or more
-fully qualified interface names, a JDK-based proxy is created. The created
-proxy implements all of the interfaces that were specified in the `proxyInterfaces`
-property. If the target class happens to implement a whole lot more interfaces than
-those specified in the `proxyInterfaces` property, that is all well and good, but those
-additional interfaces are not implemented by the returned proxy.
-
-If the `proxyInterfaces` property of the `ProxyFactoryBean` has not been set, but
-the target class does implement one (or more) interfaces, the
-`ProxyFactoryBean` auto-detects the fact that the target class does actually
-implement at least one interface, and a JDK-based proxy is created. The interfaces
-that are actually proxied are all of the interfaces that the target class
-implements. In effect, this is the same as supplying a list of each and every
-interface that the target class implements to the `proxyInterfaces` property. However,
-it is significantly less work and less prone to typographical errors.
-
-
-
-[[aop-api-proxying-intf]]
-== Proxying Interfaces
-
-Consider a simple example of `ProxyFactoryBean` in action. This example involves:
-
-* A target bean that is proxied. This is the `personTarget` bean definition in
-  the example.
-* An `Advisor` and an `Interceptor` used to provide advice.
-* An AOP proxy bean definition to specify the target object (the `personTarget` bean),
-  the interfaces to proxy, and the advice to apply.
-
-The following listing shows the example:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="personTarget" class="com.mycompany.PersonImpl">
-		<property name="name" value="Tony"/>
-		<property name="age" value="51"/>
-	</bean>
-
-	<bean id="myAdvisor" class="com.mycompany.MyAdvisor">
-		<property name="someProperty" value="Custom string property value"/>
-	</bean>
-
-	<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor">
-	</bean>
-
-	<bean id="person"
-		class="org.springframework.aop.framework.ProxyFactoryBean">
-		<property name="proxyInterfaces" value="com.mycompany.Person"/>
-
-		<property name="target" ref="personTarget"/>
-		<property name="interceptorNames">
-			<list>
-				<value>myAdvisor</value>
-				<value>debugInterceptor</value>
-			</list>
-		</property>
-	</bean>
-----
-
-Note that the `interceptorNames` property takes a list of `String`, which holds the bean names of the
-interceptors or advisors in the current factory. You can use advisors, interceptors, before, after
-returning, and throws advice objects. The ordering of advisors is significant.
-
-NOTE: You might be wondering why the list does not hold bean references. The reason for this is
-that, if the singleton property of the `ProxyFactoryBean` is set to `false`, it must be able to
-return independent proxy instances. If any of the advisors is itself a prototype, an
-independent instance would need to be returned, so it is necessary to be able to obtain
-an instance of the prototype from the factory. Holding a reference is not sufficient.
-
-The `person` bean definition shown earlier can be used in place of a `Person` implementation, as
-follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	Person person = (Person) factory.getBean("person");
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val person = factory.getBean("person") as Person;
-----
-======
-
-Other beans in the same IoC context can express a strongly typed dependency on it, as
-with an ordinary Java object. The following example shows how to do so:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="personUser" class="com.mycompany.PersonUser">
-		<property name="person"><ref bean="person"/></property>
-	</bean>
-----
-
-The `PersonUser` class in this example exposes a property of type `Person`. As far as
-it is concerned, the AOP proxy can be used transparently in place of a "`real`" person
-implementation. However, its class would be a dynamic proxy class. It would be possible
-to cast it to the `Advised` interface (discussed later).
-
-You can conceal the distinction between target and proxy by using an anonymous
-inner bean. Only the `ProxyFactoryBean` definition is different. The
-advice is included only for completeness. The following example shows how to use an
-anonymous inner bean:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="myAdvisor" class="com.mycompany.MyAdvisor">
-		<property name="someProperty" value="Custom string property value"/>
-	</bean>
-
-	<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor"/>
-
-	<bean id="person" class="org.springframework.aop.framework.ProxyFactoryBean">
-		<property name="proxyInterfaces" value="com.mycompany.Person"/>
-		<!-- Use inner bean, not local reference to target -->
-		<property name="target">
-			<bean class="com.mycompany.PersonImpl">
-				<property name="name" value="Tony"/>
-				<property name="age" value="51"/>
-			</bean>
-		</property>
-		<property name="interceptorNames">
-			<list>
-				<value>myAdvisor</value>
-				<value>debugInterceptor</value>
-			</list>
-		</property>
-	</bean>
-----
-
-Using an anonymous inner bean has the advantage that there is only one object of type `Person`. This is useful if we want
-to prevent users of the application context from obtaining a reference to the un-advised
-object or need to avoid any ambiguity with Spring IoC autowiring. There is also,
-arguably, an advantage in that the `ProxyFactoryBean` definition is self-contained.
-However, there are times when being able to obtain the un-advised target from the
-factory might actually be an advantage (for example, in certain test scenarios).
-
-
-
-[[aop-api-proxying-class]]
-== Proxying Classes
-
-What if you need to proxy a class, rather than one or more interfaces?
-
-Imagine that in our earlier example, there was no `Person` interface. We needed to advise
-a class called `Person` that did not implement any business interface. In this case, you
-can configure Spring to use CGLIB proxying rather than dynamic proxies. To do so, set the
-`proxyTargetClass` property on the `ProxyFactoryBean` shown earlier to `true`. While it is best to
-program to interfaces rather than classes, the ability to advise classes that do not
-implement interfaces can be useful when working with legacy code. (In general, Spring
-is not prescriptive. While it makes it easy to apply good practices, it avoids forcing a
-particular approach.)
-
-If you want to, you can force the use of CGLIB in any case, even if you do have
-interfaces.
-
-CGLIB proxying works by generating a subclass of the target class at runtime. Spring
-configures this generated subclass to delegate method calls to the original target. The
-subclass is used to implement the Decorator pattern, weaving in the advice.
-
-CGLIB proxying should generally be transparent to users. However, there are some issues
-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
-JDK dynamic proxies.
-
-There is little performance difference between CGLIB proxies and dynamic proxies.
-Performance should not be a decisive consideration in this case.
-
-
-
-[[aop-global-advisors]]
-== Using "`Global`" Advisors
-
-By appending an asterisk to an interceptor name, all advisors with bean names that match
-the part before the asterisk are added to the advisor chain. This can come in handy
-if you need to add a standard set of "`global`" advisors. The following example defines
-two global advisors:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
-		<property name="target" ref="service"/>
-		<property name="interceptorNames">
-			<list>
-				<value>global*</value>
-			</list>
-		</property>
-	</bean>
-
-	<bean id="global_debug" class="org.springframework.aop.interceptor.DebugInterceptor"/>
-	<bean id="global_performance" class="org.springframework.aop.interceptor.PerformanceMonitorInterceptor"/>
-----
-
-
-
-

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

@@ -1,256 +0,0 @@
-[[aop-api-pointcuts]]
-= Pointcut API in Spring
-
-This section describes how Spring handles the crucial pointcut concept.
-
-
-
-[[aop-api-concepts]]
-== Concepts
-
-Spring's pointcut model enables pointcut reuse independent of advice types. You can
-target different advice with the same pointcut.
-
-The `org.springframework.aop.Pointcut` interface is the central interface, used to
-target advice to particular classes and methods. The complete interface follows:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface Pointcut {
-
-		ClassFilter getClassFilter();
-
-		MethodMatcher getMethodMatcher();
-	}
-----
-
-Splitting the `Pointcut` interface into two parts allows reuse of class and method
-matching parts and fine-grained composition operations (such as performing a "`union`"
-with another method matcher).
-
-The `ClassFilter` interface is used to restrict the pointcut to a given set of target
-classes. If the `matches()` method always returns true, all target classes are
-matched. The following listing shows the `ClassFilter` interface definition:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface ClassFilter {
-
-		boolean matches(Class clazz);
-	}
-----
-
-The `MethodMatcher` interface is normally more important. The complete interface follows:
-
-[source,java,indent=0,subs="verbatim,quotes"]
-----
-	public interface MethodMatcher {
-
-		boolean matches(Method m, Class<?> targetClass);
-
-		boolean isRuntime();
-
-		boolean matches(Method m, Class<?> targetClass, Object... args);
-	}
-----
-
-The `matches(Method, Class)` method is used to test whether this pointcut ever
-matches a given method on a target class. This evaluation can be performed when an AOP
-proxy is created to avoid the need for a test on every method invocation. If the
-two-argument `matches` method returns `true` for a given method, and the `isRuntime()`
-method for the MethodMatcher returns `true`, the three-argument matches method is
-invoked on every method invocation. This lets a pointcut look at the arguments passed
-to the method invocation immediately before the target advice starts.
-
-Most `MethodMatcher` implementations are static, meaning that their `isRuntime()` method
-returns `false`. In this case, the three-argument `matches` method is never invoked.
-
-TIP: If possible, try to make pointcuts static, allowing the AOP framework to cache the
-results of pointcut evaluation when an AOP proxy is created.
-
-
-
-[[aop-api-pointcut-ops]]
-== Operations on Pointcuts
-
-Spring supports operations (notably, union and intersection) on pointcuts.
-
-Union means the methods that either pointcut matches.
-Intersection means the methods that both pointcuts match.
-Union is usually more useful.
-You can compose pointcuts by using the static methods in the
-`org.springframework.aop.support.Pointcuts` class or by using the
-`ComposablePointcut` class in the same package. However, using AspectJ pointcut
-expressions is usually a simpler approach.
-
-
-
-[[aop-api-pointcuts-aspectj]]
-== AspectJ Expression Pointcuts
-
-Since 2.0, the most important type of pointcut used by Spring is
-`org.springframework.aop.aspectj.AspectJExpressionPointcut`. This is a pointcut that
-uses an AspectJ-supplied library to parse an AspectJ pointcut expression string.
-
-See the xref:core/aop.adoc[previous chapter] for a discussion of supported AspectJ pointcut primitives.
-
-
-
-[[aop-api-pointcuts-impls]]
-== Convenience Pointcut Implementations
-
-Spring provides several convenient pointcut implementations. You can use some of them
-directly; others are intended to be subclassed in application-specific pointcuts.
-
-
-[[aop-api-pointcuts-static]]
-=== Static Pointcuts
-
-Static pointcuts are based on the method and the target class and cannot take into account
-the method's arguments. Static pointcuts suffice -- and are best -- for most usages.
-Spring can evaluate a static pointcut only once, when a method is first invoked.
-After that, there is no need to evaluate the pointcut again with each method invocation.
-
-The rest of this section describes some of the static pointcut implementations that are
-included with Spring.
-
-[[aop-api-pointcuts-regex]]
-==== Regular Expression Pointcuts
-
-One obvious way to specify static pointcuts is regular expressions. Several AOP
-frameworks besides Spring make this possible.
-`org.springframework.aop.support.JdkRegexpMethodPointcut` is a generic regular
-expression pointcut that uses the regular expression support in the JDK.
-
-With the `JdkRegexpMethodPointcut` class, you can provide a list of pattern strings.
-If any of these is a match, the pointcut evaluates to `true`. (As a consequence,
-the resulting pointcut is effectively the union of the specified patterns.)
-
-The following example shows how to use `JdkRegexpMethodPointcut`:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<bean id="settersAndAbsquatulatePointcut"
-			class="org.springframework.aop.support.JdkRegexpMethodPointcut">
-		<property name="patterns">
-			<list>
-				<value>.*set.*</value>
-				<value>.*absquatulate</value>
-			</list>
-		</property>
-	</bean>
-----
-
-Spring provides a convenience class named `RegexpMethodPointcutAdvisor`, which lets us
-also reference an `Advice` (remember that an `Advice` can be an interceptor, before advice,
-throws advice, and others). Behind the scenes, Spring uses a `JdkRegexpMethodPointcut`.
-Using `RegexpMethodPointcutAdvisor` simplifies wiring, as the one bean encapsulates both
-pointcut and advice, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<bean id="settersAndAbsquatulateAdvisor"
-			class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
-		<property name="advice">
-			<ref bean="beanNameOfAopAllianceInterceptor"/>
-		</property>
-		<property name="patterns">
-			<list>
-				<value>.*set.*</value>
-				<value>.*absquatulate</value>
-			</list>
-		</property>
-	</bean>
-----
-
-You can use `RegexpMethodPointcutAdvisor` with any `Advice` type.
-
-[[aop-api-pointcuts-attribute-driven]]
-==== Attribute-driven Pointcuts
-
-An important type of static pointcut is a metadata-driven pointcut. This uses the
-values of metadata attributes (typically, source-level metadata).
-
-
-[[aop-api-pointcuts-dynamic]]
-=== Dynamic pointcuts
-
-Dynamic pointcuts are costlier to evaluate than static pointcuts. They take into account
-method arguments as well as static information. This means that they must be
-evaluated with every method invocation and that the result cannot be cached, as arguments will
-vary.
-
-The main example is the `control flow` pointcut.
-
-[[aop-api-pointcuts-cflow]]
-==== Control Flow Pointcuts
-
-Spring control flow pointcuts are conceptually similar to AspectJ `cflow` pointcuts,
-although less powerful. (There is currently no way to specify that a pointcut runs
-below a join point matched by another pointcut.) A control flow pointcut matches the
-current call stack. For example, it might fire if the join point was invoked by a method
-in the `com.mycompany.web` package or by the `SomeCaller` class. Control flow pointcuts
-are specified by using the `org.springframework.aop.support.ControlFlowPointcut` class.
-
-NOTE: Control flow pointcuts are significantly more expensive to evaluate at runtime than even
-other dynamic pointcuts. In Java 1.4, the cost is about five times that of other dynamic
-pointcuts.
-
-
-
-[[aop-api-pointcuts-superclasses]]
-== Pointcut Superclasses
-
-Spring provides useful pointcut superclasses to help you to implement your own pointcuts.
-
-Because static pointcuts are most useful, you should probably subclass
-`StaticMethodMatcherPointcut`. This requires implementing only one
-abstract method (although you can override other methods to customize behavior). The
-following example shows how to subclass `StaticMethodMatcherPointcut`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	class TestStaticPointcut extends StaticMethodMatcherPointcut {
-
-		public boolean matches(Method m, Class targetClass) {
-			// return true if custom criteria match
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	class TestStaticPointcut : StaticMethodMatcherPointcut() {
-
-		override fun matches(method: Method, targetClass: Class<*>): Boolean {
-			// return true if custom criteria match
-		}
-	}
-----
-======
-
-There are also superclasses for dynamic pointcuts.
-You can use custom pointcuts with any advice type.
-
-
-
-[[aop-api-pointcuts-custom]]
-== Custom Pointcuts
-
-Because pointcuts in Spring AOP are Java classes rather than language features (as in
-AspectJ), you can declare custom pointcuts, whether static or dynamic. Custom
-pointcuts in Spring can be arbitrarily complex. However, we recommend using the AspectJ pointcut
-expression language, if you can.
-
-NOTE: Later versions of Spring may offer support for "`semantic pointcuts`" as offered by JAC --
-for example, "`all methods that change instance variables in the target object.`"
-
-
-
-

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

@@ -1,54 +0,0 @@
-[[aop-prog]]
-= Creating AOP Proxies Programmatically with the `ProxyFactory`
-
-It is easy to create AOP proxies programmatically with Spring. This lets you use
-Spring AOP without dependency on Spring IoC.
-
-The interfaces implemented by the target object are
-automatically proxied. The following listing shows creation of a proxy for a target object, with one
-interceptor and one advisor:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	ProxyFactory factory = new ProxyFactory(myBusinessInterfaceImpl);
-	factory.addAdvice(myMethodInterceptor);
-	factory.addAdvisor(myAdvisor);
-	MyBusinessInterface tb = (MyBusinessInterface) factory.getProxy();
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val factory = ProxyFactory(myBusinessInterfaceImpl)
-	factory.addAdvice(myMethodInterceptor)
-	factory.addAdvisor(myAdvisor)
-	val tb = factory.proxy as MyBusinessInterface
-----
-======
-
-The first step is to construct an object of type
-`org.springframework.aop.framework.ProxyFactory`. You can create this with a target
-object, as in the preceding example, or specify the interfaces to be proxied in an alternate
-constructor.
-
-You can add advice (with interceptors as a specialized kind of advice), advisors, or both
-and manipulate them for the life of the `ProxyFactory`. If you add an
-`IntroductionInterceptionAroundAdvisor`, you can cause the proxy to implement additional
-interfaces.
-
-There are also convenience methods on `ProxyFactory` (inherited from `AdvisedSupport`)
-that let you add other advice types, such as before and throws advice.
-`AdvisedSupport` is the superclass of both `ProxyFactory` and `ProxyFactoryBean`.
-
-TIP: Integrating AOP proxy creation with the IoC framework is best practice in most
-applications. We recommend that you externalize configuration from Java code with AOP,
-as you should in general.
-
-
-
-

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

@@ -1,232 +0,0 @@
-[[aop-targetsource]]
-= Using `TargetSource` Implementations
-
-Spring offers the concept of a `TargetSource`, expressed in the
-`org.springframework.aop.TargetSource` interface. This interface is responsible for
-returning the "`target object`" that implements the join point. The `TargetSource`
-implementation is asked for a target instance each time the AOP proxy handles a method
-invocation.
-
-Developers who use Spring AOP do not normally need to work directly with `TargetSource` implementations, but
-this provides a powerful means of supporting pooling, hot swappable, and other
-sophisticated targets. For example, a pooling `TargetSource` can return a different target
-instance for each invocation, by using a pool to manage instances.
-
-If you do not specify a `TargetSource`, a default implementation is used to wrap a
-local object. The same target is returned for each invocation (as you would expect).
-
-The rest of this section describes the standard target sources provided with Spring and how you can use them.
-
-TIP: When using a custom target source, your target will usually need to be a prototype
-rather than a singleton bean definition. This allows Spring to create a new target
-instance when required.
-
-
-
-[[aop-ts-swap]]
-== Hot-swappable Target Sources
-
-The `org.springframework.aop.target.HotSwappableTargetSource` exists to let the target
-of an AOP proxy be switched while letting callers keep their references to it.
-
-Changing the target source's target takes effect immediately. The
-`HotSwappableTargetSource` is thread-safe.
-
-You can change the target by using the `swap()` method on HotSwappableTargetSource, as the follow example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	HotSwappableTargetSource swapper = (HotSwappableTargetSource) beanFactory.getBean("swapper");
-	Object oldTarget = swapper.swap(newTarget);
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val swapper = beanFactory.getBean("swapper") as HotSwappableTargetSource
-	val oldTarget = swapper.swap(newTarget)
-----
-======
-
-The following example shows the required XML definitions:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="initialTarget" class="mycompany.OldTarget"/>
-
-	<bean id="swapper" class="org.springframework.aop.target.HotSwappableTargetSource">
-		<constructor-arg ref="initialTarget"/>
-	</bean>
-
-	<bean id="swappable" class="org.springframework.aop.framework.ProxyFactoryBean">
-		<property name="targetSource" ref="swapper"/>
-	</bean>
-----
-
-The preceding `swap()` call changes the target of the swappable bean. Clients that hold a
-reference to that bean are unaware of the change but immediately start hitting
-the new target.
-
-Although this example does not add any advice (it is not necessary to add advice to
-use a `TargetSource`), any `TargetSource` can be used in conjunction with
-arbitrary advice.
-
-
-
-[[aop-ts-pool]]
-== Pooling Target Sources
-
-Using a pooling target source provides a similar programming model to stateless session
-EJBs, in which a pool of identical instances is maintained, with method invocations
-going to free objects in the pool.
-
-A crucial difference between Spring pooling and SLSB pooling is that Spring pooling can
-be applied to any POJO. As with Spring in general, this service can be applied in a
-non-invasive way.
-
-Spring provides support for Commons Pool 2.2, which provides a
-fairly efficient pooling implementation. You need the `commons-pool` Jar on your
-application's classpath to use this feature. You can also subclass
-`org.springframework.aop.target.AbstractPoolingTargetSource` to support any other
-pooling API.
-
-NOTE: Commons Pool 1.5+ is also supported but is deprecated as of Spring Framework 4.2.
-
-The following listing shows an example configuration:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="businessObjectTarget" class="com.mycompany.MyBusinessObject"
-			scope="prototype">
-		... properties omitted
-	</bean>
-
-	<bean id="poolTargetSource" class="org.springframework.aop.target.CommonsPool2TargetSource">
-		<property name="targetBeanName" value="businessObjectTarget"/>
-		<property name="maxSize" value="25"/>
-	</bean>
-
-	<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
-		<property name="targetSource" ref="poolTargetSource"/>
-		<property name="interceptorNames" value="myInterceptor"/>
-	</bean>
-----
-
-Note that the target object (`businessObjectTarget` in the preceding example) must be a
-prototype. This lets the `PoolingTargetSource` implementation create new instances
-of the target to grow the pool as necessary. See the {spring-framework-api}/aop/target/AbstractPoolingTargetSource.html[javadoc of
-`AbstractPoolingTargetSource`] and the concrete subclass you wish to use for information
-about its properties. `maxSize` is the most basic and is always guaranteed to be present.
-
-In this case, `myInterceptor` is the name of an interceptor that would need to be
-defined in the same IoC context. However, you need not specify interceptors to
-use pooling. If you want only pooling and no other advice, do not set the
-`interceptorNames` property at all.
-
-You can configure Spring to be able to cast any pooled object to the
-`org.springframework.aop.target.PoolingConfig` interface, which exposes information
-about the configuration and current size of the pool through an introduction. You
-need to define an advisor similar to the following:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="poolConfigAdvisor" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
-		<property name="targetObject" ref="poolTargetSource"/>
-		<property name="targetMethod" value="getPoolingConfigMixin"/>
-	</bean>
-----
-
-This advisor is obtained by calling a convenience method on the
-`AbstractPoolingTargetSource` class, hence the use of `MethodInvokingFactoryBean`. This
-advisor's name (`poolConfigAdvisor`, here) must be in the list of interceptors names in
-the `ProxyFactoryBean` that exposes the pooled object.
-
-The cast is defined as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim,quotes",role="primary"]
-----
-	PoolingConfig conf = (PoolingConfig) beanFactory.getBean("businessObject");
-	System.out.println("Max pool size is " + conf.getMaxSize());
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim,quotes",role="secondary"]
-----
-	val conf = beanFactory.getBean("businessObject") as PoolingConfig
-	println("Max pool size is " + conf.maxSize)
-----
-======
-
-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
-pooling is problematic if resources are cached.
-
-Simpler pooling is available by using auto-proxying. You can set the `TargetSource` implementations
-used by any auto-proxy creator.
-
-
-
-[[aop-ts-prototype]]
-== Prototype Target Sources
-
-Setting up a "`prototype`" target source is similar to setting up a pooling `TargetSource`. In this
-case, a new instance of the target is created on every method invocation. Although
-the cost of creating a new object is not high in a modern JVM, the cost of wiring up the
-new object (satisfying its IoC dependencies) may be more expensive. Thus, you should not
-use this approach without very good reason.
-
-To do this, you could modify the `poolTargetSource` definition shown earlier as follows
-(we also changed the name, for clarity):
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="prototypeTargetSource" class="org.springframework.aop.target.PrototypeTargetSource">
-		<property name="targetBeanName" ref="businessObjectTarget"/>
-	</bean>
-----
-
-The only property is the name of the target bean. Inheritance is used in the
-`TargetSource` implementations to ensure consistent naming. As with the pooling target
-source, the target bean must be a prototype bean definition.
-
-
-
-[[aop-ts-threadlocal]]
-== `ThreadLocal` Target Sources
-
-`ThreadLocal` target sources are useful if you need an object to be created for each
-incoming request (per thread that is). The concept of a `ThreadLocal` provides a JDK-wide
-facility to transparently store a resource alongside a thread. Setting up a
-`ThreadLocalTargetSource` is pretty much the same as was explained for the other types
-of target source, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim,quotes"]
-----
-	<bean id="threadlocalTargetSource" class="org.springframework.aop.target.ThreadLocalTargetSource">
-		<property name="targetBeanName" value="businessObjectTarget"/>
-	</bean>
-----
-
-NOTE: `ThreadLocal` instances come with serious issues (potentially resulting in memory leaks) when
-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
-any case, since not unsetting it might result in problematic behavior. Spring's
-`ThreadLocal` support does this for you and should always be considered in favor of using
-`ThreadLocal` instances without other proper handling code.
-
-
-
-

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

@@ -1,38 +0,0 @@
-[[aop]]
-= Aspect Oriented Programming with Spring
-
-Aspect-oriented Programming (AOP) complements Object-oriented Programming (OOP) by
-providing another way of thinking about program structure. The key unit of modularity
-in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects
-enable the modularization of concerns (such as transaction management) that cut across
-multiple types and objects. (Such concerns are often termed "crosscutting" concerns
-in AOP literature.)
-
-One of the key components of Spring is the AOP framework. While the Spring IoC
-container does not depend on AOP (meaning you do not need to use AOP if you don't want
-to), AOP complements Spring IoC to provide a very capable middleware solution.
-
-.Spring AOP with AspectJ pointcuts
-****
-Spring provides simple and powerful ways of writing custom aspects by using either a
-xref:core/aop/schema.adoc[schema-based approach] or the xref:core/aop/ataspectj.adoc[@AspectJ annotation style].
-Both of these styles offer fully typed advice and use of the AspectJ pointcut language
-while still using Spring AOP for weaving.
-
-This chapter discusses the schema- and @AspectJ-based AOP support.
-The lower-level AOP support is discussed in xref:core/aop-api.adoc[the following chapter].
-****
-
-AOP is used in the Spring Framework to:
-
-* Provide declarative enterprise services. The most important such service is
-  xref:data-access/transaction/declarative.adoc[declarative transaction management].
-* Let users implement custom aspects, complementing their use of OOP with AOP.
-
-NOTE: If you are interested only in generic declarative services or other pre-packaged
-declarative middleware services such as pooling, you do not need to work directly with
-Spring AOP, and can skip most of this chapter.
-
-
-
-

framework-docs/modules/ROOT/pages/core/aop/aspectj-programmatic.adoc

@@ -1,59 +0,0 @@
-[[aop-aspectj-programmatic]]
-= Programmatic Creation of @AspectJ Proxies
-
-In addition to declaring aspects in your configuration by using either `<aop:config>`
-or `<aop:aspectj-autoproxy>`, it is also possible to programmatically create proxies
-that advise target objects. For the full details of Spring's AOP API, see the
-xref:core/aop-api.adoc[next chapter]. Here, we want to focus on the ability to automatically
-create proxies by using @AspectJ aspects.
-
-You can use the `org.springframework.aop.aspectj.annotation.AspectJProxyFactory` class
-to create a proxy for a target object that is advised by one or more @AspectJ aspects.
-The basic usage for this class is very simple, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	// create a factory that can generate a proxy for the given target object
-	AspectJProxyFactory factory = new AspectJProxyFactory(targetObject);
-
-	// add an aspect, the class must be an @AspectJ aspect
-	// you can call this as many times as you need with different aspects
-	factory.addAspect(SecurityManager.class);
-
-	// you can also add existing aspect instances, the type of the object supplied
-	// must be an @AspectJ aspect
-	factory.addAspect(usageTracker);
-
-	// now get the proxy object...
-	MyInterfaceType proxy = factory.getProxy();
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	// create a factory that can generate a proxy for the given target object
-	val factory = AspectJProxyFactory(targetObject)
-
-	// add an aspect, the class must be an @AspectJ aspect
-	// you can call this as many times as you need with different aspects
-	factory.addAspect(SecurityManager::class.java)
-
-	// you can also add existing aspect instances, the type of the object supplied
-	// must be an @AspectJ aspect
-	factory.addAspect(usageTracker)
-
-	// now get the proxy object...
-	val proxy = factory.getProxy<Any>()
-----
-======
-
-See the {spring-framework-api}/aop/aspectj/annotation/AspectJProxyFactory.html[javadoc] for more information.
-
-
-
-

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

@@ -1,16 +0,0 @@
-[[aop-ataspectj]]
-= @AspectJ support
-:page-section-summary-toc: 1
-
-@AspectJ refers to a style of declaring aspects as regular Java classes annotated with
-annotations. The @AspectJ style was introduced by the
-{aspectj-site}[AspectJ project] as part of the AspectJ 5 release. Spring
-interprets the same annotations as AspectJ 5, using a library supplied by AspectJ
-for pointcut parsing and matching. The AOP runtime is still pure Spring AOP, though, and
-there is no dependency on the AspectJ compiler or weaver.
-
-NOTE: Using the AspectJ compiler and weaver enables use of the full AspectJ language and
-is discussed in xref:core/aop/using-aspectj.adoc[Using AspectJ with Spring Applications].
-
-
-

framework-docs/modules/ROOT/pages/core/aop/ataspectj/advice.adoc

@@ -1,941 +0,0 @@
-[[aop-advice]]
-= Declaring Advice
-
-Advice is associated with a pointcut expression and runs before, after, or around method
-executions matched by the pointcut. The pointcut expression may be either an _inline
-pointcut_ or a reference to a xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[_named pointcut_].
-
-
-[[aop-advice-before]]
-== Before Advice
-
-You can declare before advice in an aspect by using the `@Before` annotation.
-
-The following example uses an inline pointcut expression.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.Before;
-
-	@Aspect
-	public class BeforeExample {
-
-		@Before("execution(* com.xyz.dao.*.*(..))")
-		public void doAccessCheck() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.Before
-
-	@Aspect
-	class BeforeExample {
-
-		@Before("execution(* com.xyz.dao.*.*(..))")
-		fun doAccessCheck() {
-			// ...
-		}
-	}
-----
-======
-
-If we use a xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[named pointcut], we can rewrite the preceding example
-as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.Before;
-
-	@Aspect
-	public class BeforeExample {
-
-		@Before("com.xyz.CommonPointcuts.dataAccessOperation()")
-		public void doAccessCheck() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.Before
-
-	@Aspect
-	class BeforeExample {
-
-		@Before("com.xyz.CommonPointcuts.dataAccessOperation()")
-		fun doAccessCheck() {
-			// ...
-		}
-	}
-----
-======
-
-
-[[aop-advice-after-returning]]
-== After Returning Advice
-
-After returning advice runs when a matched method execution returns normally.
-You can declare it by using the `@AfterReturning` annotation.
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterReturning;
-
-	@Aspect
-	public class AfterReturningExample {
-
-		@AfterReturning("execution(* com.xyz.dao.*.*(..))")
-		public void doAccessCheck() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterReturning
-
-	@Aspect
-	class AfterReturningExample {
-
-		@AfterReturning("execution(* com.xyz.dao.*.*(..))")
-		fun doAccessCheck() {
-			// ...
-		}
-	}
-----
-======
-
-NOTE: You can have multiple advice declarations (and other members as well),
-all inside the same aspect. We show only a single advice declaration in these
-examples to focus the effect of each one.
-
-Sometimes, you need access in the advice body to the actual value that was returned.
-You can use the form of `@AfterReturning` that binds the return value to get that
-access, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterReturning;
-
-	@Aspect
-	public class AfterReturningExample {
-
-		@AfterReturning(
-			pointcut="execution(* com.xyz.dao.*.*(..))",
-			returning="retVal")
-		public void doAccessCheck(Object retVal) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterReturning
-
-	@Aspect
-	class AfterReturningExample {
-
-		@AfterReturning(
-			pointcut = "execution(* com.xyz.dao.*.*(..))",
-			returning = "retVal")
-		fun doAccessCheck(retVal: Any?) {
-			// ...
-		}
-	}
-----
-======
-
-The name used in the `returning` attribute must correspond to the name of a parameter
-in the advice method. When a method execution returns, the return value is passed to
-the advice method as the corresponding argument value. A `returning` clause also
-restricts matching to only those method executions that return a value of the
-specified type (in this case, `Object`, which matches any return value).
-
-Please note that it is not possible to return a totally different reference when
-using after returning advice.
-
-
-[[aop-advice-after-throwing]]
-== After Throwing Advice
-
-After throwing advice runs when a matched method execution exits by throwing an
-exception. You can declare it by using the `@AfterThrowing` annotation, as the
-following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterThrowing;
-
-	@Aspect
-	public class AfterThrowingExample {
-
-		@AfterThrowing("execution(* com.xyz.dao.*.*(..))")
-		public void doRecoveryActions() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterThrowing
-
-	@Aspect
-	class AfterThrowingExample {
-
-		@AfterThrowing("execution(* com.xyz.dao.*.*(..))")
-		fun doRecoveryActions() {
-			// ...
-		}
-	}
-----
-======
-
-Often, you want the advice to run only when exceptions of a given type are thrown,
-and you also often need access to the thrown exception in the advice body. You can
-use the `throwing` attribute to both restrict matching (if desired -- use `Throwable`
-as the exception type otherwise) and bind the thrown exception to an advice parameter.
-The following example shows how to do so:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.AfterThrowing;
-
-	@Aspect
-	public class AfterThrowingExample {
-
-		@AfterThrowing(
-			pointcut="execution(* com.xyz.dao.*.*(..))",
-			throwing="ex")
-		public void doRecoveryActions(DataAccessException ex) {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.AfterThrowing
-
-	@Aspect
-	class AfterThrowingExample {
-
-		@AfterThrowing(
-			pointcut = "execution(* com.xyz.dao.*.*(..))",
-			throwing = "ex")
-		fun doRecoveryActions(ex: DataAccessException) {
-			// ...
-		}
-	}
-----
-======
-
-The name used in the `throwing` attribute must correspond to the name of a parameter in
-the advice method. When a method execution exits by throwing an exception, the exception
-is passed to the advice method as the corresponding argument value. A `throwing` clause
-also restricts matching to only those method executions that throw an exception of the
-specified type (`DataAccessException`, in this case).
-
-[NOTE]
-====
-Note that `@AfterThrowing` does not indicate a general exception handling callback.
-Specifically, an `@AfterThrowing` advice method is only supposed to receive exceptions
-from the join point (user-declared target method) itself but not from an accompanying
-`@After`/`@AfterReturning` method.
-====
-
-
-[[aop-advice-after-finally]]
-== After (Finally) Advice
-
-After (finally) advice runs when a matched method execution exits. It is declared by
-using the `@After` annotation. After advice must be prepared to handle both normal and
-exception return conditions. It is typically used for releasing resources and similar
-purposes. The following example shows how to use after finally advice:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.After;
-
-	@Aspect
-	public class AfterFinallyExample {
-
-		@After("execution(* com.xyz.dao.*.*(..))")
-		public void doReleaseLock() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.After
-
-	@Aspect
-	class AfterFinallyExample {
-
-		@After("execution(* com.xyz.dao.*.*(..))")
-		fun doReleaseLock() {
-			// ...
-		}
-	}
-----
-======
-
-[NOTE]
-====
-Note that `@After` advice in AspectJ is defined as "after finally advice", analogous
-to a finally block in a try-catch statement. It will be invoked for any outcome,
-normal return or exception thrown from the join point (user-declared target method),
-in contrast to `@AfterReturning` which only applies to successful normal returns.
-====
-
-
-[[aop-ataspectj-around-advice]]
-== Around Advice
-
-The last kind of advice is _around_ advice. Around advice runs "around" a matched
-method's execution. It has the opportunity to do work both before and after the method
-runs and to determine when, how, and even if the method actually gets to run at all.
-Around advice is often used if you need to share state before and after a method
-execution in a thread-safe manner – for example, starting and stopping a timer.
-
-[TIP]
-====
-Always use the least powerful form of advice that meets your requirements.
-
-For example, do not use _around_ advice if _before_ advice is sufficient for your needs.
-====
-
-Around advice is declared by annotating a method with the `@Around` annotation. The
-method should declare `Object` as its return type, and the first parameter of the method
-must be of type `ProceedingJoinPoint`. Within the body of the advice method, you must
-invoke `proceed()` on the `ProceedingJoinPoint` in order for the underlying method to
-run. Invoking `proceed()` without arguments will result in the caller's original
-arguments being supplied to the underlying method when it is invoked. For advanced use
-cases, there is an overloaded variant of the `proceed()` method which accepts an array of
-arguments (`Object[]`). The values in the array will be used as the arguments to the
-underlying method when it is invoked.
-
-[NOTE]
-====
-The behavior of `proceed` when called with an `Object[]` is a little different than the
-behavior of `proceed` for around advice compiled by the AspectJ compiler. For around
-advice written using the traditional AspectJ language, the number of arguments passed to
-`proceed` must match the number of arguments passed to the around advice (not the number
-of arguments taken by the underlying join point), and the value passed to proceed in a
-given argument position supplants the original value at the join point for the entity the
-value was bound to (do not worry if this does not make sense right now).
-
-The approach taken by Spring is simpler and a better match to its proxy-based,
-execution-only semantics. You only need to be aware of this difference if you compile
-`@AspectJ` aspects written for Spring and use `proceed` with arguments with the AspectJ
-compiler and weaver. There is a way to write such aspects that is 100% compatible across
-both Spring AOP and AspectJ, and this is discussed in the
-xref:core/aop/ataspectj/advice.adoc#aop-ataspectj-advice-proceeding-with-the-call[following section on advice parameters].
-====
-
-The value returned by the around advice is the return value seen by the caller of the
-method. For example, a simple caching aspect could return a value from a cache if it has
-one or invoke `proceed()` (and return that value) if it does not. Note that `proceed`
-may be invoked once, many times, or not at all within the body of the around advice. All
-of these are legal.
-
-WARNING: If you declare the return type of your around advice method as `void`, `null`
-will always be returned to the caller, effectively ignoring the result of any invocation
-of `proceed()`. It is therefore recommended that an around advice method declare a return
-type of `Object`. The advice method should typically return the value returned from an
-invocation of `proceed()`, even if the underlying method has a `void` return type.
-However, the advice may optionally return a cached value, a wrapped value, or some other
-value depending on the use case.
-
-The following example shows how to use around advice:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	import org.aspectj.lang.annotation.Aspect;
-	import org.aspectj.lang.annotation.Around;
-	import org.aspectj.lang.ProceedingJoinPoint;
-
-	@Aspect
-	public class AroundExample {
-
-		@Around("execution(* com.xyz..service.*.*(..))")
-		public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
-			// start stopwatch
-			Object retVal = pjp.proceed();
-			// stop stopwatch
-			return retVal;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	import org.aspectj.lang.annotation.Aspect
-	import org.aspectj.lang.annotation.Around
-	import org.aspectj.lang.ProceedingJoinPoint
-
-	@Aspect
-	class AroundExample {
-
-		@Around("execution(* com.xyz..service.*.*(..))")
-		fun doBasicProfiling(pjp: ProceedingJoinPoint): Any? {
-			// start stopwatch
-			val retVal = pjp.proceed()
-			// stop stopwatch
-			return retVal
-		}
-	}
-----
-======
-
-[[aop-ataspectj-advice-params]]
-== Advice Parameters
-
-Spring offers fully typed advice, meaning that you declare the parameters you need in the
-advice signature (as we saw earlier for the returning and throwing examples) rather than
-work with `Object[]` arrays all the time. We see how to make argument and other contextual
-values available to the advice body later in this section. First, we take a look at how to
-write generic advice that can find out about the method the advice is currently advising.
-
-[[aop-ataspectj-advice-params-the-joinpoint]]
-=== Access to the Current `JoinPoint`
-
-Any advice method may declare, as its first parameter, a parameter of type
-`org.aspectj.lang.JoinPoint`. Note that around advice is required to declare a first
-parameter of type `ProceedingJoinPoint`, which is a subclass of `JoinPoint`.
-
-The `JoinPoint` interface provides a number of useful methods:
-
-* `getArgs()`: Returns the method arguments.
-* `getThis()`: Returns the proxy object.
-* `getTarget()`: Returns the target object.
-* `getSignature()`: Returns a description of the method that is being advised.
-* `toString()`: Prints a useful description of the method being advised.
-
-See the {aspectj-api}/org/aspectj/lang/JoinPoint.html[javadoc] for more detail.
-
-[[aop-ataspectj-advice-params-passing]]
-=== Passing Parameters to Advice
-
-We have already seen how to bind the returned value or exception value (using after
-returning and after throwing advice). To make argument values available to the advice
-body, you can use the binding form of `args`. If you use a parameter name in place of a
-type name in an `args` expression, the value of the corresponding argument is passed as
-the parameter value when the advice is invoked. An example should make this clearer.
-Suppose you want to advise the execution of DAO operations that take an `Account`
-object as the first parameter, and you need access to the account in the advice body.
-You could write the following:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Before("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
-	public void validateAccount(Account account) {
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Before("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
-	fun validateAccount(account: Account) {
-		// ...
-	}
-----
-======
-
-The `args(account,..)` part of the pointcut expression serves two purposes. First, it
-restricts matching to only those method executions where the method takes at least one
-parameter, and the argument passed to that parameter is an instance of `Account`.
-Second, it makes the actual `Account` object available to the advice through the `account`
-parameter.
-
-Another way of writing this is to declare a pointcut that "provides" the `Account`
-object value when it matches a join point, and then refer to the named pointcut
-from the advice. This would look as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Pointcut("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
-	private void accountDataAccessOperation(Account account) {}
-
-	@Before("accountDataAccessOperation(account)")
-	public void validateAccount(Account account) {
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Pointcut("execution(* com.xyz.dao.*.*(..)) && args(account,..)")
-	private fun accountDataAccessOperation(account: Account) {
-	}
-
-	@Before("accountDataAccessOperation(account)")
-	fun validateAccount(account: Account) {
-		// ...
-	}
-----
-======
-
-See the AspectJ programming guide for more details.
-
-The proxy object (`this`), target object (`target`), and annotations (`@within`,
-`@target`, `@annotation`, and `@args`) can all be bound in a similar fashion. The next
-set of examples shows how to match the execution of methods annotated with an
-`@Auditable` annotation and extract the audit code:
-
-The following shows the definition of the `@Auditable` annotation:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.METHOD)
-	public @interface Auditable {
-		AuditCode value();
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Retention(AnnotationRetention.RUNTIME)
-	@Target(AnnotationTarget.FUNCTION)
-	annotation class Auditable(val value: AuditCode)
-----
-======
-
-The following shows the advice that matches the execution of `@Auditable` methods:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Before("com.xyz.Pointcuts.publicMethod() && @annotation(auditable)") // <1>
-	public void audit(Auditable auditable) {
-		AuditCode code = auditable.value();
-		// ...
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Before("com.xyz.Pointcuts.publicMethod() && @annotation(auditable)") // <1>
-	fun audit(auditable: Auditable) {
-		val code = auditable.value()
-		// ...
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-======
-
-[[aop-ataspectj-advice-params-generics]]
-=== Advice Parameters and Generics
-
-Spring AOP can handle generics used in class declarations and method parameters. Suppose
-you have a generic type like the following:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public interface Sample<T> {
-		void sampleGenericMethod(T param);
-		void sampleGenericCollectionMethod(Collection<T> param);
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	interface Sample<T> {
-		fun sampleGenericMethod(param: T)
-		fun sampleGenericCollectionMethod(param: Collection<T>)
-	}
-----
-======
-
-You can restrict interception of method types to certain parameter types by
-tying the advice parameter to the parameter type for which you want to intercept the method:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Before("execution(* ..Sample+.sampleGenericMethod(*)) && args(param)")
-	public void beforeSampleMethod(MyType param) {
-		// Advice implementation
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Before("execution(* ..Sample+.sampleGenericMethod(*)) && args(param)")
-	fun beforeSampleMethod(param: MyType) {
-		// Advice implementation
-	}
-----
-======
-
-This approach does not work for generic collections. So you cannot define a
-pointcut as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Before("execution(* ..Sample+.sampleGenericCollectionMethod(*)) && args(param)")
-	public void beforeSampleMethod(Collection<MyType> param) {
-		// Advice implementation
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Before("execution(* ..Sample+.sampleGenericCollectionMethod(*)) && args(param)")
-	fun beforeSampleMethod(param: Collection<MyType>) {
-		// Advice implementation
-	}
-----
-======
-
-To make this work, we would have to inspect every element of the collection, which is not
-reasonable, as we also cannot decide how to treat `null` values in general. To achieve
-something similar to this, you have to type the parameter to `Collection<?>` and manually
-check the type of the elements.
-
-[[aop-ataspectj-advice-params-names]]
-=== Determining Argument Names
-
-Parameter binding in advice invocations relies on matching the names used in pointcut
-expressions to the parameter names declared in advice and pointcut method signatures.
-
-NOTE: This section uses the terms _argument_ and _parameter_ interchangeably, since
-AspectJ APIs refer to parameter names as argument names.
-
-Spring AOP uses the following `ParameterNameDiscoverer` implementations to determine
-parameter names. Each discoverer will be given a chance to discover parameter names, and
-the first successful discoverer wins. If none of the registered discoverers is capable
-of determining parameter names, an exception will be thrown.
-
-`AspectJAnnotationParameterNameDiscoverer` :: Uses parameter names that have been explicitly
-  specified by the user via the `argNames` attribute in the corresponding advice or
-  pointcut annotation. See xref:core/aop/ataspectj/advice.adoc#aop-ataspectj-advice-params-names-explicit[Explicit Argument Names] for details.
-`KotlinReflectionParameterNameDiscoverer` :: Uses Kotlin reflection APIs to determine
-  parameter names. This discoverer is only used if such APIs are present on the classpath.
-`StandardReflectionParameterNameDiscoverer` :: Uses the standard `java.lang.reflect.Parameter`
-  API to determine parameter names. Requires that code be compiled with the `-parameters`
-  flag for `javac`. Recommended approach on Java 8+.
-`AspectJAdviceParameterNameDiscoverer` :: Deduces parameter names from the pointcut
-  expression, `returning`, and `throwing` clauses. See the
-  {spring-framework-api}/aop/aspectj/AspectJAdviceParameterNameDiscoverer.html[javadoc]
-  for details on the algorithm used.
-
-[[aop-ataspectj-advice-params-names-explicit]]
-=== Explicit Argument Names
-
-@AspectJ advice and pointcut annotations have an optional `argNames` attribute that you
-can use to specify the argument names of the annotated method.
-
-[TIP]
-====
-If an @AspectJ aspect has been compiled by the AspectJ compiler (`ajc`) even without
-debug information, you do not need to add the `argNames` attribute, since the compiler
-retains the needed information.
-
-Similarly, if an @AspectJ aspect has been compiled with `javac` using the `-parameters`
-flag, you do not need to add the `argNames` attribute, since the compiler retains the
-needed information.
-====
-
-The following example shows how to use the `argNames` attribute:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Before(
-		value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", // <1>
-		argNames = "bean,auditable") // <2>
-	public void audit(Object bean, Auditable auditable) {
-		AuditCode code = auditable.value();
-		// ... use code and bean
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-<2> Declares `bean` and `auditable` as the argument names.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Before(
-		value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", // <1>
-		argNames = "bean,auditable") // <2>
-	fun audit(bean: Any, auditable: Auditable) {
-		val code = auditable.value()
-		// ... use code and bean
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-<2> Declares `bean` and `auditable` as the argument names.
-======
-
-If the first parameter is of type `JoinPoint`, `ProceedingJoinPoint`, or
-`JoinPoint.StaticPart`, you can omit the name of the parameter from the value of the
-`argNames` attribute. For example, if you modify the preceding advice to receive the join
-point object, the `argNames` attribute does not need to include it:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Before(
-		value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", // <1>
-		argNames = "bean,auditable") // <2>
-	public void audit(JoinPoint jp, Object bean, Auditable auditable) {
-		AuditCode code = auditable.value();
-		// ... use code, bean, and jp
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-<2> Declares `bean` and `auditable` as the argument names.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Before(
-		value = "com.xyz.Pointcuts.publicMethod() && target(bean) && @annotation(auditable)", // <1>
-		argNames = "bean,auditable") // <2>
-	fun audit(jp: JoinPoint, bean: Any, auditable: Auditable) {
-		val code = auditable.value()
-		// ... use code, bean, and jp
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-<2> Declares `bean` and `auditable` as the argument names.
-======
-
-The special treatment given to the first parameter of type `JoinPoint`,
-`ProceedingJoinPoint`, or `JoinPoint.StaticPart` is particularly convenient for advice
-methods that do not collect any other join point context. In such situations, you may
-omit the `argNames` attribute. For example, the following advice does not need to declare
-the `argNames` attribute:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Before("com.xyz.Pointcuts.publicMethod()") // <1>
-	public void audit(JoinPoint jp) {
-		// ... use jp
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Before("com.xyz.Pointcuts.publicMethod()") // <1>
-	fun audit(jp: JoinPoint) {
-		// ... use jp
-	}
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-======
-
-
-[[aop-ataspectj-advice-proceeding-with-the-call]]
-=== Proceeding with Arguments
-
-We remarked earlier that we would describe how to write a `proceed` call with
-arguments that works consistently across Spring AOP and AspectJ. The solution is
-to ensure that the advice signature binds each of the method parameters in order.
-The following example shows how to do so:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Around("execution(List<Account> find*(..)) && " +
-			"com.xyz.CommonPointcuts.inDataAccessLayer() && " +
-			"args(accountHolderNamePattern)") // <1>
-	public Object preProcessQueryPattern(ProceedingJoinPoint pjp,
-			String accountHolderNamePattern) throws Throwable {
-		String newPattern = preProcess(accountHolderNamePattern);
-		return pjp.proceed(new Object[] {newPattern});
-	}
-----
-<1> References the `inDataAccessLayer` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[Sharing Named Pointcut Definitions].
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Around("execution(List<Account> find*(..)) && " +
-			"com.xyz.CommonPointcuts.inDataAccessLayer() && " +
-			"args(accountHolderNamePattern)") // <1>
-	fun preProcessQueryPattern(pjp: ProceedingJoinPoint,
-							accountHolderNamePattern: String): Any? {
-		val newPattern = preProcess(accountHolderNamePattern)
-		return pjp.proceed(arrayOf<Any>(newPattern))
-	}
-----
-<1> References the `inDataAccessLayer` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[Sharing Named Pointcut Definitions].
-======
-
-In many cases, you do this binding anyway (as in the preceding example).
-
-
-[[aop-ataspectj-advice-ordering]]
-== Advice Ordering
-
-What happens when multiple pieces of advice all want to run at the same join point?
-Spring AOP follows the same precedence rules as AspectJ to determine the order of advice
-execution. The highest precedence advice runs first "on the way in" (so, given two pieces
-of before advice, the one with highest precedence runs first). "On the way out" from a
-join point, the highest precedence advice runs last (so, given two pieces of after
-advice, the one with the highest precedence will run second).
-
-When two pieces of advice defined in different aspects both need to run at the same
-join point, unless you specify otherwise, the order of execution is undefined. You can
-control the order of execution by specifying precedence. This is done in the normal
-Spring way by either implementing the `org.springframework.core.Ordered` interface in
-the aspect class or annotating it with the `@Order` annotation. Given two aspects, the
-aspect returning the lower value from `Ordered.getOrder()` (or the annotation value) has
-the higher precedence.
-
-[NOTE]
-====
-Each of the distinct advice types of a particular aspect is conceptually meant to apply
-to the join point directly. As a consequence, an `@AfterThrowing` advice method is not
-supposed to receive an exception from an accompanying `@After`/`@AfterReturning` method.
-
-As of Spring Framework 5.2.7, advice methods defined in the same `@Aspect` class that
-need to run at the same join point are assigned precedence based on their advice type in
-the following order, from highest to lowest precedence: `@Around`, `@Before`, `@After`,
-`@AfterReturning`, `@AfterThrowing`. Note, however, that an `@After` advice method will
-effectively be invoked after any `@AfterReturning` or `@AfterThrowing` advice methods
-in the same aspect, following AspectJ's "after finally advice" semantics for `@After`.
-
-When two pieces of the same type of advice (for example, two `@After` advice methods)
-defined in the same `@Aspect` class both need to run at the same join point, the ordering
-is undefined (since there is no way to retrieve the source code declaration order through
-reflection for javac-compiled classes). Consider collapsing such advice methods into one
-advice method per join point in each `@Aspect` class or refactor the pieces of advice into
-separate `@Aspect` classes that you can order at the aspect level via `Ordered` or `@Order`.
-====
-
-

framework-docs/modules/ROOT/pages/core/aop/ataspectj/aspectj-support.adoc

@@ -1,61 +0,0 @@
-[[aop-aspectj-support]]
-= Enabling @AspectJ Support
-
-To use @AspectJ aspects in a Spring configuration, you need to enable Spring support for
-configuring Spring AOP based on @AspectJ aspects and auto-proxying beans based on
-whether or not they are advised by those aspects. By auto-proxying, we mean that, if Spring
-determines that a bean is advised by one or more aspects, it automatically generates
-a proxy for that bean to intercept method invocations and ensures that advice is run
-as needed.
-
-The @AspectJ support can be enabled with XML- or Java-style configuration. In either
-case, you also need to ensure that AspectJ's `aspectjweaver.jar` library is on the
-classpath of your application (version 1.9 or later). This library is available in the
-`lib` directory of an AspectJ distribution or from the Maven Central repository.
-
-
-[[aop-enable-aspectj-java]]
-== Enabling @AspectJ Support with Java Configuration
-
-To enable @AspectJ support with Java `@Configuration`, add the `@EnableAspectJAutoProxy`
-annotation, as the following example shows:
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Configuration
-	@EnableAspectJAutoProxy
-	public class AppConfig {
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Configuration
-	@EnableAspectJAutoProxy
-	class AppConfig
-----
-======
-
-[[aop-enable-aspectj-xml]]
-== Enabling @AspectJ Support with XML Configuration
-
-To enable @AspectJ support with XML-based configuration, use the `aop:aspectj-autoproxy`
-element, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspectj-autoproxy/>
-----
-
-This assumes that you use schema support as described in
-xref:core/appendix/xsd-schemas.adoc[XML Schema-based configuration].
-See xref:core/appendix/xsd-schemas.adoc#aop[the AOP schema] for how to
-import the tags in the `aop` namespace.
-
-
-

framework-docs/modules/ROOT/pages/core/aop/ataspectj/at-aspectj.adoc

@@ -1,68 +0,0 @@
-[[aop-at-aspectj]]
-= Declaring an Aspect
-
-With @AspectJ support enabled, any bean defined in your application context with a
-class that is an @AspectJ aspect (has the `@Aspect` annotation) is automatically
-detected by Spring and used to configure Spring AOP. The next two examples show the
-minimal steps required for a not-very-useful aspect.
-
-The first of the two examples shows a regular bean definition in the application context
-that points to a bean class that is annotated with `@Aspect`:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<bean id="myAspect" class="com.xyz.NotVeryUsefulAspect">
-		<!-- configure properties of the aspect here -->
-	</bean>
-----
-
-The second of the two examples shows the `NotVeryUsefulAspect` class definition, which is
-annotated with `@Aspect`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages",fold="none"]
-----
-	package com.xyz;
-
-	import org.aspectj.lang.annotation.Aspect;
-
-	@Aspect
-	public class NotVeryUsefulAspect {
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages",fold="none"]
-----
-	package com.xyz
-
-	import org.aspectj.lang.annotation.Aspect
-
-	@Aspect
-	class NotVeryUsefulAspect
-----
-======
-
-Aspects (classes annotated with `@Aspect`) can have methods and fields, the same as any
-other class. They can also contain pointcut, advice, and introduction (inter-type)
-declarations.
-
-.Autodetecting aspects through component scanning
-NOTE: You can register aspect classes as regular beans in your Spring XML configuration,
-via `@Bean` methods in `@Configuration` classes, or have Spring autodetect them through
-classpath scanning -- the same as any other Spring-managed bean. However, note that the
-`@Aspect` annotation is not sufficient for autodetection in the classpath. For that
-purpose, you need to add a separate `@Component` annotation (or, alternatively, a custom
-stereotype annotation that qualifies, as per the rules of Spring's component scanner).
-
-.Advising aspects with other aspects?
-NOTE: In Spring AOP, aspects themselves cannot be the targets of advice from other
-aspects. The `@Aspect` annotation on a class marks it as an aspect and, hence, excludes
-it from auto-proxying.
-
-
-

framework-docs/modules/ROOT/pages/core/aop/ataspectj/example.adoc

@@ -1,183 +0,0 @@
-[[aop-ataspectj-example]]
-= An AOP Example
-
-Now that you have seen how all the constituent parts work, we can put them together to do
-something useful.
-
-The execution of business services can sometimes fail due to concurrency issues (for
-example, a deadlock loser). If the operation is retried, it is likely to succeed
-on the next try. For business services where it is appropriate to retry in such
-conditions (idempotent operations that do not need to go back to the user for conflict
-resolution), we want to transparently retry the operation to avoid the client seeing a
-`PessimisticLockingFailureException`. This is a requirement that clearly cuts across
-multiple services in the service layer and, hence, is ideal for implementing through an
-aspect.
-
-Because we want to retry the operation, we need to use around advice so that we can
-call `proceed` multiple times. The following listing shows the basic aspect implementation:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Aspect
-	public class ConcurrentOperationExecutor implements Ordered {
-
-		private static final int DEFAULT_MAX_RETRIES = 2;
-
-		private int maxRetries = DEFAULT_MAX_RETRIES;
-		private int order = 1;
-
-		public void setMaxRetries(int maxRetries) {
-			this.maxRetries = maxRetries;
-		}
-
-		public int getOrder() {
-			return this.order;
-		}
-
-		public void setOrder(int order) {
-			this.order = order;
-		}
-
-		@Around("com.xyz.CommonPointcuts.businessService()") // <1>
-		public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {
-			int numAttempts = 0;
-			PessimisticLockingFailureException lockFailureException;
-			do {
-				numAttempts++;
-				try {
-					return pjp.proceed();
-				}
-				catch(PessimisticLockingFailureException ex) {
-					lockFailureException = ex;
-				}
-			} while(numAttempts <= this.maxRetries);
-			throw lockFailureException;
-		}
-	}
-----
-<1> References the `businessService` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[Sharing Named Pointcut Definitions].
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Aspect
-	class ConcurrentOperationExecutor : Ordered {
-
-		private val DEFAULT_MAX_RETRIES = 2
-		private var maxRetries = DEFAULT_MAX_RETRIES
-		private var order = 1
-
-		fun setMaxRetries(maxRetries: Int) {
-			this.maxRetries = maxRetries
-		}
-
-		override fun getOrder(): Int {
-			return this.order
-		}
-
-		fun setOrder(order: Int) {
-			this.order = order
-		}
-
-		@Around("com.xyz.CommonPointcuts.businessService()") // <1>
-		fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any? {
-			var numAttempts = 0
-			var lockFailureException: PessimisticLockingFailureException
-			do {
-				numAttempts++
-				try {
-					return pjp.proceed()
-				} catch (ex: PessimisticLockingFailureException) {
-					lockFailureException = ex
-				}
-
-			} while (numAttempts <= this.maxRetries)
-			throw lockFailureException
-		}
-	}
-----
-<1> References the `businessService` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[Sharing Named Pointcut Definitions].
-======
-
-Note that the aspect implements the `Ordered` interface so that we can set the precedence of
-the aspect higher than the transaction advice (we want a fresh transaction each time we
-retry). The `maxRetries` and `order` properties are both configured by Spring. The
-main action happens in the `doConcurrentOperation` around advice. Notice that, for the
-moment, we apply the retry logic to each `businessService`. We try to proceed,
-and if we fail with a `PessimisticLockingFailureException`, we try again, unless
-we have exhausted all of our retry attempts.
-
-The corresponding Spring configuration follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspectj-autoproxy/>
-
-	<bean id="concurrentOperationExecutor"
-			class="com.xyz.service.impl.ConcurrentOperationExecutor">
-		<property name="maxRetries" value="3"/>
-		<property name="order" value="100"/>
-	</bean>
-----
-
-To refine the aspect so that it retries only idempotent operations, we might define the following
-`Idempotent` annotation:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Retention(RetentionPolicy.RUNTIME)
-	// marker annotation
-	public @interface Idempotent {
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Retention(AnnotationRetention.RUNTIME)
-	// marker annotation
-	annotation class Idempotent
-----
-======
-
-We can then use the annotation to annotate the implementation of service operations. The change
-to the aspect to retry only idempotent operations involves refining the pointcut
-expression so that only `@Idempotent` operations match, as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Around("execution(* com.xyz..service.*.*(..)) && " +
-			"@annotation(com.xyz.service.Idempotent)")
-	public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Around("execution(* com.xyz..service.*.*(..)) && " +
-			"@annotation(com.xyz.service.Idempotent)")
-	fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any? {
-		// ...
-	}
-----
-======
-
-
-

framework-docs/modules/ROOT/pages/core/aop/ataspectj/instantiation-models.adoc

@@ -1,65 +0,0 @@
-[[aop-instantiation-models]]
-= Aspect Instantiation Models
-
-NOTE: This is an advanced topic. If you are just starting out with AOP, you can safely skip
-it until later.
-
-By default, there is a single instance of each aspect within the application
-context. AspectJ calls this the singleton instantiation model. It is possible to define
-aspects with alternate lifecycles. Spring supports AspectJ's `perthis`, `pertarget`, and
-`pertypewithin` instantiation models; `percflow` and `percflowbelow` are not currently
-supported.
-
-You can declare a `perthis` aspect by specifying a `perthis` clause in the `@Aspect`
-annotation. Consider the following example:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Aspect("perthis(execution(* com.xyz..service.*.*(..)))")
-	public class MyAspect {
-
-		private int someState;
-
-		@Before("execution(* com.xyz..service.*.*(..))")
-		public void recordServiceUsage() {
-			// ...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Aspect("perthis(execution(* com.xyz..service.*.*(..)))")
-	class MyAspect {
-
-		private val someState: Int = 0
-
-		@Before("execution(* com.xyz..service.*.*(..))")
-		fun recordServiceUsage() {
-			// ...
-		}
-	}
-----
-======
-
-In the preceding example, the effect of the `perthis` clause is that one aspect instance
-is created for each unique service object that performs a business service (each unique
-object bound to `this` at join points matched by the pointcut expression). The aspect
-instance is created the first time that a method is invoked on the service object. The
-aspect goes out of scope when the service object goes out of scope. Before the aspect
-instance is created, none of the advice within it runs. As soon as the aspect instance
-has been created, the advice declared within it runs at matched join points, but only
-when the service object is the one with which this aspect is associated. See the AspectJ
-Programming Guide for more information on `per` clauses.
-
-The `pertarget` instantiation model works in exactly the same way as `perthis`, but it
-creates one aspect instance for each unique target object at matched join points.
-
-
-

framework-docs/modules/ROOT/pages/core/aop/ataspectj/introductions.adoc

@@ -1,79 +0,0 @@
-[[aop-introductions]]
-= Introductions
-
-Introductions (known as inter-type declarations in AspectJ) enable an aspect to declare
-that advised objects implement a given interface, and to provide an implementation of
-that interface on behalf of those objects.
-
-You can make an introduction by using the `@DeclareParents` annotation. This annotation
-is used to declare that matching types have a new parent (hence the name). For example,
-given an interface named `UsageTracked` and an implementation of that interface named
-`DefaultUsageTracked`, the following aspect declares that all implementors of service
-interfaces also implement the `UsageTracked` interface (e.g. for statistics via JMX):
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Aspect
-	public class UsageTracking {
-
-		@DeclareParents(value="com.xyz.service.*+", defaultImpl=DefaultUsageTracked.class)
-		public static UsageTracked mixin;
-
-		@Before("execution(* com.xyz..service.*.*(..)) && this(usageTracked)")
-		public void recordUsage(UsageTracked usageTracked) {
-			usageTracked.incrementUseCount();
-		}
-
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Aspect
-	class UsageTracking {
-
-		companion object {
-			@DeclareParents(value = "com.xyz.service.*+",
-				defaultImpl = DefaultUsageTracked::class)
-			lateinit var mixin: UsageTracked
-		}
-
-		@Before("execution(* com.xyz..service.*.*(..)) && this(usageTracked)")
-		fun recordUsage(usageTracked: UsageTracked) {
-			usageTracked.incrementUseCount()
-		}
-	}
-----
-======
-
-The interface to be implemented is determined by the type of the annotated field. The
-`value` attribute of the `@DeclareParents` annotation is an AspectJ type pattern. Any
-bean of a matching type implements the `UsageTracked` interface. Note that, in the
-before advice of the preceding example, service beans can be directly used as
-implementations of the `UsageTracked` interface. If accessing a bean programmatically,
-you would write the following:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	UsageTracked usageTracked = context.getBean("myService", UsageTracked.class);
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	val usageTracked = context.getBean("myService", UsageTracked.class)
-----
-======
-
-

framework-docs/modules/ROOT/pages/core/aop/ataspectj/pointcuts.adoc

@@ -1,586 +0,0 @@
-[[aop-pointcuts]]
-= Declaring a Pointcut
-
-Pointcuts determine join points of interest and thus enable us to control
-when advice runs. Spring AOP only supports method execution join points for Spring
-beans, so you can think of a pointcut as matching the execution of methods on Spring
-beans. A pointcut declaration has two parts: a signature comprising a name and any
-parameters and a pointcut expression that determines exactly which method
-executions we are interested in. In the @AspectJ annotation-style of AOP, a pointcut
-signature is provided by a regular method definition, and the pointcut expression is
-indicated by using the `@Pointcut` annotation (the method serving as the pointcut signature
-must have a `void` return type).
-
-An example may help make this distinction between a pointcut signature and a pointcut
-expression clear. The following example defines a pointcut named `anyOldTransfer` that
-matches the execution of any method named `transfer`:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Pointcut("execution(* transfer(..))") // the pointcut expression
-	private void anyOldTransfer() {} // the pointcut signature
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Pointcut("execution(* transfer(..))") // the pointcut expression
-	private fun anyOldTransfer() {} // the pointcut signature
-----
-======
-
-The pointcut expression that forms the value of the `@Pointcut` annotation is a regular
-AspectJ pointcut expression. For a full discussion of AspectJ's pointcut language, see
-the {aspectj-docs-progguide}/index.html[AspectJ
-Programming Guide] (and, for extensions, the
-{aspectj-docs}/adk15notebook/index.html[AspectJ 5
-Developer's Notebook]) or one of the books on AspectJ (such as _Eclipse AspectJ_, by Colyer
-et al., or _AspectJ in Action_, by Ramnivas Laddad).
-
-
-[[aop-pointcuts-designators]]
-== Supported Pointcut Designators
-
-Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut
-expressions:
-
-* `execution`: For matching method execution join points. This is the primary
-  pointcut designator to use when working with Spring AOP.
-* `within`: Limits matching to join points within certain types (the execution
-  of a method declared within a matching type when using Spring AOP).
-* `this`: Limits matching to join points (the execution of methods when using Spring
-  AOP) where the bean reference (Spring AOP proxy) is an instance of the given type.
-* `target`: Limits matching to join points (the execution of methods when using
-  Spring AOP) where the target object (application object being proxied) is an instance
-  of the given type.
-* `args`: Limits matching to join points (the execution of methods when using Spring
-  AOP) where the arguments are instances of the given types.
-* `@target`: Limits matching to join points (the execution of methods when using
-  Spring AOP) where the class of the executing object has an annotation of the given type.
-* `@args`: Limits matching to join points (the execution of methods when using Spring
-  AOP) where the runtime type of the actual arguments passed have annotations of the
-  given types.
-* `@within`: Limits matching to join points within types that have the given
-  annotation (the execution of methods declared in types with the given annotation when
-  using Spring AOP).
-* `@annotation`: Limits matching to join points where the subject of the join point
-  (the method being run in Spring AOP) has the given annotation.
-
-.Other pointcut types
-****
-The full AspectJ pointcut language supports additional pointcut designators that are not
-supported in Spring: `call`, `get`, `set`, `preinitialization`,
-`staticinitialization`, `initialization`, `handler`, `adviceexecution`, `withincode`, `cflow`,
-`cflowbelow`, `if`, `@this`, and `@withincode`. Use of these pointcut designators in pointcut
-expressions interpreted by Spring AOP results in an `IllegalArgumentException` being
-thrown.
-
-The set of pointcut designators supported by Spring AOP may be extended in future
-releases to support more of the AspectJ pointcut designators.
-****
-
-Because Spring AOP limits matching to only method execution join points, the preceding discussion
-of the pointcut designators gives a narrower definition than you can find in the
-AspectJ programming guide. In addition, AspectJ itself has type-based semantics and, at
-an execution join point, both `this` and `target` refer to the same object: the
-object executing the method. Spring AOP is a proxy-based system and differentiates
-between the proxy object itself (which is bound to `this`) and the target object behind the
-proxy (which is bound to `target`).
-
-[NOTE]
-====
-Due to the proxy-based nature of Spring's AOP framework, calls within the target object
-are, by definition, not intercepted. For JDK proxies, only public interface method
-calls on the proxy can be intercepted. With CGLIB, public and protected method calls on
-the proxy are intercepted (and even package-visible methods, if necessary). However,
-common interactions through proxies should always be designed through public signatures.
-
-Note that pointcut definitions are generally matched against any intercepted method.
-If a pointcut is strictly meant to be public-only, even in a CGLIB proxy scenario with
-potential non-public interactions through proxies, it needs to be defined accordingly.
-
-If your interception needs include method calls or even constructors within the target
-class, consider the use of Spring-driven xref:core/aop/using-aspectj.adoc#aop-aj-ltw[native AspectJ weaving] instead
-of Spring's proxy-based AOP framework. This constitutes a different mode of AOP usage
-with different characteristics, so be sure to make yourself familiar with weaving
-before making a decision.
-====
-
-Spring AOP also supports an additional PCD named `bean`. This PCD lets you limit
-the matching of join points to a particular named Spring bean or to a set of named
-Spring beans (when using wildcards). The `bean` PCD has the following form:
-
-[source,indent=0,subs="verbatim"]
-----
-	bean(idOrNameOfBean)
-----
-
-The `idOrNameOfBean` token can be the name of any Spring bean. Limited wildcard
-support that uses the `*` character is provided, so, if you establish some naming
-conventions for your Spring beans, you can write a `bean` PCD expression
-to select them. As is the case with other pointcut designators, the `bean` PCD can
-be used with the `&&` (and), `||` (or), and `!` (negation) operators, too.
-
-[NOTE]
-====
-The `bean` PCD is supported only in Spring AOP and not in
-native AspectJ weaving. It is a Spring-specific extension to the standard PCDs that
-AspectJ defines and is, therefore, not available for aspects declared in the `@Aspect` model.
-
-The `bean` PCD operates at the instance level (building on the Spring bean name
-concept) rather than at the type level only (to which weaving-based AOP is limited).
-Instance-based pointcut designators are a special capability of Spring's
-proxy-based AOP framework and its close integration with the Spring bean factory, where
-it is natural and straightforward to identify specific beans by name.
-====
-
-
-[[aop-pointcuts-combining]]
-== Combining Pointcut Expressions
-
-You can combine pointcut expressions by using `&&,` `||` and `!`. You can also refer to
-pointcut expressions by name. The following example shows three pointcut expressions:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
-----
-	package com.xyz;
-
-	public class Pointcuts {
-
-		@Pointcut("execution(public * *(..))")
-		public void publicMethod() {} // <1>
-
-		@Pointcut("within(com.xyz.trading..*)")
-		public void inTrading() {} // <2>
-
-		@Pointcut("publicMethod() && inTrading()")
-		public void tradingOperation() {} // <3>
-	}
-----
-<1> `publicMethod` matches if a method execution join point represents the execution
-of any public method.
-<2> `inTrading` matches if a method execution is in the trading module.
-<3> `tradingOperation` matches if a method execution represents any public method in the
-trading module.
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
-----
-	package com.xyz
-
-	class Pointcuts {
-
-		@Pointcut("execution(public * *(..))")
-		fun publicMethod() {} // <1>
-
-		@Pointcut("within(com.xyz.trading..*)")
-		fun inTrading() {} // <2>
-
-		@Pointcut("publicMethod() && inTrading()")
-		fun tradingOperation() {} // <3>
-	}
-----
-<1> `publicMethod` matches if a method execution join point represents the execution
-of any public method.
-<2> `inTrading` matches if a method execution is in the trading module.
-<3> `tradingOperation` matches if a method execution represents any public method in the
-trading module.
-======
-
-It is a best practice to build more complex pointcut expressions out of smaller _named
-pointcuts_, as shown above. When referring to pointcuts by name, normal Java visibility
-rules apply (you can see `private` pointcuts in the same type, `protected` pointcuts in
-the hierarchy, `public` pointcuts anywhere, and so on). Visibility does not affect
-pointcut matching.
-
-
-[[aop-common-pointcuts]]
-== Sharing Named Pointcut Definitions
-
-When working with enterprise applications, developers often have the need to refer to
-modules of the application and particular sets of operations from within several aspects.
-We recommend defining a dedicated class that captures commonly used _named pointcut_
-expressions for this purpose. Such a class typically resembles the following
-`CommonPointcuts` example (though what you name the class is up to you):
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages",fold="none"]
-----
-	package com.xyz;
-
-	import org.aspectj.lang.annotation.Pointcut;
-
-	public class CommonPointcuts {
-
-		/**
-		 * A join point is in the web layer if the method is defined
-		 * in a type in the com.xyz.web package or any sub-package
-		 * under that.
-		 */
-		@Pointcut("within(com.xyz.web..*)")
-		public void inWebLayer() {}
-
-		/**
-		 * A join point is in the service layer if the method is defined
-		 * in a type in the com.xyz.service package or any sub-package
-		 * under that.
-		 */
-		@Pointcut("within(com.xyz.service..*)")
-		public void inServiceLayer() {}
-
-		/**
-		 * A join point is in the data access layer if the method is defined
-		 * in a type in the com.xyz.dao package or any sub-package
-		 * under that.
-		 */
-		@Pointcut("within(com.xyz.dao..*)")
-		public void inDataAccessLayer() {}
-
-		/**
-		 * A business service is the execution of any method defined on a service
-		 * interface. This definition assumes that interfaces are placed in the
-		 * "service" package, and that implementation types are in sub-packages.
-		 *
-		 * If you group service interfaces by functional area (for example,
-		 * in packages com.xyz.abc.service and com.xyz.def.service) then
-		 * the pointcut expression "execution(* com.xyz..service.*.*(..))"
-		 * could be used instead.
-		 *
-		 * Alternatively, you can write the expression using the 'bean'
-		 * PCD, like so "bean(*Service)". (This assumes that you have
-		 * named your Spring service beans in a consistent fashion.)
-		 */
-		@Pointcut("execution(* com.xyz..service.*.*(..))")
-		public void businessService() {}
-
-		/**
-		 * A data access operation is the execution of any method defined on a
-		 * DAO interface. This definition assumes that interfaces are placed in the
-		 * "dao" package, and that implementation types are in sub-packages.
-		 */
-		@Pointcut("execution(* com.xyz.dao.*.*(..))")
-		public void dataAccessOperation() {}
-
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages",fold="none"]
-----
-	package com.xyz
-
-	import org.aspectj.lang.annotation.Pointcut
-
-	class CommonPointcuts {
-
-		/**
-		 * A join point is in the web layer if the method is defined
-		 * in a type in the com.xyz.web package or any sub-package
-		 * under that.
-		 */
-		@Pointcut("within(com.xyz.web..*)")
-		fun inWebLayer() {}
-
-		/**
-		 * A join point is in the service layer if the method is defined
-		 * in a type in the com.xyz.service package or any sub-package
-		 * under that.
-		 */
-		@Pointcut("within(com.xyz.service..*)")
-		fun inServiceLayer() {}
-
-		/**
-		 * A join point is in the data access layer if the method is defined
-		 * in a type in the com.xyz.dao package or any sub-package
-		 * under that.
-		 */
-		@Pointcut("within(com.xyz.dao..*)")
-		fun inDataAccessLayer() {}
-
-		/**
-		 * A business service is the execution of any method defined on a service
-		 * interface. This definition assumes that interfaces are placed in the
-		 * "service" package, and that implementation types are in sub-packages.
-		 *
-		 * If you group service interfaces by functional area (for example,
-		 * in packages com.xyz.abc.service and com.xyz.def.service) then
-		 * the pointcut expression "execution(* com.xyz..service.*.*(..))"
-		 * could be used instead.
-		 *
-		 * Alternatively, you can write the expression using the 'bean'
-		 * PCD, like so "bean(*Service)". (This assumes that you have
-		 * named your Spring service beans in a consistent fashion.)
-		 */
-		@Pointcut("execution(* com.xyz..service.*.*(..))")
-		fun businessService() {}
-
-		/**
-		 * A data access operation is the execution of any method defined on a
-		 * DAO interface. This definition assumes that interfaces are placed in the
-		 * "dao" package, and that implementation types are in sub-packages.
-		 */
-		@Pointcut("execution(* com.xyz.dao.*.*(..))")
-		fun dataAccessOperation() {}
-
-	}
-----
-======
-
-You can refer to the pointcuts defined in such a class anywhere you need a pointcut
-expression by referencing the fully-qualified name of the class combined with the
-`@Pointcut` method's name. For example, to make the service layer transactional, you
-could write the following which references the
-`com.xyz.CommonPointcuts.businessService()` _named pointcut_:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-		<aop:advisor
-			pointcut="com.xyz.CommonPointcuts.businessService()"
-			advice-ref="tx-advice"/>
-	</aop:config>
-
-	<tx:advice id="tx-advice">
-		<tx:attributes>
-			<tx:method name="*" propagation="REQUIRED"/>
-		</tx:attributes>
-	</tx:advice>
-----
-
-The `<aop:config>` and `<aop:advisor>` elements are discussed in xref:core/aop/schema.adoc[Schema-based AOP Support]. The
-transaction elements are discussed in xref:data-access/transaction.adoc[Transaction Management].
-
-
-[[aop-pointcuts-examples]]
-== Examples
-
-Spring AOP users are likely to use the `execution` pointcut designator the most often.
-The format of an execution expression follows:
-
-[literal,indent=0,subs="verbatim"]
-----
-	execution(modifiers-pattern?
-				ret-type-pattern
-				declaring-type-pattern?name-pattern(param-pattern)
-				throws-pattern?)
-----
-
-All parts except the returning type pattern (`ret-type-pattern` in the preceding snippet),
-the name pattern, and the parameters pattern are optional. The returning type pattern determines
-what the return type of the method must be in order for a join point to be matched.
-`{asterisk}` is most frequently used as the returning type pattern. It matches any return
-type. A fully-qualified type name matches only when the method returns the given
-type. The name pattern matches the method name. You can use the `{asterisk}` wildcard as all or
-part of a name pattern. If you specify a declaring type pattern,
-include a trailing `.` to join it to the name pattern component.
-The parameters pattern is slightly more complex: `()` matches a
-method that takes no parameters, whereas `(..)` matches any number (zero or more) of parameters.
-The `({asterisk})` pattern matches a method that takes one parameter of any type.
-`(*,String)` matches a method that takes two parameters. The first can be of any type, while the
-second must be a `String`. Consult the
-{aspectj-docs-progguide}/semantics-pointcuts.html[Language
-Semantics] section of the AspectJ Programming Guide for more information.
-
-The following examples show some common pointcut expressions:
-
-* The execution of any public method:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	execution(public * *(..))
-----
-
-* The execution of any method with a name that begins with `set`:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	execution(* set*(..))
-----
-
-* The execution of any method defined by the `AccountService` interface:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	execution(* com.xyz.service.AccountService.*(..))
-----
-
-* The execution of any method defined in the `service` package:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	execution(* com.xyz.service.*.*(..))
-----
-
-* The execution of any method defined in the service package or one of its sub-packages:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	execution(* com.xyz.service..*.*(..))
-----
-
-* Any join point (method execution only in Spring AOP) within the service package:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	within(com.xyz.service.*)
-----
-
-* Any join point (method execution only in Spring AOP) within the service package or one of its
-sub-packages:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	within(com.xyz.service..*)
-----
-
-* Any join point (method execution only in Spring AOP) where the proxy implements the
-`AccountService` interface:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	this(com.xyz.service.AccountService)
-----
-+
-NOTE: `this` is more commonly used in a binding form. See the section on xref:core/aop/ataspectj/advice.adoc[Declaring Advice]
-for how to make the proxy object available in the advice body.
-
-* Any join point (method execution only in Spring AOP) where the target object
-implements the `AccountService` interface:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	target(com.xyz.service.AccountService)
-----
-+
-NOTE: `target` is more commonly used in a binding form. See the xref:core/aop/ataspectj/advice.adoc[Declaring Advice] section
-for how to make the target object available in the advice body.
-
-* Any join point (method execution only in Spring AOP) that takes a single parameter
-and where the argument passed at runtime is `Serializable`:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	args(java.io.Serializable)
-----
-+
-NOTE: `args` is more commonly used in a binding form. See the xref:core/aop/ataspectj/advice.adoc[Declaring Advice] section
-for how to make the method arguments available in the advice body.
-+
-Note that the pointcut given in this example is different from `execution(*
-*(java.io.Serializable))`. The args version matches if the argument passed at runtime is
-`Serializable`, and the execution version matches if the method signature declares a single
-parameter of type `Serializable`.
-
-* Any join point (method execution only in Spring AOP) where the target object has a
-`@Transactional` annotation:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	@target(org.springframework.transaction.annotation.Transactional)
-----
-+
-NOTE: You can also use `@target` in a binding form. See the xref:core/aop/ataspectj/advice.adoc[Declaring Advice] section for
-how to make the annotation object available in the advice body.
-
-* Any join point (method execution only in Spring AOP) where the declared type of the
-target object has an `@Transactional` annotation:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	@within(org.springframework.transaction.annotation.Transactional)
-----
-+
-NOTE: You can also use `@within` in a binding form. See the xref:core/aop/ataspectj/advice.adoc[Declaring Advice] section for
-how to make the annotation object available in the advice body.
-
-* Any join point (method execution only in Spring AOP) where the executing method has an
-`@Transactional` annotation:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	@annotation(org.springframework.transaction.annotation.Transactional)
-----
-+
-NOTE: You can also use `@annotation` in a binding form. See the xref:core/aop/ataspectj/advice.adoc[Declaring Advice] section
-for how to make the annotation object available in the advice body.
-
-* Any join point (method execution only in Spring AOP) which takes a single parameter,
-and where the runtime type of the argument passed has the `@Classified` annotation:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	@args(com.xyz.security.Classified)
-----
-+
-NOTE: You can also use `@args` in a binding form. See the xref:core/aop/ataspectj/advice.adoc[Declaring Advice] section
-how to make the annotation object(s) available in the advice body.
-
-* Any join point (method execution only in Spring AOP) on a Spring bean named
-`tradeService`:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	bean(tradeService)
-----
-
-* Any join point (method execution only in Spring AOP) on Spring beans having names that
-match the wildcard expression `*Service`:
-+
-[literal,indent=0,subs="verbatim"]
-----
-	bean(*Service)
-----
-
-
-[[writing-good-pointcuts]]
-== Writing Good Pointcuts
-
-During compilation, AspectJ processes pointcuts in order to optimize matching
-performance. Examining code and determining if each join point matches (statically or
-dynamically) a given pointcut is a costly process. (A dynamic match means the match
-cannot be fully determined from static analysis and that a test is placed in the code to
-determine if there is an actual match when the code is running). On first encountering a
-pointcut declaration, AspectJ rewrites it into an optimal form for the matching
-process. What does this mean? Basically, pointcuts are rewritten in DNF (Disjunctive
-Normal Form) and the components of the pointcut are sorted such that those components
-that are cheaper to evaluate are checked first. This means you do not have to worry
-about understanding the performance of various pointcut designators and may supply them
-in any order in a pointcut declaration.
-
-However, AspectJ can work only with what it is told. For optimal performance of
-matching, you should think about what you are trying to achieve and narrow the search
-space for matches as much as possible in the definition. The existing designators
-naturally fall into one of three groups: kinded, scoping, and contextual:
-
-* Kinded designators select a particular kind of join point:
-`execution`, `get`, `set`, `call`, and `handler`.
-* Scoping designators select a group of join points of interest
-(probably of many kinds): `within` and `withincode`
-* Contextual designators match (and optionally bind) based on context:
-`this`, `target`, and `@annotation`
-
-A well written pointcut should include at least the first two types (kinded and
-scoping). You can include the contextual designators to match based on
-join point context or bind that context for use in the advice. Supplying only a
-kinded designator or only a contextual designator works but could affect weaving
-performance (time and memory used), due to extra processing and analysis. Scoping
-designators are very fast to match, and using them means AspectJ can very quickly
-dismiss groups of join points that should not be further processed. A good
-pointcut should always include one if possible.
-
-
-

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

@@ -1,113 +0,0 @@
-[[aop-choosing]]
-= Choosing which AOP Declaration Style to Use
-
-Once you have decided that an aspect is the best approach for implementing a given
-requirement, how do you decide between using Spring AOP or AspectJ and between the
-Aspect language (code) style, the @AspectJ annotation style, or the Spring XML style? These
-decisions are influenced by a number of factors including application requirements,
-development tools, and team familiarity with AOP.
-
-
-
-[[aop-spring-or-aspectj]]
-== Spring AOP or Full AspectJ?
-
-Use the simplest thing that can work. Spring AOP is simpler than using full AspectJ, as
-there is no requirement to introduce the AspectJ compiler / weaver into your development
-and build processes. If you only need to advise the execution of operations on Spring
-beans, Spring AOP is the right choice. If you need to advise objects not managed by
-the Spring container (such as domain objects, typically), you need to use
-AspectJ. You also need to use AspectJ if you wish to advise join points other than
-simple method executions (for example, field get or set join points and so on).
-
-When you use AspectJ, you have the choice of the AspectJ language syntax (also known as
-the "code style") or the @AspectJ annotation style. If aspects play a large
-role in your design, and you are able to use the https://www.eclipse.org/ajdt/[AspectJ
-Development Tools (AJDT)] plugin for Eclipse, the AspectJ language syntax is the
-preferred option. It is cleaner and simpler because the language was purposefully
-designed for writing aspects. If you do not use Eclipse or have only a few aspects
-that do not play a major role in your application, you may want to consider using
-the @AspectJ style, sticking with regular Java compilation in your IDE, and adding
-an aspect weaving phase to your build script.
-
-
-
-[[aop-ataspectj-or-xml]]
-== @AspectJ or XML for Spring AOP?
-
-If you have chosen to use Spring AOP, you have a choice of @AspectJ or XML style.
-There are various tradeoffs to consider.
-
-The XML style may be most familiar to existing Spring users, and it is backed by genuine
-POJOs. When using AOP as a tool to configure enterprise services, XML can be a good
-choice (a good test is whether you consider the pointcut expression to be a part of your
-configuration that you might want to change independently). With the XML style, it is
-arguably clearer from your configuration which aspects are present in the system.
-
-The XML style has two disadvantages. First, it does not fully encapsulate the
-implementation of the requirement it addresses in a single place. The DRY principle says
-that there should be a single, unambiguous, authoritative representation of any piece of
-knowledge within a system. When using the XML style, the knowledge of how a requirement
-is implemented is split across the declaration of the backing bean class and the XML in
-the configuration file. When you use the @AspectJ style, this information is encapsulated
-in a single module: the aspect. Secondly, the XML style is slightly more limited in what
-it can express than the @AspectJ style: Only the "singleton" aspect instantiation model
-is supported, and it is not possible to combine named pointcuts declared in XML.
-For example, in the @AspectJ style you can write something like the following:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Pointcut("execution(* get*())")
-	public void propertyAccess() {}
-
-	@Pointcut("execution(com.xyz.Account+ *(..))")
-	public void operationReturningAnAccount() {}
-
-	@Pointcut("propertyAccess() && operationReturningAnAccount()")
-	public void accountPropertyAccess() {}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Pointcut("execution(* get*())")
-	fun propertyAccess() {}
-
-	@Pointcut("execution(com.xyz.Account+ *(..))")
-	fun operationReturningAnAccount() {}
-
-	@Pointcut("propertyAccess() && operationReturningAnAccount()")
-	fun accountPropertyAccess() {}
-----
-======
-
-In the XML style you can declare the first two pointcuts:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:pointcut id="propertyAccess"
-			expression="execution(* get*())"/>
-
-	<aop:pointcut id="operationReturningAnAccount"
-			expression="execution(com.xyz.Account+ *(..))"/>
-----
-
-The downside of the XML approach is that you cannot define the
-`accountPropertyAccess` pointcut by combining these definitions.
-
-The @AspectJ style supports additional instantiation models and richer pointcut
-composition. It has the advantage of keeping the aspect as a modular unit. It also has
-the advantage that the @AspectJ aspects can be understood (and thus consumed) both by
-Spring AOP and by AspectJ. So, if you later decide you need the capabilities of AspectJ
-to implement additional requirements, you can easily migrate to a classic AspectJ setup.
-In general, the Spring team prefers the @AspectJ style for custom aspects beyond simple
-configuration of enterprise services.
-
-
-
-

framework-docs/modules/ROOT/pages/core/aop/introduction-defn.adoc

@@ -1,79 +0,0 @@
-[[aop-introduction-defn]]
-= AOP Concepts
-
-Let us begin by defining some central AOP concepts and terminology. These terms are not
-Spring-specific. Unfortunately, AOP terminology is not particularly intuitive.
-However, it would be even more confusing if Spring used its own terminology.
-
-* Aspect: A modularization of a concern that cuts across multiple classes.
-  Transaction management is a good example of a crosscutting concern in enterprise Java
-  applications. In Spring AOP, aspects are implemented by using regular classes
-  (the xref:core/aop/schema.adoc[schema-based approach]) or regular classes annotated with the
-  `@Aspect` annotation (the xref:core/aop/ataspectj.adoc[@AspectJ style]).
-* Join point: A point during the execution of a program, such as the execution of a
-  method or the handling of an exception. In Spring AOP, a join point always
-  represents a method execution.
-* Advice: Action taken by an aspect at a particular join point. Different types of
-  advice include "around", "before", and "after" advice. (Advice types are discussed
-  later.) Many AOP frameworks, including Spring, model an advice as an interceptor and
-  maintain a chain of interceptors around the join point.
-* Pointcut: A predicate that matches join points. Advice is associated with a
-  pointcut expression and runs at any join point matched by the pointcut (for example,
-  the execution of a method with a certain name). The concept of join points as matched
-  by pointcut expressions is central to AOP, and Spring uses the AspectJ pointcut
-  expression language by default.
-* Introduction: Declaring additional methods or fields on behalf of a type. Spring
-  AOP lets you introduce new interfaces (and a corresponding implementation) to any
-  advised object. For example, you could use an introduction to make a bean implement an
-  `IsModified` interface, to simplify caching. (An introduction is known as an
-  inter-type declaration in the AspectJ community.)
-* Target object: An object being advised by one or more aspects. Also referred to as
-  the "advised object". Since Spring AOP is implemented by using runtime proxies, this
-  object is always a proxied object.
-* AOP proxy: An object created by the AOP framework in order to implement the aspect
-  contracts (advice method executions and so on). In the Spring Framework, an AOP proxy
-  is a JDK dynamic proxy or a CGLIB proxy.
-* Weaving: linking aspects with other application types or objects to create an
-  advised object. This can be done at compile time (using the AspectJ compiler, for
-  example), load time, or at runtime. Spring AOP, like other pure Java AOP frameworks,
-  performs weaving at runtime.
-
-Spring AOP includes the following types of advice:
-
-* Before advice: Advice that runs before a join point but that does not have
-  the ability to prevent execution flow proceeding to the join point (unless it throws
-  an exception).
-* After returning advice: Advice to be run after a join point completes
-  normally (for example, if a method returns without throwing an exception).
-* After throwing advice: Advice to be run if a method exits by throwing an
-  exception.
-* After (finally) advice: Advice to be run regardless of the means by which a
-  join point exits (normal or exceptional return).
-* Around advice: Advice that surrounds a join point such as a method invocation.
-  This is the most powerful kind of advice. Around advice can perform custom behavior
-  before and after the method invocation. It is also responsible for choosing whether to
-  proceed to the join point or to shortcut the advised method execution by returning its
-  own return value or throwing an exception.
-
-Around advice is the most general kind of advice. Since Spring AOP, like AspectJ,
-provides a full range of advice types, we recommend that you use the least powerful
-advice type that can implement the required behavior. For example, if you need only to
-update a cache with the return value of a method, you are better off implementing an
-after returning advice than an around advice, although an around advice can accomplish
-the same thing. Using the most specific advice type provides a simpler programming model
-with less potential for errors. For example, you do not need to invoke the `proceed()`
-method on the `JoinPoint` used for around advice, and, hence, you cannot fail to invoke it.
-
-All advice parameters are statically typed so that you work with advice parameters of
-the appropriate type (e.g. the type of the return value from a method execution) rather
-than `Object` arrays.
-
-The concept of join points matched by pointcuts is the key to AOP, which distinguishes
-it from older technologies offering only interception. Pointcuts enable advice to be
-targeted independently of the object-oriented hierarchy. For example, you can apply an
-around advice providing declarative transaction management to a set of methods that span
-multiple objects (such as all business operations in the service layer).
-
-
-
-

framework-docs/modules/ROOT/pages/core/aop/introduction-proxies.adoc

@@ -1,22 +0,0 @@
-[[aop-introduction-proxies]]
-= AOP Proxies
-:page-section-summary-toc: 1
-
-Spring AOP defaults to using standard JDK dynamic proxies for AOP proxies. This
-enables any interface (or set of interfaces) to be proxied.
-
-Spring AOP can also use CGLIB proxies. This is necessary to proxy classes rather than
-interfaces. By default, CGLIB is used if a business object does not implement an
-interface. As it is good practice to program to interfaces rather than classes, business
-classes normally implement one or more business interfaces. It is possible to
-xref:core/aop/proxying.adoc[force the use of CGLIB], in those (hopefully rare) cases where you
-need to advise a method that is not declared on an interface or where you need to
-pass a proxied object to a method as a concrete type.
-
-It is important to grasp the fact that Spring AOP is proxy-based. See
-xref:core/aop/proxying.adoc#aop-understanding-aop-proxies[Understanding AOP Proxies] for a thorough examination of exactly what this
-implementation detail actually means.
-
-
-
-

framework-docs/modules/ROOT/pages/core/aop/introduction-spring-defn.adoc

@@ -1,61 +0,0 @@
-[[aop-introduction-spring-defn]]
-= Spring AOP Capabilities and Goals
-
-Spring AOP is implemented in pure Java. There is no need for a special compilation
-process. Spring AOP does not need to control the class loader hierarchy and is thus
-suitable for use in a servlet container or application server.
-
-Spring AOP currently supports only method execution join points (advising the execution
-of methods on Spring beans). Field interception is not implemented, although support for
-field interception could be added without breaking the core Spring AOP APIs. If you need
-to advise field access and update join points, consider a language such as AspectJ.
-
-Spring AOP's approach to AOP differs from that of most other AOP frameworks. The aim is
-not to provide the most complete AOP implementation (although Spring AOP is quite
-capable). Rather, the aim is to provide a close integration between AOP implementation and
-Spring IoC, to help solve common problems in enterprise applications.
-
-Thus, for example, the Spring Framework's AOP functionality is normally used in
-conjunction with the Spring IoC container. Aspects are configured by using normal bean
-definition syntax (although this allows powerful "auto-proxying" capabilities). This is a
-crucial difference from other AOP implementations. You cannot do some things
-easily or efficiently with Spring AOP, such as advise very fine-grained objects (typically,
-domain objects). AspectJ is the best choice in such cases. However, our
-experience is that Spring AOP provides an excellent solution to most problems in
-enterprise Java applications that are amenable to AOP.
-
-Spring AOP never strives to compete with AspectJ to provide a comprehensive AOP
-solution. We believe that both proxy-based frameworks such as Spring AOP and full-blown
-frameworks such as AspectJ are valuable and that they are complementary, rather than in
-competition. Spring seamlessly integrates Spring AOP and IoC with AspectJ, to enable
-all uses of AOP within a consistent Spring-based application
-architecture. This integration does not affect the Spring AOP API or the AOP Alliance
-API. Spring AOP remains backward-compatible. See xref:core/aop-api.adoc[the following chapter]
-for a discussion of the Spring AOP APIs.
-
-[NOTE]
-====
-One of the central tenets of the Spring Framework is that of non-invasiveness. This
-is the idea that you should not be forced to introduce framework-specific classes and
-interfaces into your business or domain model. However, in some places, the Spring Framework
-does give you the option to introduce Spring Framework-specific dependencies into your
-codebase. The rationale in giving you such options is because, in certain scenarios, it
-might be just plain easier to read or code some specific piece of functionality in such
-a way. However, the Spring Framework (almost) always offers you the choice: You have the
-freedom to make an informed decision as to which option best suits your particular use
-case or scenario.
-
-One such choice that is relevant to this chapter is that of which AOP framework (and
-which AOP style) to choose. You have the choice of AspectJ, Spring AOP, or both. You
-also have the choice of either the @AspectJ annotation-style approach or the Spring XML
-configuration-style approach. The fact that this chapter chooses to introduce the
-@AspectJ-style approach first should not be taken as an indication that the Spring team
-favors the @AspectJ annotation-style approach over the Spring XML configuration-style.
-
-See xref:core/aop/choosing.adoc[Choosing which AOP Declaration Style to Use] for a more complete discussion of the advantages and disadvantages of
-each style.
-====
-
-
-
-

framework-docs/modules/ROOT/pages/core/aop/mixing-styles.adoc

@@ -1,12 +0,0 @@
-[[aop-mixing-styles]]
-= Mixing Aspect Types
-:page-section-summary-toc: 1
-
-It is perfectly possible to mix @AspectJ style aspects by using the auto-proxying support,
-schema-defined `<aop:aspect>` aspects, `<aop:advisor>` declared advisors, and even proxies
-and interceptors in other styles in the same configuration. All of these are implemented
-by using the same underlying support mechanism and can co-exist without any difficulty.
-
-
-
-

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

@@ -1,285 +0,0 @@
-[[aop-proxying]]
-= Proxying Mechanisms
-
-Spring AOP uses either JDK dynamic proxies or CGLIB to create the proxy for a given
-target object. JDK dynamic proxies are built into the JDK, whereas CGLIB is a common
-open-source class definition library (repackaged into `spring-core`).
-
-If the target object to be proxied implements at least one interface, a JDK dynamic
-proxy is used. All of the interfaces implemented by the target type are proxied.
-If the target object does not implement any interfaces, a CGLIB proxy is created.
-
-If you want to force the use of CGLIB proxying (for example, to proxy every method
-defined for the target object, not only those implemented by its interfaces),
-you can do so. However, you should consider the following issues:
-
-* With CGLIB, `final` methods cannot be advised, as they cannot be overridden in
-  runtime-generated subclasses.
-* As of Spring 4.0, the constructor of your proxied object is NOT called twice anymore,
-  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:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config proxy-target-class="true">
-		<!-- other beans defined here... -->
-	</aop:config>
-----
-
-To force CGLIB proxying when you use the @AspectJ auto-proxy support, set the
-`proxy-target-class` attribute of the `<aop:aspectj-autoproxy>` element to `true`,
-as follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspectj-autoproxy proxy-target-class="true"/>
-----
-
-[NOTE]
-====
-Multiple `<aop:config/>` sections are collapsed into a single unified auto-proxy creator
-at runtime, which applies the _strongest_ proxy settings that any of the
-`<aop:config/>` sections (typically from different XML bean definition files) specified.
-This also applies to the `<tx:annotation-driven/>` and `<aop:aspectj-autoproxy/>`
-elements.
-
-To be clear, using `proxy-target-class="true"` on `<tx:annotation-driven/>`,
-`<aop:aspectj-autoproxy/>`, or `<aop:config/>` elements forces the use of CGLIB
-proxies _for all three of them_.
-====
-
-
-
-[[aop-understanding-aop-proxies]]
-== Understanding AOP Proxies
-
-Spring AOP is proxy-based. It is vitally important that you grasp the semantics of
-what that last statement actually means before you write your own aspects or use any of
-the Spring AOP-based aspects supplied with the Spring Framework.
-
-Consider first the scenario where you have a plain-vanilla, un-proxied,
-nothing-special-about-it, straight object reference, as the following
-code snippet shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public class SimplePojo implements Pojo {
-
-		public void foo() {
-			// this next method invocation is a direct call on the 'this' reference
-			this.bar();
-		}
-
-		public void bar() {
-			// some logic...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	class SimplePojo : Pojo {
-
-		fun foo() {
-			// this next method invocation is a direct call on the 'this' reference
-			this.bar()
-		}
-
-		fun bar() {
-			// some logic...
-		}
-	}
-----
-======
-
-If you invoke a method on an object reference, the method is invoked directly on
-that object reference, as the following image and listing show:
-
-image::aop-proxy-plain-pojo-call.png[]
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public class Main {
-
-		public static void main(String[] args) {
-			Pojo pojo = new SimplePojo();
-			// this is a direct method call on the 'pojo' reference
-			pojo.foo();
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun main() {
-		val pojo = SimplePojo()
-		// this is a direct method call on the 'pojo' reference
-		pojo.foo()
-	}
-----
-======
-
-Things change slightly when the reference that client code has is a proxy. Consider the
-following diagram and code snippet:
-
-image::aop-proxy-call.png[]
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public class Main {
-
-		public static void main(String[] args) {
-			ProxyFactory factory = new ProxyFactory(new SimplePojo());
-			factory.addInterface(Pojo.class);
-			factory.addAdvice(new RetryAdvice());
-
-			Pojo pojo = (Pojo) factory.getProxy();
-			// this is a method call on the proxy!
-			pojo.foo();
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-fun main() {
-	val factory = ProxyFactory(SimplePojo())
-	factory.addInterface(Pojo::class.java)
-	factory.addAdvice(RetryAdvice())
-
-	val pojo = factory.proxy as Pojo
-	// this is a method call on the proxy!
-	pojo.foo()
-}
-----
-======
-
-The key thing to understand here is that the client code inside the `main(..)` method
-of the `Main` class has a reference to the proxy. This means that method calls on that
-object reference are calls on the proxy. As a result, the proxy can delegate to all of
-the interceptors (advice) that are relevant to that particular method call. However,
-once the call has finally reached the target object (the `SimplePojo` reference in
-this case), any method calls that it may make on itself, such as `this.bar()` or
-`this.foo()`, are going to be invoked against the `this` reference, and not the proxy.
-This has important implications. It means that self-invocation is not going to result
-in the advice associated with a method invocation getting a chance to run.
-
-Okay, so what is to be done about this? The best approach (the term "best" is used
-loosely here) is to refactor your code such that the self-invocation does not happen.
-This does entail some work on your part, but it is the best, least-invasive approach.
-The next approach is absolutely horrendous, and we hesitate to point it out, precisely
-because it is so horrendous. You can (painful as it is to us) totally tie the logic
-within your class to Spring AOP, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public class SimplePojo implements Pojo {
-
-		public void foo() {
-			// this works, but... gah!
-			((Pojo) AopContext.currentProxy()).bar();
-		}
-
-		public void bar() {
-			// some logic...
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	class SimplePojo : Pojo {
-
-		fun foo() {
-			// this works, but... gah!
-			(AopContext.currentProxy() as Pojo).bar()
-		}
-
-		fun bar() {
-			// some logic...
-		}
-	}
-----
-======
-
-This totally couples your code to Spring AOP, and it makes the class itself aware of
-the fact that it is being used in an AOP context, which flies in the face of AOP. It
-also requires some additional configuration when the proxy is being created, as the
-following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public class Main {
-
-		public static void main(String[] args) {
-			ProxyFactory factory = new ProxyFactory(new SimplePojo());
-			factory.addInterface(Pojo.class);
-			factory.addAdvice(new RetryAdvice());
-			factory.setExposeProxy(true);
-
-			Pojo pojo = (Pojo) factory.getProxy();
-			// this is a method call on the proxy!
-			pojo.foo();
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun main() {
-		val factory = ProxyFactory(SimplePojo())
-		factory.addInterface(Pojo::class.java)
-		factory.addAdvice(RetryAdvice())
-		factory.isExposeProxy = true
-
-		val pojo = factory.proxy as Pojo
-		// this is a method call on the proxy!
-		pojo.foo()
-	}
-----
-======
-
-Finally, it must be noted that AspectJ does not have this self-invocation issue because
-it is not a proxy-based AOP framework.
-
-
-
-

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

@@ -1,12 +0,0 @@
-[[aop-resources]]
-= Further Resources
-:page-section-summary-toc: 1
-
-More information on AspectJ can be found on the {aspectj-site}[AspectJ website].
-
-_Eclipse AspectJ_ by Adrian Colyer et. al. (Addison-Wesley, 2005) provides a
-comprehensive introduction and reference for the AspectJ language.
-
-_AspectJ in Action_, Second Edition by Ramnivas Laddad (Manning, 2009) comes highly
-recommended. The focus of the book is on AspectJ, but a lot of general AOP themes are
-explored (in some depth).

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

@@ -1,987 +0,0 @@
-[[aop-schema]]
-= Schema-based AOP Support
-
-If you prefer an XML-based format, Spring also offers support for defining aspects
-using the `aop` namespace tags. The exact same pointcut expressions and advice kinds
-as when using the @AspectJ style are supported. Hence, in this section we focus on
-that syntax and refer the reader to the discussion in the previous section
-(xref:core/aop/ataspectj.adoc[@AspectJ support]) for an understanding of writing pointcut expressions and the binding
-of advice parameters.
-
-To use the aop namespace tags described in this section, you need to import the
-`spring-aop` schema, as described in xref:core/appendix/xsd-schemas.adoc[XML Schema-based configuration]
-. See xref:core/appendix/xsd-schemas.adoc#aop[the AOP schema]
-for how to import the tags in the `aop` namespace.
-
-Within your Spring configurations, all aspect and advisor elements must be placed within
-an `<aop:config>` element (you can have more than one `<aop:config>` element in an
-application context configuration). An `<aop:config>` element can contain pointcut,
-advisor, and aspect elements (note that these must be declared in that order).
-
-WARNING: The `<aop:config>` style of configuration makes heavy use of Spring's
-xref:core/aop-api/autoproxy.adoc[auto-proxying] mechanism. This can cause issues (such as advice
-not being woven) if you already use explicit auto-proxying through the use of
-`BeanNameAutoProxyCreator` or something similar. The recommended usage pattern is to
-use either only the `<aop:config>` style or only the `AutoProxyCreator` style and
-never mix them.
-
-
-
-[[aop-schema-declaring-an-aspect]]
-== Declaring an Aspect
-
-When you use the schema support, an aspect is a regular Java object defined as a bean in
-your Spring application context. The state and behavior are captured in the fields and
-methods of the object, and the pointcut and advice information are captured in the XML.
-
-You can declare an aspect by using the `<aop:aspect>` element, and reference the backing bean
-by using the `ref` attribute, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-		<aop:aspect id="myAspect" ref="aBean">
-			...
-		</aop:aspect>
-	</aop:config>
-
-	<bean id="aBean" class="...">
-		...
-	</bean>
-----
-
-The bean that backs the aspect (`aBean` in this case) can of course be configured and
-dependency injected just like any other Spring bean.
-
-
-
-[[aop-schema-pointcuts]]
-== Declaring a Pointcut
-
-You can declare a _named pointcut_ inside an `<aop:config>` element, letting the pointcut
-definition be shared across several aspects and advisors.
-
-A pointcut that represents the execution of any business service in the service layer can
-be defined as follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-
-		<aop:pointcut id="businessService"
-			expression="execution(* com.xyz.service.*.*(..))" />
-
-	</aop:config>
-----
-
-Note that the pointcut expression itself uses the same AspectJ pointcut expression
-language as described in xref:core/aop/ataspectj.adoc[@AspectJ support]. If you use the schema based declaration
-style, you can also refer to _named pointcuts_ defined in `@Aspect` types within the
-pointcut expression. Thus, another way of defining the above pointcut would be as follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-
-		<aop:pointcut id="businessService"
-			expression="com.xyz.CommonPointcuts.businessService()" /> <1>
-
-	</aop:config>
-----
-<1> References the `businessService` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[Sharing Named Pointcut Definitions].
-
-Declaring a pointcut _inside_ an aspect is very similar to declaring a top-level pointcut,
-as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-
-		<aop:aspect id="myAspect" ref="aBean">
-
-			<aop:pointcut id="businessService"
-				expression="execution(* com.xyz.service.*.*(..))"/>
-
-			...
-		</aop:aspect>
-
-	</aop:config>
-----
-
-In much the same way as an @AspectJ aspect, pointcuts declared by using the schema based
-definition style can collect join point context. For example, the following pointcut
-collects the `this` object as the join point context and passes it to the advice:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-
-		<aop:aspect id="myAspect" ref="aBean">
-
-			<aop:pointcut id="businessService"
-				expression="execution(* com.xyz.service.*.*(..)) &amp;&amp; this(service)"/>
-
-			<aop:before pointcut-ref="businessService" method="monitor"/>
-
-			...
-		</aop:aspect>
-
-	</aop:config>
-----
-
-The advice must be declared to receive the collected join point context by including
-parameters of the matching names, as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public void monitor(Object service) {
-		// ...
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun monitor(service: Any) {
-		// ...
-	}
-----
-======
-
-When combining pointcut sub-expressions, `+&amp;&amp;+` is awkward within an XML
-document, so you can use the `and`, `or`, and `not` keywords in place of `+&amp;&amp;+`,
-`||`, and `!`, respectively. For example, the previous pointcut can be better written as
-follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-
-		<aop:aspect id="myAspect" ref="aBean">
-
-			<aop:pointcut id="businessService"
-				expression="execution(* com.xyz.service.*.*(..)) and this(service)"/>
-
-			<aop:before pointcut-ref="businessService" method="monitor"/>
-
-			...
-		</aop:aspect>
-
-	</aop:config>
-----
-
-Note that pointcuts defined in this way are referred to by their XML `id` and cannot be
-used as named pointcuts to form composite pointcuts. The named pointcut support in the
-schema-based definition style is thus more limited than that offered by the @AspectJ
-style.
-
-
-
-[[aop-schema-advice]]
-== Declaring Advice
-
-The schema-based AOP support uses the same five kinds of advice as the @AspectJ style, and they have
-exactly the same semantics.
-
-
-[[aop-schema-advice-before]]
-=== Before Advice
-
-Before advice runs before a matched method execution. It is declared inside an
-`<aop:aspect>` by using the `<aop:before>` element, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="beforeExample" ref="aBean">
-
-		<aop:before
-			pointcut-ref="dataAccessOperation"
-			method="doAccessCheck"/>
-
-		...
-
-	</aop:aspect>
-----
-
-In the example above, `dataAccessOperation` is the `id` of a _named pointcut_ defined at
-the top (`<aop:config>`) level (see xref:core/aop/schema.adoc#aop-schema-pointcuts[Declaring a Pointcut]).
-
-NOTE: As we noted in the discussion of the @AspectJ style, using _named pointcuts_ can
-significantly improve the readability of your code. See xref:core/aop/ataspectj/pointcuts.adoc#aop-common-pointcuts[Sharing Named Pointcut Definitions] for
-details.
-
-To define the pointcut inline instead, replace the `pointcut-ref` attribute with a
-`pointcut` attribute, as follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="beforeExample" ref="aBean">
-
-		<aop:before
-			pointcut="execution(* com.xyz.dao.*.*(..))"
-			method="doAccessCheck"/>
-
-		...
-
-	</aop:aspect>
-----
-
-The `method` attribute identifies a method (`doAccessCheck`) that provides the body of
-the advice. This method must be defined for the bean referenced by the aspect element
-that contains the advice. Before a data access operation is performed (a method execution
-join point matched by the pointcut expression), the `doAccessCheck` method on the aspect
-bean is invoked.
-
-
-[[aop-schema-advice-after-returning]]
-=== After Returning Advice
-
-After returning advice runs when a matched method execution completes normally. It is
-declared inside an `<aop:aspect>` in the same way as before advice. The following example
-shows how to declare it:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="afterReturningExample" ref="aBean">
-
-		<aop:after-returning
-			pointcut="execution(* com.xyz.dao.*.*(..))"
-			method="doAccessCheck"/>
-
-		...
-	</aop:aspect>
-----
-
-As in the @AspectJ style, you can get the return value within the advice body.
-To do so, use the `returning` attribute to specify the name of the parameter to which
-the return value should be passed, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="afterReturningExample" ref="aBean">
-
-		<aop:after-returning
-			pointcut="execution(* com.xyz.dao.*.*(..))"
-			returning="retVal"
-			method="doAccessCheck"/>
-
-		...
-	</aop:aspect>
-----
-
-The `doAccessCheck` method must declare a parameter named `retVal`. The type of this
-parameter constrains matching in the same way as described for `@AfterReturning`. For
-example, you can declare the method signature as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public void doAccessCheck(Object retVal) {...
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun doAccessCheck(retVal: Any) {...
-----
-======
-
-
-[[aop-schema-advice-after-throwing]]
-=== After Throwing Advice
-
-After throwing advice runs when a matched method execution exits by throwing an
-exception. It is declared inside an `<aop:aspect>` by using the `after-throwing` element,
-as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="afterThrowingExample" ref="aBean">
-
-		<aop:after-throwing
-			pointcut="execution(* com.xyz.dao.*.*(..))"
-			method="doRecoveryActions"/>
-
-		...
-	</aop:aspect>
-----
-
-As in the @AspectJ style, you can get the thrown exception within the advice body.
-To do so, use the `throwing` attribute to specify the name of the parameter to
-which the exception should be passed as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="afterThrowingExample" ref="aBean">
-
-		<aop:after-throwing
-			pointcut="execution(* com.xyz.dao.*.*(..))"
-			throwing="dataAccessEx"
-			method="doRecoveryActions"/>
-
-		...
-	</aop:aspect>
-----
-
-The `doRecoveryActions` method must declare a parameter named `dataAccessEx`.
-The type of this parameter constrains matching in the same way as described for
-`@AfterThrowing`. For example, the method signature may be declared as follows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public void doRecoveryActions(DataAccessException dataAccessEx) {...
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun doRecoveryActions(dataAccessEx: DataAccessException) {...
-----
-======
-
-
-[[aop-schema-advice-after-finally]]
-=== After (Finally) Advice
-
-After (finally) advice runs no matter how a matched method execution exits.
-You can declare it by using the `after` element, as the following example shows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="afterFinallyExample" ref="aBean">
-
-		<aop:after
-			pointcut="execution(* com.xyz.dao.*.*(..))"
-			method="doReleaseLock"/>
-
-		...
-	</aop:aspect>
-----
-
-
-[[aop-schema-advice-around]]
-=== Around Advice
-
-The last kind of advice is _around_ advice. Around advice runs "around" a matched
-method's execution. It has the opportunity to do work both before and after the method
-runs and to determine when, how, and even if the method actually gets to run at all.
-Around advice is often used if you need to share state before and after a method
-execution in a thread-safe manner – for example, starting and stopping a timer.
-
-[TIP]
-====
-Always use the least powerful form of advice that meets your requirements.
-
-For example, do not use _around_ advice if _before_ advice is sufficient for your needs.
-====
-
-You can declare around advice by using the `aop:around` element. The advice method should
-declare `Object` as its return type, and the first parameter of the method must be of
-type `ProceedingJoinPoint`. Within the body of the advice method, you must invoke
-`proceed()` on the `ProceedingJoinPoint` in order for the underlying method to run.
-Invoking `proceed()` without arguments will result in the caller's original arguments
-being supplied to the underlying method when it is invoked. For advanced use cases, there
-is an overloaded variant of the `proceed()` method which accepts an array of arguments
-(`Object[]`). The values in the array will be used as the arguments to the underlying
-method when it is invoked. See xref:core/aop/ataspectj/advice.adoc#aop-ataspectj-around-advice[Around Advice] for notes on calling
-`proceed` with an `Object[]`.
-
-The following example shows how to declare around advice in XML:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="aroundExample" ref="aBean">
-
-		<aop:around
-			pointcut="execution(* com.xyz.service.*.*(..))"
-			method="doBasicProfiling"/>
-
-		...
-	</aop:aspect>
-----
-
-The implementation of the `doBasicProfiling` advice can be exactly the same as in the
-@AspectJ example (minus the annotation, of course), as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
-		// start stopwatch
-		Object retVal = pjp.proceed();
-		// stop stopwatch
-		return retVal;
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun doBasicProfiling(pjp: ProceedingJoinPoint): Any? {
-		// start stopwatch
-		val retVal = pjp.proceed()
-		// stop stopwatch
-		return pjp.proceed()
-	}
-----
-======
-
-
-[[aop-schema-params]]
-=== Advice Parameters
-
-The schema-based declaration style supports fully typed advice in the same way as
-described for the @AspectJ support -- by matching pointcut parameters by name against
-advice method parameters. See xref:core/aop/ataspectj/advice.adoc#aop-ataspectj-advice-params[Advice Parameters] for details. If you wish
-to explicitly specify argument names for the advice methods (not relying on the
-detection strategies previously described), you can do so by using the `arg-names`
-attribute of the advice element, which is treated in the same manner as the `argNames`
-attribute in an advice annotation (as described in xref:core/aop/ataspectj/advice.adoc#aop-ataspectj-advice-params-names[Determining Argument Names]).
-The following example shows how to specify an argument name in XML:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:before
-		pointcut="com.xyz.Pointcuts.publicMethod() and @annotation(auditable)" <1>
-		method="audit"
-		arg-names="auditable" />
-----
-<1> References the `publicMethod` named pointcut defined in xref:core/aop/ataspectj/pointcuts.adoc#aop-pointcuts-combining[Combining Pointcut Expressions].
-
-The `arg-names` attribute accepts a comma-delimited list of parameter names.
-
-The following slightly more involved example of the XSD-based approach shows
-some around advice used in conjunction with a number of strongly typed parameters:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
-----
-	package com.xyz.service;
-
-	public interface PersonService {
-
-		Person getPerson(String personName, int age);
-	}
-
-	public class DefaultPersonService implements PersonService {
-
-		public Person getPerson(String name, int age) {
-			return new Person(name, age);
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
-----
-	package com.xyz.service
-
-	interface PersonService {
-
-		fun getPerson(personName: String, age: Int): Person
-	}
-
-	class DefaultPersonService : PersonService {
-
-		fun getPerson(name: String, age: Int): Person {
-			return Person(name, age)
-		}
-	}
-----
-======
-
-Next up is the aspect. Notice the fact that the `profile(..)` method accepts a number of
-strongly-typed parameters, the first of which happens to be the join point used to
-proceed with the method call. The presence of this parameter is an indication that the
-`profile(..)` is to be used as `around` advice, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
-----
-	package com.xyz;
-
-	import org.aspectj.lang.ProceedingJoinPoint;
-	import org.springframework.util.StopWatch;
-
-	public class SimpleProfiler {
-
-		public Object profile(ProceedingJoinPoint call, String name, int age) throws Throwable {
-			StopWatch clock = new StopWatch("Profiling for '" + name + "' and '" + age + "'");
-			try {
-				clock.start(call.toShortString());
-				return call.proceed();
-			} finally {
-				clock.stop();
-				System.out.println(clock.prettyPrint());
-			}
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
-----
-	package com.xyz
-
-	import org.aspectj.lang.ProceedingJoinPoint
-	import org.springframework.util.StopWatch
-
-	class SimpleProfiler {
-
-		fun profile(call: ProceedingJoinPoint, name: String, age: Int): Any? {
-			val clock = StopWatch("Profiling for '$name' and '$age'")
-			try {
-				clock.start(call.toShortString())
-				return call.proceed()
-			} finally {
-				clock.stop()
-				println(clock.prettyPrint())
-			}
-		}
-	}
-----
-======
-
-Finally, the following example XML configuration effects the execution of the
-preceding advice for a particular join point:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<beans xmlns="http://www.springframework.org/schema/beans"
-		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-		xmlns:aop="http://www.springframework.org/schema/aop"
-		xsi:schemaLocation="
-			http://www.springframework.org/schema/beans
-			https://www.springframework.org/schema/beans/spring-beans.xsd
-			http://www.springframework.org/schema/aop
-			https://www.springframework.org/schema/aop/spring-aop.xsd">
-
-		<!-- this is the object that will be proxied by Spring's AOP infrastructure -->
-		<bean id="personService" class="com.xyz.service.DefaultPersonService"/>
-
-		<!-- this is the actual advice itself -->
-		<bean id="profiler" class="com.xyz.SimpleProfiler"/>
-
-		<aop:config>
-			<aop:aspect ref="profiler">
-
-				<aop:pointcut id="theExecutionOfSomePersonServiceMethod"
-					expression="execution(* com.xyz.service.PersonService.getPerson(String,int))
-					and args(name, age)"/>
-
-				<aop:around pointcut-ref="theExecutionOfSomePersonServiceMethod"
-					method="profile"/>
-
-			</aop:aspect>
-		</aop:config>
-
-	</beans>
-----
-
-Consider the following driver script:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public class Boot {
-
-		public static void main(String[] args) {
-			ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
-			PersonService person = ctx.getBean(PersonService.class);
-			person.getPerson("Pengo", 12);
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun main() {
-		val ctx = ClassPathXmlApplicationContext("beans.xml")
-		val person = ctx.getBean(PersonService.class)
-		person.getPerson("Pengo", 12)
-	}
-----
-======
-
-With such a `Boot` class, we would get output similar to the following on standard output:
-
-[literal,subs="verbatim"]
-----
-StopWatch 'Profiling for 'Pengo' and '12': running time (millis) = 0
------------------------------------------
-ms     %     Task name
------------------------------------------
-00000  ?  execution(getFoo)
-----
-
-
-[[aop-ordering]]
-=== Advice Ordering
-
-When multiple pieces of advice need to run at the same join point (executing method)
-the ordering rules are as described in xref:core/aop/ataspectj/advice.adoc#aop-ataspectj-advice-ordering[Advice Ordering]. The precedence
-between aspects is determined via the `order` attribute in the `<aop:aspect>` element or
-by either adding the `@Order` annotation to the bean that backs the aspect or by having
-the bean implement the `Ordered` interface.
-
-[NOTE]
-====
-In contrast to the precedence rules for advice methods defined in the same `@Aspect`
-class, when two pieces of advice defined in the same `<aop:aspect>` element both need to
-run at the same join point, the precedence is determined by the order in which the advice
-elements are declared within the enclosing `<aop:aspect>` element, from highest to lowest
-precedence.
-
-For example, given an `around` advice and a `before` advice defined in the same
-`<aop:aspect>` element that apply to the same join point, to ensure that the `around`
-advice has higher precedence than the `before` advice, the `<aop:around>` element must be
-declared before the `<aop:before>` element.
-
-As a general rule of thumb, if you find that you have multiple pieces of advice defined
-in the same `<aop:aspect>` element that apply to the same join point, consider collapsing
-such advice methods into one advice method per join point in each `<aop:aspect>` element
-or refactor the pieces of advice into separate `<aop:aspect>` elements that you can order
-at the aspect level.
-====
-
-
-
-[[aop-schema-introductions]]
-== Introductions
-
-Introductions (known as inter-type declarations in AspectJ) let an aspect declare
-that advised objects implement a given interface and provide an implementation of
-that interface on behalf of those objects.
-
-You can make an introduction by using the `aop:declare-parents` element inside an `aop:aspect`.
-You can use the `aop:declare-parents` element to declare that matching types have a new parent (hence the name).
-For example, given an interface named `UsageTracked` and an implementation of that interface named
-`DefaultUsageTracked`, the following aspect declares that all implementors of service
-interfaces also implement the `UsageTracked` interface. (In order to expose statistics
-through JMX for example.)
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:aspect id="usageTrackerAspect" ref="usageTracking">
-
-		<aop:declare-parents
-			types-matching="com.xyz.service.*+"
-			implement-interface="com.xyz.service.tracking.UsageTracked"
-			default-impl="com.xyz.service.tracking.DefaultUsageTracked"/>
-
-		<aop:before
-			pointcut="execution(* com.xyz..service.*.*(..))
-				and this(usageTracked)"
-				method="recordUsage"/>
-
-	</aop:aspect>
-----
-
-The class that backs the `usageTracking` bean would then contain the following method:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public void recordUsage(UsageTracked usageTracked) {
-		usageTracked.incrementUseCount();
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	fun recordUsage(usageTracked: UsageTracked) {
-		usageTracked.incrementUseCount()
-	}
-----
-======
-
-The interface to be implemented is determined by the `implement-interface` attribute. The
-value of the `types-matching` attribute is an AspectJ type pattern. Any bean of a
-matching type implements the `UsageTracked` interface. Note that, in the before
-advice of the preceding example, service beans can be directly used as implementations of
-the `UsageTracked` interface. To access a bean programmatically, you could write the
-following:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	UsageTracked usageTracked = context.getBean("myService", UsageTracked.class);
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	val usageTracked = context.getBean("myService", UsageTracked.class)
-----
-======
-
-
-
-[[aop-schema-instantiation-models]]
-== Aspect Instantiation Models
-
-The only supported instantiation model for schema-defined aspects is the singleton
-model. Other instantiation models may be supported in future releases.
-
-
-
-[[aop-schema-advisors]]
-== Advisors
-
-The concept of "advisors" comes from the AOP support defined in Spring
-and does not have a direct equivalent in AspectJ. An advisor is like a small
-self-contained aspect that has a single piece of advice. The advice itself is
-represented by a bean and must implement one of the advice interfaces described in
-xref:core/aop-api/advice.adoc#aop-api-advice-types[Advice Types in Spring]. Advisors can take advantage of AspectJ pointcut expressions.
-
-Spring supports the advisor concept with the `<aop:advisor>` element. You most
-commonly see it used in conjunction with transactional advice, which also has its own
-namespace support in Spring. The following example shows an advisor:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-
-		<aop:pointcut id="businessService"
-			expression="execution(* com.xyz.service.*.*(..))"/>
-
-		<aop:advisor
-			pointcut-ref="businessService"
-			advice-ref="tx-advice" />
-
-	</aop:config>
-
-	<tx:advice id="tx-advice">
-		<tx:attributes>
-			<tx:method name="*" propagation="REQUIRED"/>
-		</tx:attributes>
-	</tx:advice>
-----
-
-As well as the `pointcut-ref` attribute used in the preceding example, you can also use the
-`pointcut` attribute to define a pointcut expression inline.
-
-To define the precedence of an advisor so that the advice can participate in ordering,
-use the `order` attribute to define the `Ordered` value of the advisor.
-
-
-
-[[aop-schema-example]]
-== An AOP Schema Example
-
-This section shows how the concurrent locking failure retry example from
-xref:core/aop/ataspectj/example.adoc[An AOP Example] looks when rewritten with the schema support.
-
-The execution of business services can sometimes fail due to concurrency issues (for
-example, a deadlock loser). If the operation is retried, it is likely to succeed
-on the next try. For business services where it is appropriate to retry in such
-conditions (idempotent operations that do not need to go back to the user for conflict
-resolution), we want to transparently retry the operation to avoid the client seeing a
-`PessimisticLockingFailureException`. This is a requirement that clearly cuts across
-multiple services in the service layer and, hence, is ideal for implementing through an
-aspect.
-
-Because we want to retry the operation, we need to use around advice so that we can
-call `proceed` multiple times. The following listing shows the basic aspect implementation
-(which is a regular Java class that uses the schema support):
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	public class ConcurrentOperationExecutor implements Ordered {
-
-		private static final int DEFAULT_MAX_RETRIES = 2;
-
-		private int maxRetries = DEFAULT_MAX_RETRIES;
-		private int order = 1;
-
-		public void setMaxRetries(int maxRetries) {
-			this.maxRetries = maxRetries;
-		}
-
-		public int getOrder() {
-			return this.order;
-		}
-
-		public void setOrder(int order) {
-			this.order = order;
-		}
-
-		public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {
-			int numAttempts = 0;
-			PessimisticLockingFailureException lockFailureException;
-			do {
-				numAttempts++;
-				try {
-					return pjp.proceed();
-				}
-				catch(PessimisticLockingFailureException ex) {
-					lockFailureException = ex;
-				}
-			} while(numAttempts <= this.maxRetries);
-			throw lockFailureException;
-		}
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	class ConcurrentOperationExecutor : Ordered {
-
-		private val DEFAULT_MAX_RETRIES = 2
-
-		private var maxRetries = DEFAULT_MAX_RETRIES
-		private var order = 1
-
-		fun setMaxRetries(maxRetries: Int) {
-			this.maxRetries = maxRetries
-		}
-
-		override fun getOrder(): Int {
-			return this.order
-		}
-
-		fun setOrder(order: Int) {
-			this.order = order
-		}
-
-		fun doConcurrentOperation(pjp: ProceedingJoinPoint): Any? {
-			var numAttempts = 0
-			var lockFailureException: PessimisticLockingFailureException
-			do {
-				numAttempts++
-				try {
-					return pjp.proceed()
-				} catch (ex: PessimisticLockingFailureException) {
-					lockFailureException = ex
-				}
-
-			} while (numAttempts <= this.maxRetries)
-			throw lockFailureException
-		}
-	}
-----
-======
-
-Note that the aspect implements the `Ordered` interface so that we can set the precedence of
-the aspect higher than the transaction advice (we want a fresh transaction each time we
-retry). The `maxRetries` and `order` properties are both configured by Spring. The
-main action happens in the `doConcurrentOperation` around advice method. We try to
-proceed. If we fail with a `PessimisticLockingFailureException`, we try again,
-unless we have exhausted all of our retry attempts.
-
-NOTE: This class is identical to the one used in the @AspectJ example, but with the
-annotations removed.
-
-The corresponding Spring configuration is as follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:config>
-
-		<aop:aspect id="concurrentOperationRetry" ref="concurrentOperationExecutor">
-
-			<aop:pointcut id="idempotentOperation"
-				expression="execution(* com.xyz.service.*.*(..))"/>
-
-			<aop:around
-				pointcut-ref="idempotentOperation"
-				method="doConcurrentOperation"/>
-
-		</aop:aspect>
-
-	</aop:config>
-
-	<bean id="concurrentOperationExecutor"
-		class="com.xyz.service.impl.ConcurrentOperationExecutor">
-			<property name="maxRetries" value="3"/>
-			<property name="order" value="100"/>
-	</bean>
-----
-
-Notice that, for the time being, we assume that all business services are idempotent. If
-this is not the case, we can refine the aspect so that it retries only genuinely
-idempotent operations, by introducing an `Idempotent` annotation and using the annotation
-to annotate the implementation of service operations, as the following example shows:
-
-[tabs]
-======
-Java::
-+
-[source,java,indent=0,subs="verbatim",role="primary"]
-----
-	@Retention(RetentionPolicy.RUNTIME)
-	// marker annotation
-	public @interface Idempotent {
-	}
-----
-
-Kotlin::
-+
-[source,kotlin,indent=0,subs="verbatim",role="secondary"]
-----
-	@Retention(AnnotationRetention.RUNTIME)
-	// marker annotation
-	annotation class Idempotent
-----
-======
-
-The
-change to the aspect to retry only idempotent operations involves refining the
-pointcut expression so that only `@Idempotent` operations match, as follows:
-
-[source,xml,indent=0,subs="verbatim"]
-----
-	<aop:pointcut id="idempotentOperation"
-			expression="execution(* com.xyz.service.*.*(..)) and
-			@annotation(com.xyz.service.Idempotent)"/>
-----
-
-
-
-