Efficient ETag parsing

Closes gh-33372

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

@@ -0,0 +1,20 @@
+name: Await HTTP Resource
+description: Waits for an HTTP resource to be available (a HEAD request succeeds)
+inputs:
+  url:
+    description: 'The 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

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

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

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

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

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

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

@@ -0,0 +1,49 @@
+name: 'Prepare Gradle Build'
+description: 'Prepares a Gradle build. Sets up Java and Gradle and configures Gradle properties'
+inputs:
+  java-version:
+    required: false
+    default: '17'
+    description: 'The Java version to use for the build'
+  java-early-access:
+    required: false
+    default: 'false'
+    description: 'Whether the Java version is in early access'
+  java-toolchain:
+    required: false
+    default: 'false'
+    description: 'Whether a Java toolchain should be used'
+  develocity-access-key:
+    required: false
+    description: 'The access key for authentication with ge.spring.io'
+runs:
+  using: composite
+  steps:
+    - name: Set Up Java
+      uses: actions/setup-java@v4
+      with:
+        distribution: ${{ inputs.java-early-access == 'true' && 'temurin' || '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@d9c87d481d55275bb5441eef3fe0e46805f9ef70 # v3.5.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/send-notification/action.yml

@@ -0,0 +1,33 @@
+name: Send Notification
+description: Sends a Google Chat message as a notification of the job's outcome
+inputs:
+  webhook-url:
+    description: 'Google Chat Webhook URL'
+    required: true
+  status:
+    description: 'Status of the job'
+    required: true
+  build-scan-url:
+    description: 'URL of the build scan to include in the notification'
+  run-name:
+    description: 'Name of the run to include in the notification'
+    default: ${{ format('{0} {1}', github.ref_name, github.job) }}
+runs:
+  using: composite
+  steps:
+    - shell: bash
+      run: |
+        echo "BUILD_SCAN=${{ inputs.build-scan-url == '' && ' [build scan unavailable]' || format(' [<{0}|Build Scan>]', inputs.build-scan-url) }}" >> "$GITHUB_ENV"
+        echo "RUN_URL=${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" >> "$GITHUB_ENV"
+    - shell: bash
+      if: ${{ inputs.status == 'success' }}
+      run: |
+        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was successful ${{ env.BUILD_SCAN }}"}' || true
+    - shell: bash
+      if: ${{ inputs.status == 'failure' }}
+      run: |
+        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<users/all> *<${{ env.RUN_URL }}|${{ inputs.run-name }}> failed* ${{ env.BUILD_SCAN }}"}' || true
+    - shell: bash
+      if: ${{ inputs.status == 'cancelled' }}
+      run: |
+        curl -X POST '${{ inputs.webhook-url }}' -H 'Content-Type: application/json' -d '{ text: "<${{ env.RUN_URL }}|${{ inputs.run-name }}> was cancelled"}' || true

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

@@ -0,0 +1,43 @@
+name: Sync to Maven Central
+description: Syncs a release to Maven Central and waits for it to be available for use
+inputs:
+  jfrog-cli-config-token:
+    description: 'Config token for the JFrog CLI'
+    required: true
+  spring-framework-version:
+    description: 'The version of Spring Framework that is being synced to Central'
+    required: true
+  ossrh-s01-token-username:
+    description: 'Username for authentication with s01.oss.sonatype.org'
+    required: true
+  ossrh-s01-token-password:
+    description: 'Password for authentication with s01.oss.sonatype.org'
+    required: true
+  ossrh-s01-staging-profile:
+    description: 'Staging profile to use when syncing to Central'
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Set Up JFrog CLI
+      uses: jfrog/setup-jfrog-cli@105617d23456a69a92485207c4f28ae12297581d # v4.2.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:
+        username: ${{ inputs.ossrh-s01-token-username }}
+        password: ${{ inputs.ossrh-s01-token-password }}
+        staging-profile-name: ${{ inputs.ossrh-s01-staging-profile }}
+        create: true
+        upload: true
+        close: true
+        release: true
+        generate-checksums: true
+    - name: Await
+      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

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

.github/workflows/backport-bot.yml

@@ -18,11 +18,13 @@ jobs:
       pull-requests: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-java@v3
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Set up Java
+        uses: actions/setup-java@v4
         with:
-          distribution: 'temurin'
-          java-version: '17'
+          distribution: 'liberica'
+          java-version: 17
       - name: Download BackportBot
         run: wget https://github.com/spring-io/backport-bot/releases/download/latest/backport-bot-0.0.1-SNAPSHOT.jar
       - name: Backport

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

@@ -0,0 +1,59 @@
+name: Build and Deploy Snapshot
+on:
+  push:
+    branches:
+      - 6.0.x
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build-and-deploy-snapshot:
+    name: Build and Deploy Snapshot
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Build and Publish
+        id: build-and-publish
+        uses: ./.github/actions/build
+        with:
+          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+          publish: true
+      - name: Deploy
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
+        with:
+          uri: 'https://repo.spring.io'
+          username: ${{ secrets.ARTIFACTORY_USERNAME }}
+          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          build-name: 'spring-framework-6.0.x'
+          repository: 'libs-snapshot-local'
+          folder: 'deployment-repository'
+          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
+          artifact-properties: |
+            /**/framework-docs-*.zip::zip.name=spring-framework,zip.deployed=false
+            /**/framework-docs-*-docs.zip::zip.type=docs
+            /**/framework-docs-*-dist.zip::zip.type=dist
+            /**/framework-docs-*-schema.zip::zip.type=schema
+      - name: Send Notification
+        uses: ./.github/actions/send-notification
+        if: always()
+        with:
+          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+          status: ${{ job.status }}
+          build-scan-url: ${{ steps.build-and-publish.outputs.build-scan-url }}
+          run-name: ${{ format('{0} | Linux | Java 17', github.ref_name) }}
+    outputs:
+      version: ${{ steps.build-and-publish.outputs.version }}
+  verify:
+    name: Verify
+    needs: build-and-deploy-snapshot
+    uses: ./.github/workflows/verify.yml
+    secrets:
+      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
+      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+    with:
+      version: ${{ needs.build-and-deploy-snapshot.outputs.version }}

.github/workflows/ci.yml

@@ -0,0 +1,53 @@
+name: CI
+on:
+  push:
+    branches:
+      - 6.0.x
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  ci:
+    name: '${{ matrix.os.name}} | Java ${{ matrix.java.version}}'
+    runs-on: ${{ matrix.os.id }}
+    timeout-minutes: 60
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    strategy:
+      matrix:
+        os:
+          - id: ubuntu-latest
+            name: Linux
+        java:
+          - version: 17
+            toolchain: false
+          - version: 21
+            toolchain: true
+        exclude:
+          - os:
+              name: Linux
+            java:
+              version: 17
+    steps:
+      - name: Prepare Windows runner
+        if: ${{ runner.os == 'Windows' }}
+        run: |
+          git config --global core.autocrlf true
+          git config --global core.longPaths true
+          Stop-Service -name Docker
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Build
+        id: build
+        uses: ./.github/actions/build
+        with:
+          java-version: ${{ matrix.java.version }}
+          java-early-access: ${{ matrix.java.early-access || 'false' }}
+          java-toolchain: ${{ matrix.java.toolchain }}
+          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+      - name: Send Notification
+        uses: ./.github/actions/send-notification
+        if: always()
+        with:
+          webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+          status: ${{ job.status }}
+          build-scan-url: ${{ steps.build.outputs.build-scan-url }}
+          run-name: ${{ format('{0} | {1} | Java {2}', github.ref_name, matrix.os.name, matrix.java.version) }}

.github/workflows/deploy-docs.yml

@@ -0,0 +1,34 @@
+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:
+    runs-on: ubuntu-latest
+    if: github.repository_owner == 'spring-projects'
+    steps:
+    - name: Check out code
+      uses: actions/checkout@v4
+      with:
+        ref: docs-build
+        fetch-depth: 1
+    - 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/gradle-wrapper-validation.yml

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

.github/workflows/release.yml

@@ -0,0 +1,95 @@
+name: Release
+on:
+  push:
+    tags:
+      - v6.0.[0-9]+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  build-and-stage-release:
+    if: ${{ github.repository == 'spring-projects/spring-framework' }}
+    name: Build and Stage Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Build and Publish
+        id: build-and-publish
+        uses: ./.github/actions/build
+        with:
+          develocity-access-key: ${{ secrets.GRADLE_ENTERPRISE_SECRET_ACCESS_KEY }}
+          publish: true
+      - name: Stage Release
+        uses: spring-io/artifactory-deploy-action@26bbe925a75f4f863e1e529e85be2d0093cac116 # v0.0.1
+        with:
+          uri: 'https://repo.spring.io'
+          username: ${{ secrets.ARTIFACTORY_USERNAME }}
+          password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          build-name: ${{ format('spring-framework-{0}', steps.build-and-publish.outputs.version)}}
+          repository: 'libs-staging-local'
+          folder: 'deployment-repository'
+          signing-key: ${{ secrets.GPG_PRIVATE_KEY }}
+          signing-passphrase: ${{ secrets.GPG_PASSPHRASE }}
+          artifact-properties: |
+            /**/framework-docs-*.zip::zip.name=spring-framework,zip.deployed=false
+            /**/framework-docs-*-docs.zip::zip.type=docs
+            /**/framework-docs-*-dist.zip::zip.type=dist
+            /**/framework-docs-*-schema.zip::zip.type=schema
+    outputs:
+      version: ${{ steps.build-and-publish.outputs.version }}
+  verify:
+    name: Verify
+    needs: build-and-stage-release
+    uses: ./.github/workflows/verify.yml
+    with:
+      staging: true
+      version: ${{ needs.build-and-stage-release.outputs.version }}
+    secrets:
+      google-chat-webhook-url: ${{ secrets.GOOGLE_CHAT_WEBHOOK_URL }}
+      repository-password: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      repository-username: ${{ secrets.ARTIFACTORY_USERNAME }}
+      token: ${{ secrets.GH_ACTIONS_REPO_TOKEN }}
+  sync-to-maven-central:
+    name: Sync to Maven Central
+    needs:
+      - build-and-stage-release
+      - verify
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+      - name: Sync to Maven Central
+        uses: ./.github/actions/sync-to-maven-central
+        with:
+          jfrog-cli-config-token: ${{ secrets.JF_ARTIFACTORY_SPRING }}
+          ossrh-s01-staging-profile: ${{ secrets.OSSRH_S01_STAGING_PROFILE }}
+          ossrh-s01-token-password: ${{ secrets.OSSRH_S01_TOKEN_PASSWORD }}
+          ossrh-s01-token-username: ${{ secrets.OSSRH_S01_TOKEN_USERNAME }}
+          spring-framework-version: ${{ needs.build-and-stage-release.outputs.version }}
+  promote-release:
+    name: Promote Release
+    needs:
+      - build-and-stage-release
+      - sync-to-maven-central
+    runs-on: ubuntu-latest
+    steps:
+      - name: Set up JFrog CLI
+        uses: jfrog/setup-jfrog-cli@105617d23456a69a92485207c4f28ae12297581d # v4.2.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/validate-gradle-wrapper.yml

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

.github/workflows/verify.yml

@@ -0,0 +1,71 @@
+name: Verify
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      staging:
+        required: false
+        default: false
+        type: boolean
+    secrets:
+      repository-username:
+        required: false
+      repository-password:
+        required: false
+      google-chat-webhook-url:
+        required: true
+      token:
+        required: true
+jobs:
+  verify:
+    name: Verify
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check Out Release Verification Tests
+        uses: actions/checkout@v4
+        with:
+          repository: spring-projects/spring-framework-release-verification
+          ref: 'v0.0.2'
+          token: ${{ secrets.token }}
+      - name: Check Out Send Notification Action
+        uses: actions/checkout@v4
+        with:
+          path: spring-framework
+          sparse-checkout: .github/actions/send-notification
+      - name: Set Up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'liberica'
+          java-version: 17
+      - name: Set Up Gradle
+        uses: gradle/actions/setup-gradle@d9c87d481d55275bb5441eef3fe0e46805f9ef70 # v3.5.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_VERSION: ${{ inputs.version }}
+          RVT_RELEASE_TYPE: oss
+          RVT_STAGING: ${{ inputs.staging }}
+          RVT_OSS_REPOSITORY_USERNAME: ${{ secrets.repository-username }}
+          RVT_OSS_REPOSITORY_PASSWORD: ${{ secrets.repository-password }}
+        run: ./gradlew spring-framework-release-verification-tests:test
+      - name: Upload Build Reports on Failure
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: build-reports
+          path: '**/build/reports/'
+      - name: Send Notification
+        uses: ./spring-framework/.github/actions/send-notification
+        if: failure()
+        with:
+          webhook-url: ${{ secrets.google-chat-webhook-url }}
+          status: ${{ job.status }}
+          run-name: ${{ format('{0} | Verification | {1}', github.ref_name, inputs.version) }}

.gitignore

@@ -21,8 +21,7 @@ derby.log
 /build
 buildSrc/build
 /spring-*/build
-/framework-bom/build
-/framework-docs/build
+/framework-*/build
 /integration-tests/build
 /src/asciidoc/build
 spring-test/test-output/
@@ -50,3 +49,7 @@ atlassian-ide-plugin.xml
 
 # VS Code
 .vscode/
+
+cached-antora-playbook.yml
+
+node_modules

.mailmap

@@ -1,36 +0,0 @@
-Juergen Hoeller <jhoeller@vmware.com>
-Juergen Hoeller <jhoeller@vmware.com> <jhoeller@pivotal.io>
-Juergen Hoeller <jhoeller@vmware.com> <jhoeller@gopivotal.com>
-Rossen Stoyanchev <rstoyanchev@vmware.com>
-Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@pivotal.io>
-Rossen Stoyanchev <rstoyanchev@vmware.com> <rstoyanchev@gopivotal.com>
-Phillip Webb <pwebb@vmware.com>
-Phillip Webb <pwebb@vmware.com> <pwebb@pivotal.io>
-Phillip Webb <pwebb@vmware.com> <pwebb@gopivotal.com>
-Chris Beams <cbeams@vmware.com>
-Chris Beams <cbeams@vmware.com> <cbeams@pivotal.io>
-Chris Beams <cbeams@vmware.com> <cbeams@gopivotal.com>
-Arjen Poutsma <poutsmaa@vmware.com>
-Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@pivotal.io>
-Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@gopivotal.com>
-Arjen Poutsma <poutsmaa@vmware.com> <poutsma@mac.com>
-Arjen Poutsma <poutsmaa@vmware.com> <apoutsma@vmware.com>
-Oliver Drotbohm <odrotbohm@vmware.com>
-Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@vmware.com>
-Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@pivotal.io>
-Oliver Drotbohm <odrotbohm@vmware.com> <ogierke@gopivotal.com>
-Dave Syer <dsyer@vmware.com>
-Dave Syer <dsyer@vmware.com> <dsyer@pivotal.io>
-Dave Syer <dsyer@vmware.com> <dsyer@gopivotal.com>
-Dave Syer <dsyer@vmware.com> <david_syer@hotmail.com>
-Andy Clement <aclement@vmware.com>
-Andy Clement <aclement@vmware.com> <aclement@pivotal.io>
-Andy Clement <aclement@vmware.com> <aclement@gopivotal.com>
-Andy Clement <aclement@vmware.com> <andrew.clement@gmail.com>
-Sam Brannen <sbrannen@vmware.com>
-Sam Brannen <sbrannen@vmware.com> <sbrannen@pivotal.io>
-Sam Brannen <sbrannen@vmware.com> <sam@sambrannen.com>
-Simon Basle <sbasle@vmware.com>
-Simon Baslé <sbasle@vmware.com>
-<dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
-Nick Williams <nicholas@nicholaswilliams.net>

.sdkmanrc

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

README.md

@@ -1,4 +1,4 @@
-# <img src="framework-docs/src/docs/spring-framework.png" width="80" height="80"> Spring Framework [![Build Status](https://ci.spring.io/api/v1/teams/spring-framework/pipelines/spring-framework-6.0.x/jobs/build/badge)](https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x?groups=Build") [![Revved up by Gradle Enterprise](https://img.shields.io/badge/Revved%20up%20by-Gradle%20Enterprise-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
+# <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.0.x)](https://github.com/spring-projects/spring-framework/actions/workflows/build-and-deploy-snapshot.yml?query=branch%3A6.0.x) [![Revved up by Develocity](https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A)](https://ge.spring.io/scans?search.rootProjectNames=spring)
 
 This is the home of the Spring Framework: the foundation for all [Spring projects](https://spring.io/projects). Collectively the Spring Framework and the family of Spring projects are often referred to simply as "Spring". 
 

build.gradle

@@ -3,14 +3,12 @@ plugins {
 	id 'io.freefair.aspectj' version '8.0.1' apply false
 	// kotlinVersion is managed in gradle.properties
 	id 'org.jetbrains.kotlin.plugin.serialization' version "${kotlinVersion}" apply false
-	id 'org.jetbrains.dokka' version '1.8.10'
-	id 'org.asciidoctor.jvm.convert' version '3.3.2' apply false
-	id 'org.asciidoctor.jvm.pdf' version '3.3.2'  apply false
+	id 'org.jetbrains.dokka' version '1.8.20'
 	id 'org.unbroken-dome.xjc' version '2.0.0' apply false
-	id 'com.github.ben-manes.versions' version '0.46.0'
+	id 'com.github.ben-manes.versions' version '0.51.0'
 	id 'com.github.johnrengelman.shadow' version '8.1.1' apply false
 	id 'de.undercouch.download' version '5.4.0'
-	id 'me.champeau.jmh' version '0.7.0' apply false
+	id 'me.champeau.jmh' version '0.7.2' apply false
 }
 
 ext {
@@ -28,7 +26,6 @@ configure(allprojects) { project ->
 				includeGroup 'io.projectreactor.netty'
 			}
 		}
-		maven { url "https://repo.spring.io/libs-spring-framework-build" }
 		if (version.contains('-')) {
 			maven { url "https://repo.spring.io/milestone" }
 		}
@@ -78,7 +75,7 @@ configure([rootProject] + javaProjects) { project ->
 	}
 
 	checkstyle {
-		toolVersion = "10.9.3"
+		toolVersion = "10.12.7"
 		configDirectory.set(rootProject.file("src/checkstyle"))
 	}
 
@@ -109,17 +106,14 @@ configure([rootProject] + javaProjects) { project ->
 		// JSR-305 only used for non-required meta-annotations
 		compileOnly("com.google.code.findbugs:jsr305")
 		testCompileOnly("com.google.code.findbugs:jsr305")
-		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.38")
+		checkstyle("io.spring.javaformat:spring-javaformat-checkstyle:0.0.42")
 	}
 
 	ext.javadocLinks = [
 			"https://docs.oracle.com/en/java/javase/17/docs/api/",
 			"https://jakarta.ee/specifications/platform/9/apidocs/",
-			"https://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/",  // CommonJ
-			"https://www.ibm.com/docs/api/v1/content/SSEQTP_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/",
-			"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/",
-			"https://docs.jboss.org/jbossas/javadoc/7.1.2.Final/",
-			"https://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
+			"https://docs.jboss.org/hibernate/orm/5.6/javadocs/",
+			"https://eclipse.dev/aspectj/doc/released/aspectj5rt-api",
 			"https://www.quartz-scheduler.org/api/2.3.0/",
 			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-core/2.14.1/",
 			"https://www.javadoc.io/doc/com.fasterxml.jackson.core/jackson-databind/2.14.1/",
@@ -130,15 +124,13 @@ configure([rootProject] + javaProjects) { project ->
 			// TODO Uncomment link to JUnit 5 docs once we execute Gradle with Java 18+.
 			// See https://github.com/spring-projects/spring-framework/issues/27497
 			//
-			// "https://junit.org/junit5/docs/5.9.2/api/",
+			// "https://junit.org/junit5/docs/5.9.3/api/",
 			"https://www.reactive-streams.org/reactive-streams-1.0.3-javadoc/",
 			"https://javadoc.io/static/io.rsocket/rsocket-core/1.1.1/",
 			"https://r2dbc.io/spec/1.0.0.RELEASE/api/",
-			// The external Javadoc link for JSR 305 must come last to ensure that types from
-			// JSR 250 (such as @PostConstruct) are still supported. This is due to the fact
-			// that JSR 250 and JSR 305 both define types in javax.annotation, which results
-			// in a split package, and the javadoc tool does not support split packages
-			// across multiple external Javadoc sites.
+			// Previously there could be a split-package issue between JSR250 and JSR305 javax.annotation packages,
+			// but since 6.0 JSR 250 annotations such as @Resource and @PostConstruct have been replaced by their
+			// JakartaEE equivalents in the jakarta.annotation package.
 			"https://www.javadoc.io/doc/com.google.code.findbugs/jsr305/3.0.2/"
 	] as String[]
 }
@@ -151,15 +143,15 @@ configure(rootProject) {
 	description = "Spring Framework"
 
 	apply plugin: "io.spring.nohttp"
-	apply plugin: 'org.springframework.build.api-diff'
 
 	nohttp {
 		source.exclude "**/test-output/**"
+		source.exclude "**/.gradle/**"
 		allowlistFile = project.file("src/nohttp/allowlist.lines")
 		def rootPath = file(rootDir).toPath()
 		def projectDirs = allprojects.collect { it.projectDir } + "${rootDir}/buildSrc"
 		projectDirs.forEach { dir ->
-			[ 'bin', 'build', 'out', '.settings' ]
+			[ 'bin', 'build', 'out', '.settings', 'node_modules' ]
 				.collect { rootPath.relativize(new File(dir, it).toPath()) }
 				.forEach { source.exclude "$it/**" }
 			[ '.classpath', '.project' ]

buildSrc/README.md

@@ -22,21 +22,6 @@ 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.
 
-### API Diff
-
-This plugin uses the [Gradle JApiCmp](https://github.com/melix/japicmp-gradle-plugin) plugin
-to generate API Diff reports for each Spring Framework module. This plugin is applied once on the root
-project and creates tasks in each framework module. Unlike previous versions of this part of the build,
-there is no need for checking out a specific tag. The plugin will fetch the JARs we want to compare the
-current working version with. You can generate the reports for all modules or a single module:
-
-```
-./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE
-./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE
-```      
-
-The reports are located under `build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/`.
-                                                                                       
 
 ### RuntimeHints Java Agent
 

buildSrc/build.gradle

@@ -19,16 +19,11 @@ ext {
 dependencies {
 	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
 	implementation("org.jetbrains.kotlin:kotlin-compiler-embeddable:${kotlinVersion}")
-	implementation "me.champeau.gradle:japicmp-gradle-plugin:0.3.0"
-	implementation "org.gradle:test-retry-gradle-plugin:1.4.1"
+	implementation "org.gradle:test-retry-gradle-plugin:1.5.6"
 }
 
 gradlePlugin {
 	plugins {
-		apiDiffPlugin {
-			id = "org.springframework.build.api-diff"
-			implementationClass = "org.springframework.build.api.ApiDiffPlugin"
-		}
 		conventionsPlugin {
 			id = "org.springframework.build.conventions"
 			implementationClass = "org.springframework.build.ConventionsPlugin"

buildSrc/src/main/java/org/springframework/build/api/ApiDiffPlugin.java

@@ -1,140 +0,0 @@
-/*
- * Copyright 2002-2019 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.api;
-
-import java.io.File;
-import java.net.URI;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.Collections;
-import java.util.List;
-
-import me.champeau.gradle.japicmp.JapicmpPlugin;
-import me.champeau.gradle.japicmp.JapicmpTask;
-import org.gradle.api.GradleException;
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.Dependency;
-import org.gradle.api.plugins.JavaBasePlugin;
-import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.publish.maven.plugins.MavenPublishPlugin;
-import org.gradle.api.tasks.TaskProvider;
-import org.gradle.jvm.tasks.Jar;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * {@link Plugin} that applies the {@code "japicmp-gradle-plugin"}
- * and create tasks for all subprojects named {@code "spring-*"}, diffing the public API one by one
- * and creating the reports in {@code "build/reports/api-diff/$OLDVERSION_to_$NEWVERSION/"}.
- * <p>{@code "./gradlew apiDiff -PbaselineVersion=5.1.0.RELEASE"} will output the
- * reports for the API diff between the baseline version and the current one for all modules.
- * You can limit the report to a single module with
- * {@code "./gradlew :spring-core:apiDiff -PbaselineVersion=5.1.0.RELEASE"}.
- *
- * @author Brian Clozel
- */
-public class ApiDiffPlugin implements Plugin<Project> {
-
-	private static final Logger logger = LoggerFactory.getLogger(ApiDiffPlugin.class);
-
-	public static final String TASK_NAME = "apiDiff";
-
-	private static final String BASELINE_VERSION_PROPERTY = "baselineVersion";
-
-	private static final List<String> PACKAGE_INCLUDES = Collections.singletonList("org.springframework.*");
-
-	private static final URI SPRING_MILESTONE_REPOSITORY = URI.create("https://repo.spring.io/milestone");
-
-	@Override
-	public void apply(Project project) {
-		if (project.hasProperty(BASELINE_VERSION_PROPERTY) && project.equals(project.getRootProject())) {
-			project.getPluginManager().apply(JapicmpPlugin.class);
-			project.getPlugins().withType(JapicmpPlugin.class,
-					plugin -> applyApiDiffConventions(project));
-		}
-	}
-
-	private void applyApiDiffConventions(Project project) {
-		String baselineVersion = project.property(BASELINE_VERSION_PROPERTY).toString();
-		project.subprojects(subProject -> {
-			if (subProject.getName().startsWith("spring-")) {
-				createApiDiffTask(baselineVersion, subProject);
-			}
-		});
-	}
-
-	private void createApiDiffTask(String baselineVersion, Project project) {
-		if (isProjectEligible(project)) {
-			// Add Spring Milestone repository for generating diffs against previous milestones
-			project.getRootProject()
-					.getRepositories()
-					.maven(mavenArtifactRepository -> mavenArtifactRepository.setUrl(SPRING_MILESTONE_REPOSITORY));
-			JapicmpTask apiDiff = project.getTasks().create(TASK_NAME, JapicmpTask.class);
-			apiDiff.setDescription("Generates an API diff report with japicmp");
-			apiDiff.setGroup(JavaBasePlugin.DOCUMENTATION_GROUP);
-
-			apiDiff.setOldClasspath(createBaselineConfiguration(baselineVersion, project));
-			TaskProvider<Jar> jar = project.getTasks().withType(Jar.class).named("jar");
-			apiDiff.setNewArchives(project.getLayout().files(jar.get().getArchiveFile().get().getAsFile()));
-			apiDiff.setNewClasspath(getRuntimeClassPath(project));
-			apiDiff.setPackageIncludes(PACKAGE_INCLUDES);
-			apiDiff.setOnlyModified(true);
-			apiDiff.setIgnoreMissingClasses(true);
-			// Ignore Kotlin metadata annotations since they contain
-			// illegal HTML characters and fail the report generation
-			apiDiff.setAnnotationExcludes(Collections.singletonList("@kotlin.Metadata"));
-
-			apiDiff.setHtmlOutputFile(getOutputFile(baselineVersion, project));
-
-			apiDiff.dependsOn(project.getTasks().getByName("jar"));
-		}
-	}
-
-	private boolean isProjectEligible(Project project) {
-		return project.getPlugins().hasPlugin(JavaPlugin.class)
-				&& project.getPlugins().hasPlugin(MavenPublishPlugin.class);
-	}
-
-	private Configuration createBaselineConfiguration(String baselineVersion, Project project) {
-		String baseline = String.join(":",
-				project.getGroup().toString(), project.getName(), baselineVersion);
-		Dependency baselineDependency = project.getDependencies().create(baseline + "@jar");
-		Configuration baselineConfiguration = project.getRootProject().getConfigurations().detachedConfiguration(baselineDependency);
-		try {
-			// eagerly resolve the baseline configuration to check whether this is a new Spring module
-			baselineConfiguration.resolve();
-			return baselineConfiguration;
-		}
-		catch (GradleException exception) {
-			logger.warn("Could not resolve {} - assuming this is a new Spring module.", baseline);
-		}
-		return project.getRootProject().getConfigurations().detachedConfiguration();
-	}
-
-	private Configuration getRuntimeClassPath(Project project) {
-		return project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME);
-	}
-
-	private File getOutputFile(String baseLineVersion, Project project) {
-		Path outDir = Paths.get(project.getRootProject().getBuildDir().getAbsolutePath(),
-				"reports", "api-diff",
-				baseLineVersion + "_to_" + project.getRootProject().getVersion());
-		return project.file(outDir.resolve(project.getName() + ".html").toString());
-	}
-
-}

ci/README.adoc

@@ -1,57 +0,0 @@
-== Spring Framework Concourse pipeline
-
-The Spring Framework uses https://concourse-ci.org/[Concourse] for its CI build and other automated tasks.
-The Spring team has a dedicated Concourse instance available at https://ci.spring.io with a build pipeline
-for https://ci.spring.io/teams/spring-framework/pipelines/spring-framework-6.0.x[Spring Framework 6.0.x].
-
-=== Setting up your development environment
-
-If you're part of the Spring Framework project on GitHub, you can get access to CI management features.
-First, you need to go to https://ci.spring.io and install the client CLI for your platform (see bottom right of the screen).
-
-You can then login with the instance using:
-
-[source]
-----
-$ fly -t spring login -n spring-framework -c https://ci.spring.io
-----
-
-Once logged in, you should get something like:
-
-[source]
-----
-$ fly ts
-name                  url                   team                  expiry
-spring                https://ci.spring.io  spring-framework      Wed, 25 Mar 2020 17:45:26 UTC
-----
-
-=== Pipeline configuration and structure
-
-The build pipelines are described in `pipeline.yml` file.
-
-This file is listing Concourse resources, i.e. build inputs and outputs such as container images, artifact repositories, source repositories, notification services, etc.
-
-It also describes jobs (a job is a sequence of inputs, tasks and outputs); jobs are organized by groups.
-
-The `pipeline.yml` definition contains `((parameters))` which are loaded from the `parameters.yml` file or from our https://docs.cloudfoundry.org/credhub/[credhub instance].
-
-You'll find in this folder the following resources:
-
-* `pipeline.yml` the build pipeline
-* `parameters.yml` the build parameters used for the pipeline
-* `images/` holds the container images definitions used in this pipeline
-* `scripts/` holds the build scripts that ship within the CI container images
-* `tasks` contains the task definitions used in the main `pipeline.yml`
-
-=== Updating the build pipeline
-
-Updating files on the repository is not enough to update the build pipeline, as changes need to be applied.
-
-The pipeline can be deployed using the following command:
-
-[source]
-----
-$ fly -t spring set-pipeline -p spring-framework-6.0.x -c ci/pipeline.yml -l ci/parameters.yml
-----
-
-NOTE: This assumes that you have credhub integration configured with the appropriate secrets.

ci/config/release-scripts.yml

@@ -1,10 +0,0 @@
-logging:
-  level:
-    io.spring.concourse: DEBUG
-spring:
-  main:
-    banner-mode: off
-sonatype:
-  exclude:
-    - 'build-info\.json'
-    - '.*\.zip'

ci/images/README.adoc

@@ -1,21 +0,0 @@
-== CI Images
-
-These images are used by CI to run the actual builds.
-
-To build the image locally run the following from this directory:
-
-----
-$ docker build --no-cache -f <image-folder>/Dockerfile .
-----
-
-For example
-
-----
-$ docker build --no-cache -f spring-framework-ci-image/Dockerfile .
-----
-
-To test run:
-
-----
-$ docker run -it --entrypoint /bin/bash <SHA>
-----

ci/images/ci-image/Dockerfile

@@ -1,11 +0,0 @@
-FROM ubuntu:focal-20220922
-
-ADD setup.sh /setup.sh
-ADD get-jdk-url.sh /get-jdk-url.sh
-RUN ./setup.sh
-
-ENV JAVA_HOME /opt/openjdk/java17
-ENV JDK17 /opt/openjdk/java17
-ENV JDK20 /opt/openjdk/java20
-
-ENV PATH $JAVA_HOME/bin:$PATH

ci/images/get-jdk-url.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-set -e
-
-case "$1" in
-	java17)
-		echo "https://github.com/bell-sw/Liberica/releases/download/17.0.6+10/bellsoft-jdk17.0.6+10-linux-amd64.tar.gz"
-	;;
-	java20)
-		echo "https://github.com/bell-sw/Liberica/releases/download/20%2B37/bellsoft-jdk20+37-linux-amd64.tar.gz"
-	;;
-	*)
-		echo $"Unknown java version"
-		exit 1
-esac

ci/images/setup.sh

@@ -1,40 +0,0 @@
-#!/bin/bash
-set -ex
-
-###########################################################
-# UTILS
-###########################################################
-
-export DEBIAN_FRONTEND=noninteractive
-apt-get update
-apt-get install --no-install-recommends -y tzdata ca-certificates net-tools libxml2-utils git curl libudev1 libxml2-utils iptables iproute2 jq fontconfig
-ln -fs /usr/share/zoneinfo/UTC /etc/localtime
-dpkg-reconfigure --frontend noninteractive tzdata
-rm -rf /var/lib/apt/lists/*
-
-curl https://raw.githubusercontent.com/spring-io/concourse-java-scripts/v0.0.4/concourse-java.sh > /opt/concourse-java.sh
-
-###########################################################
-# JAVA
-###########################################################
-
-mkdir -p /opt/openjdk
-pushd /opt/openjdk > /dev/null
-for jdk in java17 java20
-do
-  JDK_URL=$( /get-jdk-url.sh $jdk )
-  mkdir $jdk
-  pushd $jdk > /dev/null
-  curl -L ${JDK_URL} | tar zx --strip-components=1
-  test -f bin/java
-  test -f bin/javac
-  popd > /dev/null
-done
-popd
-
-###########################################################
-# GRADLE ENTERPRISE
-###########################################################
-cd /
-mkdir ~/.gradle
-echo 'systemProp.user.name=concourse' > ~/.gradle/gradle.properties

ci/parameters.yml

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

ci/pipeline.yml

@@ -1,450 +0,0 @@
-anchors:
-  git-repo-resource-source: &git-repo-resource-source
-    uri: ((github-repo))
-    username: ((github-username))
-    password: ((github-ci-release-token))
-    branch: ((branch))
-  gradle-enterprise-task-params: &gradle-enterprise-task-params
-    GRADLE_ENTERPRISE_ACCESS_KEY: ((gradle_enterprise_secret_access_key))
-    GRADLE_ENTERPRISE_CACHE_USERNAME: ((gradle_enterprise_cache_user.username))
-    GRADLE_ENTERPRISE_CACHE_PASSWORD: ((gradle_enterprise_cache_user.password))
-  sonatype-task-params: &sonatype-task-params
-    SONATYPE_USERNAME: ((sonatype-username))
-    SONATYPE_PASSWORD: ((sonatype-password))
-    SONATYPE_URL: ((sonatype-url))
-    SONATYPE_STAGING_PROFILE: ((sonatype-staging-profile))
-  artifactory-task-params: &artifactory-task-params
-    ARTIFACTORY_SERVER: ((artifactory-server))
-    ARTIFACTORY_USERNAME: ((artifactory-username))
-    ARTIFACTORY_PASSWORD: ((artifactory-password))
-  build-project-task-params: &build-project-task-params
-      BRANCH: ((branch))
-      <<: *gradle-enterprise-task-params
-  docker-resource-source: &docker-resource-source
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
-  slack-fail-params: &slack-fail-params
-    text: >
-      :concourse-failed: <https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}|${BUILD_PIPELINE_NAME} ${BUILD_JOB_NAME} failed!>
-      [$TEXT_FILE_CONTENT]
-    text_file: git-repo/build/build-scan-uri.txt
-    silent: true
-    icon_emoji: ":concourse:"
-    username: concourse-ci
-  changelog-task-params: &changelog-task-params
-    name: generated-changelog/tag
-    tag: generated-changelog/tag
-    body: generated-changelog/changelog.md
-  github-task-params: &github-task-params
-    GITHUB_USERNAME: ((github-username))
-    GITHUB_TOKEN: ((github-ci-release-token))
-
-resource_types:
-- name: registry-image
-  type: registry-image
-  source:
-    <<: *docker-resource-source
-    repository: concourse/registry-image-resource
-    tag: 1.5.0
-- name: artifactory-resource
-  type: registry-image
-  source:
-    <<: *docker-resource-source
-    repository: springio/artifactory-resource
-    tag: 0.0.18
-- name: github-release
-  type: registry-image
-  source:
-    <<: *docker-resource-source
-    repository: concourse/github-release-resource
-    tag: 1.5.5
-- name: github-status-resource
-  type: registry-image
-  source:
-    <<: *docker-resource-source
-    repository: dpb587/github-status-resource
-    tag: master
-- name: pull-request
-  type: registry-image
-  source:
-    <<: *docker-resource-source
-    repository: teliaoss/github-pr-resource
-    tag: v0.23.0
-- name: slack-notification
-  type: registry-image
-  source:
-    <<: *docker-resource-source
-    repository: cfcommunity/slack-notification-resource
-    tag: latest
-resources:
-- name: git-repo
-  type: git
-  icon: github
-  source:
-    <<: *git-repo-resource-source
-- name: ci-images-git-repo
-  type: git
-  icon: github
-  source:
-    uri: ((github-repo))
-    branch: ((branch))
-    paths: ["ci/images/*"]
-- name: ci-image
-  type: registry-image
-  icon: docker
-  source:
-    <<: *docker-resource-source
-    repository: ((docker-hub-organization))/spring-framework-ci
-    tag: ((milestone))
-- name: every-morning
-  type: time
-  icon: alarm
-  source:
-    start: 8:00 AM
-    stop: 9:00 AM
-    location: Europe/Vienna
-- name: artifactory-repo
-  type: artifactory-resource
-  icon: package-variant
-  source:
-    uri: ((artifactory-server))
-    username: ((artifactory-username))
-    password: ((artifactory-password))
-    build_name: ((build-name))
-- name: git-pull-request
-  type: pull-request
-  icon: source-pull
-  source:
-    access_token: ((github-ci-pull-request-token))
-    repository: ((github-repo-name))
-    base_branch: ((branch))
-    ignore_paths: ["ci/*"]
-- name: repo-status-build
-  type: github-status-resource
-  icon: eye-check-outline
-  source:
-    repository: ((github-repo-name))
-    access_token: ((github-ci-status-token))
-    branch: ((branch))
-    context: build
-- name: repo-status-jdk20-build
-  type: github-status-resource
-  icon: eye-check-outline
-  source:
-    repository: ((github-repo-name))
-    access_token: ((github-ci-status-token))
-    branch: ((branch))
-    context: jdk20-build
-- name: slack-alert
-  type: slack-notification
-  icon: slack
-  source:
-    url: ((slack-webhook-url))
-- name: github-pre-release
-  type: github-release
-  icon: briefcase-download-outline
-  source:
-    owner: spring-projects
-    repository: spring-framework
-    access_token: ((github-ci-release-token))
-    pre_release: true
-    release: false
-- name: github-release
-  type: github-release
-  icon: briefcase-download
-  source:
-    owner: spring-projects
-    repository: spring-framework
-    access_token: ((github-ci-release-token))
-    pre_release: false
-jobs:
-- name: build-ci-images
-  plan:
-    - get: git-repo
-    - get: ci-images-git-repo
-      trigger: true
-    - task: build-ci-image
-      privileged: true
-      file: git-repo/ci/tasks/build-ci-image.yml
-      output_mapping:
-        image: ci-image
-      vars:
-        ci-image-name: ci-image
-        <<: *docker-resource-source
-    - put: ci-image
-      params:
-        image: ci-image/image.tar
-- name: build
-  serial: true
-  public: true
-  plan:
-  - get: ci-image
-  - get: git-repo
-    trigger: true
-  - put: repo-status-build
-    params: { state: "pending", commit: "git-repo" }
-  - do:
-    - task: build-project
-      image: ci-image
-      file: git-repo/ci/tasks/build-project.yml
-      privileged: true
-      timeout: ((task-timeout))
-      params:
-        <<: *build-project-task-params
-    on_failure:
-      do:
-      - put: repo-status-build
-        params: { state: "failure", commit: "git-repo" }
-      - put: slack-alert
-        params:
-          <<: *slack-fail-params
-  - put: repo-status-build
-    params: { state: "success", commit: "git-repo" }
-  - put: artifactory-repo
-    params: &artifactory-params
-      signing_key: ((signing-key))
-      signing_passphrase: ((signing-passphrase))
-      repo: libs-snapshot-local
-      folder: distribution-repository
-      build_uri: "https://ci.spring.io/teams/${BUILD_TEAM_NAME}/pipelines/${BUILD_PIPELINE_NAME}/jobs/${BUILD_JOB_NAME}/builds/${BUILD_NAME}"
-      build_number: "${BUILD_PIPELINE_NAME}-${BUILD_JOB_NAME}-${BUILD_NAME}"
-      disable_checksum_uploads: true
-      threads: 8
-      artifact_set:
-      - include:
-        - "/**/framework-docs-*.zip"
-        properties:
-          "zip.name": "spring-framework"
-          "zip.displayname": "Spring Framework"
-          "zip.deployed": "false"
-      - include:
-        - "/**/framework-docs-*-docs.zip"
-        properties:
-          "zip.type": "docs"
-      - include:
-        - "/**/framework-docs-*-dist.zip"
-        properties:
-          "zip.type": "dist"
-      - include:
-        - "/**/framework-docs-*-schema.zip"
-        properties:
-          "zip.type": "schema"
-    get_params:
-      threads: 8
-- name: jdk20-build
-  serial: true
-  public: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-    - get: every-morning
-      trigger: true
-    - put: repo-status-jdk20-build
-      params: { state: "pending", commit: "git-repo" }
-    - do:
-        - task: check-project
-          image: ci-image
-          file: git-repo/ci/tasks/check-project.yml
-          privileged: true
-          timeout: ((task-timeout))
-          params:
-            TEST_TOOLCHAIN: 20
-            <<: *build-project-task-params
-      on_failure:
-        do:
-          - put: repo-status-jdk20-build
-            params: { state: "failure", commit: "git-repo" }
-          - put: slack-alert
-            params:
-              <<: *slack-fail-params
-    - put: repo-status-jdk20-build
-      params: { state: "success", commit: "git-repo" }
-- name: build-pull-requests
-  serial: true
-  public: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      resource: git-pull-request
-      trigger: true
-      version: every
-    - do:
-      - put: git-pull-request
-        params:
-          path: git-repo
-          status: pending
-      - task: build-pr
-        image: ci-image
-        file: git-repo/ci/tasks/build-pr.yml
-        privileged: true
-        timeout: ((task-timeout))
-        params:
-          BRANCH: ((branch))
-      on_success:
-        put: git-pull-request
-        params:
-          path: git-repo
-          status: success
-      on_failure:
-        put: git-pull-request
-        params:
-          path: git-repo
-          status: failure
-- name: stage-milestone
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      trigger: false
-    - task: stage
-      image: ci-image
-      file: git-repo/ci/tasks/stage-version.yml
-      params:
-        RELEASE_TYPE: M
-        <<: *gradle-enterprise-task-params
-    - put: artifactory-repo
-      params:
-        <<: *artifactory-params
-        repo: libs-staging-local
-    - put: git-repo
-      params:
-        repository: stage-git-repo
-- name: promote-milestone
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      trigger: false
-    - get: artifactory-repo
-      trigger: false
-      passed: [stage-milestone]
-      params:
-        download_artifacts: false
-        save_build_info: true
-    - task: promote
-      file: git-repo/ci/tasks/promote-version.yml
-      params:
-        RELEASE_TYPE: M
-        <<: *artifactory-task-params
-    - task: generate-changelog
-      file: git-repo/ci/tasks/generate-changelog.yml
-      params:
-        RELEASE_TYPE: M
-        <<: *github-task-params
-        <<: *docker-resource-source
-    - put: github-pre-release
-      params:
-        <<: *changelog-task-params
-- name: stage-rc
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      trigger: false
-    - task: stage
-      image: ci-image
-      file: git-repo/ci/tasks/stage-version.yml
-      params:
-        RELEASE_TYPE: RC
-        <<: *gradle-enterprise-task-params
-    - put: artifactory-repo
-      params:
-        <<: *artifactory-params
-        repo: libs-staging-local
-    - put: git-repo
-      params:
-        repository: stage-git-repo
-- name: promote-rc
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      trigger: false
-    - get: artifactory-repo
-      trigger: false
-      passed: [stage-rc]
-      params:
-        download_artifacts: false
-        save_build_info: true
-    - task: promote
-      file: git-repo/ci/tasks/promote-version.yml
-      params:
-        RELEASE_TYPE: RC
-        <<: *docker-resource-source
-        <<: *artifactory-task-params
-    - task: generate-changelog
-      file: git-repo/ci/tasks/generate-changelog.yml
-      params:
-        RELEASE_TYPE: RC
-        <<: *github-task-params
-    - put: github-pre-release
-      params:
-        <<: *changelog-task-params
-- name: stage-release
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      trigger: false
-    - task: stage
-      image: ci-image
-      file: git-repo/ci/tasks/stage-version.yml
-      params:
-        RELEASE_TYPE: RELEASE
-        <<: *gradle-enterprise-task-params
-    - put: artifactory-repo
-      params:
-        <<: *artifactory-params
-        repo: libs-staging-local
-    - put: git-repo
-      params:
-        repository: stage-git-repo
-- name: promote-release
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-      trigger: false
-    - get: artifactory-repo
-      trigger: false
-      passed: [stage-release]
-      params:
-        download_artifacts: true
-        save_build_info: true
-    - task: promote
-      file: git-repo/ci/tasks/promote-version.yml
-      params:
-        RELEASE_TYPE: RELEASE
-        <<: *docker-resource-source
-        <<: *artifactory-task-params
-        <<: *sonatype-task-params
-- name: create-github-release
-  serial: true
-  plan:
-    - get: ci-image
-    - get: git-repo
-    - get: artifactory-repo
-      trigger: true
-      passed: [promote-release]
-      params:
-        download_artifacts: false
-        save_build_info: true
-    - task: generate-changelog
-      file: git-repo/ci/tasks/generate-changelog.yml
-      params:
-        RELEASE_TYPE: RELEASE
-        <<: *docker-resource-source
-        <<: *github-task-params
-    - put: github-release
-      params:
-        <<: *changelog-task-params
-
-groups:
-- name: "builds"
-  jobs: ["build", "jdk20-build"]
-- name: "releases"
-  jobs: ["stage-milestone", "stage-rc", "stage-release", "promote-milestone", "promote-rc", "promote-release", "create-github-release"]
-- name: "ci-images"
-  jobs: ["build-ci-images"]
-- name: "pull-requests"
-  jobs: [ "build-pull-requests" ]

ci/scripts/build-pr.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-set -e
-
-source $(dirname $0)/common.sh
-
-pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 check
-popd > /dev/null

ci/scripts/build-project.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-set -e
-
-source $(dirname $0)/common.sh
-repository=$(pwd)/distribution-repository
-
-pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
-popd > /dev/null

ci/scripts/check-project.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-set -e
-
-source $(dirname $0)/common.sh
-
-pushd git-repo > /dev/null
-./gradlew -Dorg.gradle.internal.launcher.welcomeMessageEnabled=false -Porg.gradle.java.installations.fromEnv=JDK17,JDK20 \
-  -PmainToolchain=${MAIN_TOOLCHAIN} -PtestToolchain=${TEST_TOOLCHAIN} --no-daemon --max-workers=4 check
-popd > /dev/null

ci/scripts/common.sh

@@ -1,2 +0,0 @@
-source /opt/concourse-java.sh
-setup_symlinks

ci/scripts/generate-changelog.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-set -e
-
-CONFIG_DIR=git-repo/ci/config
-version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
-
-java -jar /github-changelog-generator.jar \
-  --spring.config.location=${CONFIG_DIR}/changelog-generator.yml \
-  ${version} generated-changelog/changelog.md
-
-echo ${version} > generated-changelog/version
-echo v${version} > generated-changelog/tag

ci/scripts/promote-version.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-
-CONFIG_DIR=git-repo/ci/config
-
-version=$( cat artifactory-repo/build-info.json | jq -r '.buildInfo.modules[0].id' | sed 's/.*:.*:\(.*\)/\1/' )
-export BUILD_INFO_LOCATION=$(pwd)/artifactory-repo/build-info.json
-
-java -jar /concourse-release-scripts.jar \
-  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
-  publishToCentral $RELEASE_TYPE $BUILD_INFO_LOCATION artifactory-repo || { exit 1; }
-
-java -jar /concourse-release-scripts.jar \
-  --spring.config.location=${CONFIG_DIR}/release-scripts.yml \
-  promote $RELEASE_TYPE $BUILD_INFO_LOCATION || { exit 1; }
-
-echo "Promotion complete"
-echo $version > version/version

ci/scripts/stage-version.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-set -e
-
-source $(dirname $0)/common.sh
-repository=$(pwd)/distribution-repository
-
-pushd git-repo > /dev/null
-git fetch --tags --all > /dev/null
-popd > /dev/null
-
-git clone git-repo stage-git-repo > /dev/null
-
-pushd stage-git-repo > /dev/null
-
-snapshotVersion=$( awk -F '=' '$1 == "version" { print $2 }' gradle.properties )
-if [[ $RELEASE_TYPE = "M" ]]; then
-	stageVersion=$( get_next_milestone_release $snapshotVersion)
-	nextVersion=$snapshotVersion
-elif [[ $RELEASE_TYPE = "RC" ]]; then
-	stageVersion=$( get_next_rc_release $snapshotVersion)
-	nextVersion=$snapshotVersion
-elif [[ $RELEASE_TYPE = "RELEASE" ]]; then
-	stageVersion=$( get_next_release $snapshotVersion)
-	nextVersion=$( bump_version_number $snapshotVersion)
-else
-	echo "Unknown release type $RELEASE_TYPE" >&2; exit 1;
-fi
-
-echo "Staging $stageVersion (next version will be $nextVersion)"
-sed -i "s/version=$snapshotVersion/version=$stageVersion/" gradle.properties
-
-git config user.name "Spring Builds" > /dev/null
-git config user.email "spring-builds@users.noreply.github.com" > /dev/null
-git add gradle.properties > /dev/null
-git commit -m"Release v$stageVersion" > /dev/null
-git tag -a "v$stageVersion" -m"Release v$stageVersion" > /dev/null
-
-./gradlew --no-daemon --max-workers=4 -PdeploymentRepository=${repository} build publishAllPublicationsToDeploymentRepository
-
-git reset --hard HEAD^ > /dev/null
-if [[ $nextVersion != $snapshotVersion ]]; then
-	echo "Setting next development version (v$nextVersion)"
-	sed -i "s/version=$snapshotVersion/version=$nextVersion/" gradle.properties
-	git add gradle.properties > /dev/null
-	git commit -m"Next development version (v$nextVersion)" > /dev/null
-fi;
-
-echo "Staging Complete"
-
-popd > /dev/null

ci/tasks/build-ci-image.yml

@@ -1,30 +0,0 @@
----
-platform: linux
-image_resource:
-  type: registry-image
-  source:
-    repository: concourse/oci-build-task
-    tag: 0.10.0
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
-inputs:
-  - name: ci-images-git-repo
-outputs:
-  - name: image
-caches:
-  - path: ci-image-cache
-params:
-  CONTEXT: ci-images-git-repo/ci/images
-  DOCKERFILE: ci-images-git-repo/ci/images/ci-image/Dockerfile
-  DOCKER_HUB_AUTH: ((docker-hub-auth))
-run:
-  path: /bin/sh
-  args:
-    - "-c"
-    - |
-      mkdir -p /root/.docker
-      cat > /root/.docker/config.json <<EOF
-      { "auths": { "https://index.docker.io/v1/": { "auth": "$DOCKER_HUB_AUTH" }}}
-      EOF
-      build
-

ci/tasks/build-pr.yml

@@ -1,19 +0,0 @@
----
-platform: linux
-inputs:
-- name: git-repo
-caches:
-- path: gradle
-params:
-  BRANCH:
-  CI: true
-  GRADLE_ENTERPRISE_ACCESS_KEY:
-  GRADLE_ENTERPRISE_CACHE_USERNAME:
-  GRADLE_ENTERPRISE_CACHE_PASSWORD:
-  GRADLE_ENTERPRISE_URL: https://ge.spring.io
-run:
-  path: bash
-  args:
-    - -ec
-    - |
-      ${PWD}/git-repo/ci/scripts/build-pr.sh

ci/tasks/build-project.yml

@@ -1,22 +0,0 @@
----
-platform: linux
-inputs:
-- name: git-repo
-outputs:
-- name: distribution-repository
-- name: git-repo
-caches:
-- path: gradle
-params:
-  BRANCH:
-  CI: true
-  GRADLE_ENTERPRISE_ACCESS_KEY:
-  GRADLE_ENTERPRISE_CACHE_USERNAME:
-  GRADLE_ENTERPRISE_CACHE_PASSWORD:
-  GRADLE_ENTERPRISE_URL: https://ge.spring.io
-run:
-  path: bash
-  args:
-    - -ec
-    - |
-      ${PWD}/git-repo/ci/scripts/build-project.sh

ci/tasks/check-project.yml

@@ -1,24 +0,0 @@
----
-platform: linux
-inputs:
-- name: git-repo
-outputs:
-- name: distribution-repository
-- name: git-repo
-caches:
-- path: gradle
-params:
-  BRANCH:
-  CI: true
-  MAIN_TOOLCHAIN:
-  TEST_TOOLCHAIN:
-  GRADLE_ENTERPRISE_ACCESS_KEY:
-  GRADLE_ENTERPRISE_CACHE_USERNAME:
-  GRADLE_ENTERPRISE_CACHE_PASSWORD:
-  GRADLE_ENTERPRISE_URL: https://ge.spring.io
-run:
-  path: bash
-  args:
-    - -ec
-    - |
-      ${PWD}/git-repo/ci/scripts/check-project.sh

ci/tasks/generate-changelog.yml

@@ -1,22 +0,0 @@
----
-platform: linux
-image_resource:
-  type: registry-image
-  source:
-    repository: springio/github-changelog-generator
-    tag: '0.0.8'
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
-inputs:
-- name: git-repo
-- name: artifactory-repo
-outputs:
-- name: generated-changelog
-params:
-  GITHUB_ORGANIZATION:
-  GITHUB_REPO:
-  GITHUB_USERNAME:
-  GITHUB_TOKEN:
-  RELEASE_TYPE:
-run:
-  path: git-repo/ci/scripts/generate-changelog.sh

ci/tasks/promote-version.yml

@@ -1,25 +0,0 @@
----
-platform: linux
-image_resource:
-  type: registry-image
-  source:
-    repository: springio/concourse-release-scripts
-    tag: '0.3.4'
-    username: ((docker-hub-username))
-    password: ((docker-hub-password))
-inputs:
-- name: git-repo
-- name: artifactory-repo
-outputs:
-- name: version
-params:
-  RELEASE_TYPE:
-  ARTIFACTORY_SERVER:
-  ARTIFACTORY_USERNAME:
-  ARTIFACTORY_PASSWORD:
-  SONATYPE_USER:
-  SONATYPE_PASSWORD:
-  SONATYPE_URL:
-  SONATYPE_STAGING_PROFILE:
-run:
-  path: git-repo/ci/scripts/promote-version.sh

ci/tasks/stage-version.yml

@@ -1,17 +0,0 @@
----
-platform: linux
-inputs:
-- name: git-repo
-outputs:
-- name: stage-git-repo
-- name: distribution-repository
-params:
-  RELEASE_TYPE:
-  CI: true
-  GRADLE_ENTERPRISE_CACHE_USERNAME:
-  GRADLE_ENTERPRISE_CACHE_PASSWORD:
-  GRADLE_ENTERPRISE_URL: https://ge.spring.io
-caches:
-- path: gradle
-run:
-  path: git-repo/ci/scripts/stage-version.sh

framework-docs/antora-playbook.yml

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

framework-docs/antora.yml

@@ -0,0 +1,32 @@
+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'
+    include-java: 'example$docs-src/main/java/org/springframework/docs'
+    spring-framework-main-code: 'https://github.com/spring-projects/spring-framework/tree/main'
+    docs-site: 'https://docs.spring.io'
+    docs-spring: "{docs-site}/spring-framework/docs/{spring-version}"
+    docs-spring-framework: '{docs-site}/spring-framework/docs/{spring-version}'
+    api-spring-framework: '{docs-spring-framework}/javadoc-api/org/springframework'
+    docs-graalvm: 'https://www.graalvm.org/22.3/reference-manual'
+    docs-spring-boot: '{docs-site}/spring-boot/docs/current/reference'
+    docs-spring-gemfire: '{docs-site}/spring-gemfire/docs/current/reference'
+    docs-spring-security: '{docs-site}/spring-security/reference'
+    gh-rsocket: 'https://github.com/rsocket'
+    gh-rsocket-extensions: '{gh-rsocket}/rsocket/blob/master/Extensions'
+    gh-rsocket-java: '{gh-rsocket}/rsocket-java{gh-rsocket}/rsocket-java'

framework-docs/framework-docs.gradle

@@ -1,24 +1,39 @@
+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 plugin: 'kotlin'
-apply plugin: 'org.asciidoctor.jvm.convert'
-apply plugin: 'org.asciidoctor.jvm.pdf'
 apply from: "${rootDir}/gradle/publications.gradle"
 
 
-configurations {
-	asciidoctorExtensions
+antora {
+	options = [clean: true, fetch: !project.gradle.startParameter.offline, stacktrace: true]
+	environment = [
+			'BUILD_REFNAME': 'HEAD',
+			'BUILD_VERSION': project.version,
+	]
 }
 
-dependencies {
-	api(project(":spring-context"))
-	api(project(":spring-web"))
-	api("jakarta.servlet:jakarta.servlet-api")
 
-	implementation(project(":spring-core-test"))
-	implementation("org.assertj:assertj-core")
+tasks.named("generateAntoraYml") {
+	asciidocAttributes = project.provider( {
+		return  ["spring-version": project.version ]
+	} )
 }
 
+tasks.create("generateAntoraResources") {
+	dependsOn 'generateAntoraYml'
+}
+
+// Commented out for now:
+// https://github.com/spring-projects/spring-framework/issues/30481
+// tasks.named("check") {
+//	dependsOn 'antora'
+// }
+
 jar {
 	enabled = false
 }
@@ -27,8 +42,19 @@ javadoc {
 	enabled = false
 }
 
+repositories {
+	maven {
+		url "https://repo.spring.io/release"
+	}
+}
+
 dependencies {
-	asciidoctorExtensions "io.spring.asciidoctor.backends:spring-asciidoctor-backends:0.0.5"
+	api(project(":spring-context"))
+	api(project(":spring-web"))
+	api("jakarta.servlet:jakarta.servlet-api")
+
+	implementation(project(":spring-core-test"))
+	implementation("org.assertj:assertj-core")
 }
 
 /**
@@ -61,7 +87,7 @@ task api(type: Javadoc) {
 		overview = "framework-docs/src/docs/api/overview.html"
 		splitIndex = true
 		links(project.ext.javadocLinks)
-		addBooleanOption('Xdoclint:syntax', true) // only check syntax with doclint
+		addBooleanOption('Xdoclint:syntax,reference', true) // only check syntax and reference with doclint
 		addBooleanOption('Werror', true) // fail build on Javadoc warnings
 	}
 	source moduleProjects.collect { project ->
@@ -82,69 +108,10 @@ rootProject.tasks.dokkaHtmlMultiModule.configure {
 	outputDirectory.set(project.file("$buildDir/docs/kdoc"))
 }
 
-asciidoctorj {
-	version = '2.4.3'
-	fatalWarnings ".*"
-	options doctype: 'book', eruby: 'erubis'
-	attributes([
-			icons: 'font',
-			idprefix: '',
-			idseparator: '-',
-			revnumber: project.version,
-			sectanchors: '',
-			sectnums: '',
-			'spring-version': project.version
-	])
-}
-
 /**
- * Generate the Spring Framework Reference documentation from
- * "src/docs/asciidoc" in "build/docs/ref-docs/html5".
+ * Zip all Java docs (javadoc & kdoc) into a single archive
  */
-asciidoctor {
-	baseDirFollowsSourceDir()
-	configurations "asciidoctorExtensions"
-	sources {
-		include '*.adoc'
-	}
-	resources {
-		from(sourceDir) {
-			include 'images/*.png'
-		}
-	}
-	outputDir "$buildDir/docs/ref-docs/html5"
-	outputOptions {
-		backends "spring-html"
-	}
-	forkOptions {
-		jvmArgs += ["--add-opens", "java.base/sun.nio.ch=ALL-UNNAMED", "--add-opens", "java.base/java.io=ALL-UNNAMED"]
-	}
-	logDocuments = true
-}
-
-asciidoctor.mustRunAfter "check"
-
-/**
- * Generate the Spring Framework Reference documentation from "src/docs/asciidoc"
- * in "build/docs/ref-docs/pdf".
- */
-asciidoctorPdf {
-	baseDirFollowsSourceDir()
-	configurations 'asciidoctorExtensions'
-	sources {
-		include 'spring-framework.adocbook'
-	}
-	outputDir "$buildDir/docs/ref-docs/pdf"
-	forkOptions {
-		jvmArgs += ["--add-opens", "java.base/sun.nio.ch=ALL-UNNAMED", "--add-opens", "java.base/java.io=ALL-UNNAMED"]
-	}
-	logDocuments = true
-}
-
-/**
- * Zip all docs (API and reference) into a single archive
- */
-task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', rootProject.tasks.dokkaHtmlMultiModule]) {
+task docsZip(type: Zip, dependsOn: ['api', rootProject.tasks.dokkaHtmlMultiModule]) {
 	group = "Distribution"
 	description = "Builds -${archiveClassifier} archive containing api and reference " +
 			"for deployment at https://docs.spring.io/spring-framework/docs/."
@@ -157,12 +124,6 @@ task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', root
 	from (api) {
 		into "javadoc-api"
 	}
-	from ("$asciidoctor.outputDir") {
-		into "reference/html"
-	}
-	from ("$asciidoctorPdf.outputDir") {
-		into "reference/pdf"
-	}
 	from (rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {
 		into "kdoc-api"
 	}
@@ -251,4 +212,4 @@ publishing {
 			artifact distZip
 		}
 	}
-}
+}

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

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

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

framework-docs/modules/ROOT/nav.adoc

@@ -0,0 +1,434 @@
+* 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/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/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-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-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-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-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/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[]
+* https://github.com/spring-projects/spring-framework/wiki[Wiki]

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

@@ -1,7 +1,5 @@
 [[appendix]]
 = Appendix
-include::attributes.adoc[]
-include::page-layout.adoc[]
 
 This part of the reference documentation covers topics that apply to multiple modules
 within the core Spring Framework.
@@ -27,12 +25,12 @@ The following table lists all currently supported Spring properties.
 | `spring.beaninfo.ignore`
 | Instructs Spring to use the `Introspector.IGNORE_ALL_BEANINFO` mode when calling the
 JavaBeans `Introspector`. See
-{api-spring-framework}++/beans/CachedIntrospectionResults.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
+{api-spring-framework}++/beans/StandardBeanInfoFactory.html#IGNORE_BEANINFO_PROPERTY_NAME++[`CachedIntrospectionResults`]
 for details.
 
 | `spring.expression.compiler.mode`
 | The mode to use when compiling expressions for the
-<<core.adoc#expressions-compiler-configuration, Spring Expression Language>>.
+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
@@ -43,12 +41,12 @@ for details.
 
 | `spring.index.ignore`
 | Instructs Spring to ignore the components index located in
-`META-INF/spring.components`. See <<core.adoc#beans-scanning-index, Generating an Index
-of Candidate Components>>.
+`META-INF/spring.components`. See xref:core/beans/classpath-scanning.adoc#beans-scanning-index[Generating an Index of Candidate Components]
+.
 
 | `spring.jdbc.getParameterType.ignore`
 | Instructs Spring to ignore `java.sql.ParameterMetaData.getParameterType` completely.
-See the note in <<data-access.adoc#jdbc-batch-list, Batch Operations with a List of Objects>>.
+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
@@ -64,17 +62,17 @@ for details.
 
 | `spring.test.constructor.autowire.mode`
 | The default _test constructor autowire mode_ to use if `@TestConstructor` is not present
-on a test class. See <<testing.adoc#integration-testing-annotations-testconstructor,
-Changing the default test constructor autowire mode>>.
+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
-<<testing.adoc#testcontext-ctx-management-caching, Context Caching>>.
+xref:testing/testcontext-framework/ctx-management/caching.adoc[Context Caching].
 
 | `spring.test.enclosing.configuration`
 | The default _enclosing configuration inheritance mode_ to use if
 `@NestedTestConfiguration` is not present on a test class. See
-<<testing.adoc#integration-testing-annotations-nestedtestconfiguration, Changing the
-default enclosing configuration inheritance mode>>.
+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,7 +1,5 @@
 [[spring-core]]
 = Core Technologies
-include::attributes.adoc[]
-include::page-layout.adoc[]
 
 This part of the reference documentation covers all the technologies that are
 absolutely integral to the Spring Framework.
@@ -20,24 +18,13 @@ is also provided.
 AOT processing can be used to optimize your application ahead-of-time. It is typically
 used for native image deployment using GraalVM.
 
-include::core/core-beans.adoc[leveloffset=+1]
 
-include::core/core-resources.adoc[leveloffset=+1]
 
-include::core/core-validation.adoc[leveloffset=+1]
 
-include::core/core-expressions.adoc[leveloffset=+1]
 
-include::core/core-aop.adoc[leveloffset=+1]
 
-include::core/core-aop-api.adoc[leveloffset=+1]
 
-include::core/core-null-safety.adoc[leveloffset=+1]
 
-include::core/core-databuffer-codec.adoc[leveloffset=+1]
 
-include::core/core-spring-jcl.adoc[leveloffset=+1]
 
-include::core/core-aot.adoc[leveloffset=+1]
 
-include::core/core-appendix.adoc[leveloffset=+1]

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+[[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 {api-spring-framework}/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

@@ -0,0 +1,329 @@
+[[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.
+
+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

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

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

@@ -0,0 +1,232 @@
+[[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 {api-spring-framework}/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 simply involves a call to
+`ThreadLocal.set(null)`) the resource local to the thread. Unsetting should be done in
+any case, since not unsetting it might result in problematic behavior. Spring's
+`ThreadLocal` support does this for you and should always be considered in favor of using
+`ThreadLocal` instances without other proper handling code.
+
+
+
+

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

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

@@ -0,0 +1,59 @@
+[[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 {api-spring-framework}/aop/aspectj/annotation/AspectJProxyFactory.html[javadoc] for more information.
+
+
+
+

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

@@ -0,0 +1,16 @@
+[[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
+https://www.eclipse.org/aspectj[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

@@ -0,0 +1,946 @@
+[[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 https://www.eclipse.org/aspectj/doc/released/runtime-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+.
+`LocalVariableTableParameterNameDiscoverer` :: Analyzes the local variable table available
+  in the byte code of the advice class to determine parameter names from debug information.
+  Requires that code be compiled with debug symbols (`-g:vars` at a minimum). Deprecated
+  as of Spring Framework 6.0 for removal in Spring Framework 6.1 in favor of compiling
+  code with `-parameters`. Not supported in a GraalVM native image.
+`AspectJAdviceParameterNameDiscoverer` :: Deduces parameter names from the pointcut
+  expression, `returning`, and `throwing` clauses. See the
+  {api-spring-framework}/aop/aspectj/AspectJAdviceParameterNameDiscoverer.html[javadoc]
+  for details on the algorithm used.
+
+[[aop-ataspectj-advice-params-names-explicit]]
+=== Explicit Argument Names
+
+@AspectJ advice and pointcut annotations have an optional `argNames` attribute that you
+can use to specify the argument names of the annotated method.
+
+[TIP]
+====
+If an @AspectJ aspect has been compiled by the AspectJ compiler (`ajc`) even without
+debug information, you do not need to add the `argNames` attribute, since the compiler
+retains the needed information.
+
+Similarly, if an @AspectJ aspect has been compiled with `javac` using the `-parameters`
+flag, you do not need to add the `argNames` attribute, since the compiler retains the
+needed information.
+====
+
+The following example shows how to use the `argNames` attribute:
+
+[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

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

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

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

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

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

@@ -0,0 +1,586 @@
+[[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 https://www.eclipse.org/aspectj/doc/released/progguide/index.html[AspectJ
+Programming Guide] (and, for extensions, the
+https://www.eclipse.org/aspectj/doc/released/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
+https://www.eclipse.org/aspectj/doc/released/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

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

@@ -0,0 +1,79 @@
+[[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 (advise 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

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

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

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

@@ -0,0 +1,281 @@
+[[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.
+
+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

@@ -0,0 +1,12 @@
+[[aop-resources]]
+= Further Resources
+:page-section-summary-toc: 1
+
+More information on AspectJ can be found on the https://www.eclipse.org/aspectj[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

@@ -0,0 +1,987 @@
+[[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)"/>
+----
+
+
+
+

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

@@ -0,0 +1,988 @@
+[[aop-using-aspectj]]
+= Using AspectJ with Spring Applications
+
+Everything we have covered so far in this chapter is pure Spring AOP. In this section,
+we look at how you can use the AspectJ compiler or weaver instead of or in
+addition to Spring AOP if your needs go beyond the facilities offered by Spring AOP
+alone.
+
+Spring ships with a small AspectJ aspect library, which is available stand-alone in your
+distribution as `spring-aspects.jar`. You need to add this to your classpath in order
+to use the aspects in it. xref:core/aop/using-aspectj.adoc#aop-atconfigurable[Using AspectJ to Dependency Inject Domain Objects with Spring] and xref:core/aop/using-aspectj.adoc#aop-ajlib-other[Other Spring aspects for AspectJ] discuss the
+content of this library and how you can use it. xref:core/aop/using-aspectj.adoc#aop-aj-configure[Configuring AspectJ Aspects by Using Spring IoC] discusses how to
+dependency inject AspectJ aspects that are woven using the AspectJ compiler. Finally,
+xref:core/aop/using-aspectj.adoc#aop-aj-ltw[Load-time Weaving with AspectJ in the Spring Framework] provides an introduction to load-time weaving for Spring applications
+that use AspectJ.
+
+
+
+[[aop-atconfigurable]]
+== Using AspectJ to Dependency Inject Domain Objects with Spring
+
+The Spring container instantiates and configures beans defined in your application
+context. It is also possible to ask a bean factory to configure a pre-existing
+object, given the name of a bean definition that contains the configuration to be applied.
+`spring-aspects.jar` contains an annotation-driven aspect that exploits this
+capability to allow dependency injection of any object. The support is intended to
+be used for objects created outside of the control of any container. Domain objects
+often fall into this category because they are often created programmatically with the
+`new` operator or by an ORM tool as a result of a database query.
+
+The `@Configurable` annotation marks a class as being eligible for Spring-driven
+configuration. In the simplest case, you can use purely it as a marker annotation, as the
+following example shows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
+----
+	package com.xyz.domain;
+
+	import org.springframework.beans.factory.annotation.Configurable;
+
+	@Configurable
+	public class Account {
+		// ...
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
+----
+	package com.xyz.domain
+
+	import org.springframework.beans.factory.annotation.Configurable
+
+	@Configurable
+	class Account {
+		// ...
+	}
+----
+======
+
+When used as a marker interface in this way, Spring configures new instances of the
+annotated type (`Account`, in this case) by using a bean definition (typically
+prototype-scoped) with the same name as the fully-qualified type name
+(`com.xyz.domain.Account`). Since the default name for a bean is the
+fully-qualified name of its type, a convenient way to declare the prototype definition
+is to omit the `id` attribute, as the following example shows:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<bean class="com.xyz.domain.Account" scope="prototype">
+		<property name="fundsTransferService" ref="fundsTransferService"/>
+	</bean>
+----
+
+If you want to explicitly specify the name of the prototype bean definition to use, you
+can do so directly in the annotation, as the following example shows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
+----
+	package com.xyz.domain;
+
+	import org.springframework.beans.factory.annotation.Configurable;
+
+	@Configurable("account")
+	public class Account {
+		// ...
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
+----
+	package com.xyz.domain
+
+	import org.springframework.beans.factory.annotation.Configurable
+
+	@Configurable("account")
+	class Account {
+		// ...
+	}
+----
+======
+
+Spring now looks for a bean definition named `account` and uses that as the
+definition to configure new `Account` instances.
+
+You can also use autowiring to avoid having to specify a dedicated bean definition at
+all. To have Spring apply autowiring, use the `autowire` property of the `@Configurable`
+annotation. You can specify either `@Configurable(autowire=Autowire.BY_TYPE)` or
+`@Configurable(autowire=Autowire.BY_NAME)` for autowiring by type or by name,
+respectively. As an alternative, it is preferable to specify explicit, annotation-driven
+dependency injection for your `@Configurable` beans through `@Autowired` or `@Inject`
+at the field or method level (see xref:core/beans/annotation-config.adoc[Annotation-based Container Configuration] for further details).
+
+Finally, you can enable Spring dependency checking for the object references in the newly
+created and configured object by using the `dependencyCheck` attribute (for example,
+`@Configurable(autowire=Autowire.BY_NAME,dependencyCheck=true)`). If this attribute is
+set to `true`, Spring validates after configuration that all properties (which
+are not primitives or collections) have been set.
+
+Note that using the annotation on its own does nothing. It is the
+`AnnotationBeanConfigurerAspect` in `spring-aspects.jar` that acts on the presence of
+the annotation. In essence, the aspect says, "after returning from the initialization of
+a new object of a type annotated with `@Configurable`, configure the newly created object
+using Spring in accordance with the properties of the annotation". In this context,
+"initialization" refers to newly instantiated objects (for example, objects instantiated
+with the `new` operator) as well as to `Serializable` objects that are undergoing
+deserialization (for example, through
+https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html[readResolve()]).
+
+[NOTE]
+=====
+One of the key phrases in the above paragraph is "in essence". For most cases, the
+exact semantics of "after returning from the initialization of a new object" are
+fine. In this context, "after initialization" means that the dependencies are
+injected after the object has been constructed. This means that the dependencies
+are not available for use in the constructor bodies of the class. If you want the
+dependencies to be injected before the constructor bodies run and thus be
+available for use in the body of the constructors, you need to define this on the
+`@Configurable` declaration, as follows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary"]
+----
+	@Configurable(preConstruction = true)
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary"]
+----
+	@Configurable(preConstruction = true)
+----
+======
+
+You can find more information about the language semantics of the various pointcut
+types in AspectJ
+https://www.eclipse.org/aspectj/doc/next/progguide/semantics-joinPoints.html[in this
+appendix] of the https://www.eclipse.org/aspectj/doc/next/progguide/index.html[AspectJ
+Programming Guide].
+=====
+
+For this to work, the annotated types must be woven with the AspectJ weaver. You can
+either use a build-time Ant or Maven task to do this (see, for example, the
+https://www.eclipse.org/aspectj/doc/released/devguide/antTasks.html[AspectJ Development
+Environment Guide]) or load-time weaving (see xref:core/aop/using-aspectj.adoc#aop-aj-ltw[Load-time Weaving with AspectJ in the Spring Framework]). The
+`AnnotationBeanConfigurerAspect` itself needs to be configured by Spring (in order to obtain
+a reference to the bean factory that is to be used to configure new objects). If you
+use Java-based configuration, you can add `@EnableSpringConfigured` to any
+`@Configuration` class, as follows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary"]
+----
+	@Configuration
+	@EnableSpringConfigured
+	public class AppConfig {
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary"]
+----
+	@Configuration
+	@EnableSpringConfigured
+	class AppConfig {
+	}
+----
+======
+
+If you prefer XML based configuration, the Spring
+xref:core/appendix/xsd-schemas.adoc#context[`context` namespace]
+defines a convenient `context:spring-configured` element, which you can use as follows:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<context:spring-configured/>
+----
+
+Instances of `@Configurable` objects created before the aspect has been configured
+result in a message being issued to the debug log and no configuration of the
+object taking place. An example might be a bean in the Spring configuration that creates
+domain objects when it is initialized by Spring. In this case, you can use the
+`depends-on` bean attribute to manually specify that the bean depends on the
+configuration aspect. The following example shows how to use the `depends-on` attribute:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<bean id="myService"
+			class="com.xyz.service.MyService"
+			depends-on="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect">
+
+		<!-- ... -->
+
+	</bean>
+----
+
+NOTE: Do not activate `@Configurable` processing through the bean configurer aspect unless you
+really mean to rely on its semantics at runtime. In particular, make sure that you do
+not use `@Configurable` on bean classes that are registered as regular Spring beans
+with the container. Doing so results in double initialization, once through the
+container and once through the aspect.
+
+
+[[aop-configurable-testing]]
+=== Unit Testing `@Configurable` Objects
+
+One of the goals of the `@Configurable` support is to enable independent unit testing
+of domain objects without the difficulties associated with hard-coded lookups.
+If `@Configurable` types have not been woven by AspectJ, the annotation has no affect
+during unit testing. You can set mock or stub property references in the object under
+test and proceed as normal. If `@Configurable` types have been woven by AspectJ,
+you can still unit test outside of the container as normal, but you see a warning
+message each time that you construct a `@Configurable` object indicating that it has
+not been configured by Spring.
+
+
+[[aop-configurable-container]]
+=== Working with Multiple Application Contexts
+
+The `AnnotationBeanConfigurerAspect` that is used to implement the `@Configurable` support
+is an AspectJ singleton aspect. The scope of a singleton aspect is the same as the scope
+of `static` members: There is one aspect instance per `ClassLoader` that defines the type.
+This means that, if you define multiple application contexts within the same `ClassLoader`
+hierarchy, you need to consider where to define the `@EnableSpringConfigured` bean and
+where to place `spring-aspects.jar` on the classpath.
+
+Consider a typical Spring web application configuration that has a shared parent application
+context that defines common business services, everything needed to support those services,
+and one child application context for each servlet (which contains definitions particular
+to that servlet). All of these contexts co-exist within the same `ClassLoader` hierarchy,
+and so the `AnnotationBeanConfigurerAspect` can hold a reference to only one of them.
+In this case, we recommend defining the `@EnableSpringConfigured` bean in the shared
+(parent) application context. This defines the services that you are likely to want to
+inject into domain objects. A consequence is that you cannot configure domain objects
+with references to beans defined in the child (servlet-specific) contexts by using the
+@Configurable mechanism (which is probably not something you want to do anyway).
+
+When deploying multiple web applications within the same container, ensure that each
+web application loads the types in `spring-aspects.jar` by using its own `ClassLoader`
+(for example, by placing `spring-aspects.jar` in `WEB-INF/lib`). If `spring-aspects.jar`
+is added only to the container-wide classpath (and hence loaded by the shared parent
+`ClassLoader`), all web applications share the same aspect instance (which is probably
+not what you want).
+
+
+
+[[aop-ajlib-other]]
+== Other Spring aspects for AspectJ
+
+In addition to the `@Configurable` aspect, `spring-aspects.jar` contains an AspectJ
+aspect that you can use to drive Spring's transaction management for types and methods
+annotated with the `@Transactional` annotation. This is primarily intended for users who
+want to use the Spring Framework's transaction support outside of the Spring container.
+
+The aspect that interprets `@Transactional` annotations is the
+`AnnotationTransactionAspect`. When you use this aspect, you must annotate the
+implementation class (or methods within that class or both), not the interface (if
+any) that the class implements. AspectJ follows Java's rule that annotations on
+interfaces are not inherited.
+
+A `@Transactional` annotation on a class specifies the default transaction semantics for
+the execution of any public operation in the class.
+
+A `@Transactional` annotation on a method within the class overrides the default
+transaction semantics given by the class annotation (if present). Methods of any
+visibility may be annotated, including private methods. Annotating non-public methods
+directly is the only way to get transaction demarcation for the execution of such methods.
+
+TIP: Since Spring Framework 4.2, `spring-aspects` provides a similar aspect that offers the
+exact same features for the standard `jakarta.transaction.Transactional` annotation. Check
+`JtaAnnotationTransactionAspect` for more details.
+
+For AspectJ programmers who want to use the Spring configuration and transaction
+management support but do not want to (or cannot) use annotations, `spring-aspects.jar`
+also contains `abstract` aspects you can extend to provide your own pointcut
+definitions. See the sources for the `AbstractBeanConfigurerAspect` and
+`AbstractTransactionAspect` aspects for more information. As an example, the following
+excerpt shows how you could write an aspect to configure all instances of objects
+defined in the domain model by using prototype bean definitions that match the
+fully qualified class names:
+
+[source,java,indent=0,subs="verbatim"]
+----
+	public aspect DomainObjectConfiguration extends AbstractBeanConfigurerAspect {
+
+		public DomainObjectConfiguration() {
+			setBeanWiringInfoResolver(new ClassNameBeanWiringInfoResolver());
+		}
+
+		// the creation of a new bean (any object in the domain model)
+		protected pointcut beanCreation(Object beanInstance) :
+			initialization(new(..)) &&
+			CommonPointcuts.inDomainModel() &&
+			this(beanInstance);
+	}
+----
+
+
+
+[[aop-aj-configure]]
+== Configuring AspectJ Aspects by Using Spring IoC
+
+When you use AspectJ aspects with Spring applications, it is natural to both want and
+expect to be able to configure such aspects with Spring. The AspectJ runtime itself is
+responsible for aspect creation, and the means of configuring the AspectJ-created
+aspects through Spring depends on the AspectJ instantiation model (the `per-xxx` clause)
+used by the aspect.
+
+The majority of AspectJ aspects are singleton aspects. Configuration of these
+aspects is easy. You can create a bean definition that references the aspect type as
+normal and include the `factory-method="aspectOf"` bean attribute. This ensures that
+Spring obtains the aspect instance by asking AspectJ for it rather than trying to create
+an instance itself. The following example shows how to use the `factory-method="aspectOf"` attribute:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<bean id="profiler" class="com.xyz.profiler.Profiler"
+			factory-method="aspectOf"> <1>
+
+		<property name="profilingStrategy" ref="jamonProfilingStrategy"/>
+	</bean>
+----
+<1> Note the `factory-method="aspectOf"` attribute
+
+
+Non-singleton aspects are harder to configure. However, it is possible to do so by
+creating prototype bean definitions and using the `@Configurable` support from
+`spring-aspects.jar` to configure the aspect instances once they have bean created by
+the AspectJ runtime.
+
+If you have some @AspectJ aspects that you want to weave with AspectJ (for example,
+using load-time weaving for domain model types) and other @AspectJ aspects that you want
+to use with Spring AOP, and these aspects are all configured in Spring, you
+need to tell the Spring AOP @AspectJ auto-proxying support which exact subset of the
+@AspectJ aspects defined in the configuration should be used for auto-proxying. You can
+do this by using one or more `<include/>` elements inside the `<aop:aspectj-autoproxy/>`
+declaration. Each `<include/>` element specifies a name pattern, and only beans with
+names matched by at least one of the patterns are used for Spring AOP auto-proxy
+configuration. The following example shows how to use `<include/>` elements:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<aop:aspectj-autoproxy>
+		<aop:include name="thisBean"/>
+		<aop:include name="thatBean"/>
+	</aop:aspectj-autoproxy>
+----
+
+NOTE: Do not be misled by the name of the `<aop:aspectj-autoproxy/>` element. Using it
+results in the creation of Spring AOP proxies. The @AspectJ style of aspect
+declaration is being used here, but the AspectJ runtime is not involved.
+
+
+
+[[aop-aj-ltw]]
+== Load-time Weaving with AspectJ in the Spring Framework
+
+Load-time weaving (LTW) refers to the process of weaving AspectJ aspects into an
+application's class files as they are being loaded into the Java virtual machine (JVM).
+The focus of this section is on configuring and using LTW in the specific context of the
+Spring Framework. This section is not a general introduction to LTW. For full details on
+the specifics of LTW and configuring LTW with only AspectJ (with Spring not being
+involved at all), see the
+https://www.eclipse.org/aspectj/doc/released/devguide/ltw.html[LTW section of the AspectJ
+Development Environment Guide].
+
+The value that the Spring Framework brings to AspectJ LTW is in enabling much
+finer-grained control over the weaving process. 'Vanilla' AspectJ LTW is effected by using
+a Java (5+) agent, which is switched on by specifying a VM argument when starting up a
+JVM. It is, thus, a JVM-wide setting, which may be fine in some situations but is often a
+little too coarse. Spring-enabled LTW lets you switch on LTW on a
+per-`ClassLoader` basis, which is more fine-grained and which can make more
+sense in a 'single-JVM-multiple-application' environment (such as is found in a typical
+application server environment).
+
+Further, xref:core/aop/using-aspectj.adoc#aop-aj-ltw-environments[in certain environments], this support enables
+load-time weaving without making any modifications to the application server's launch
+script that is needed to add `-javaagent:path/to/aspectjweaver.jar` or (as we describe
+later in this section) `-javaagent:path/to/spring-instrument.jar`. Developers configure
+the application context to enable load-time weaving instead of relying on administrators
+who typically are in charge of the deployment configuration, such as the launch script.
+
+Now that the sales pitch is over, let us first walk through a quick example of AspectJ
+LTW that uses Spring, followed by detailed specifics about elements introduced in the
+example. For a complete example, see the
+https://github.com/spring-projects/spring-petclinic[Petclinic sample application].
+
+
+[[aop-aj-ltw-first-example]]
+=== A First Example
+
+Assume that you are an application developer who has been tasked with diagnosing
+the cause of some performance problems in a system. Rather than break out a
+profiling tool, we are going to switch on a simple profiling aspect that lets us
+quickly get some performance metrics. We can then apply a finer-grained profiling
+tool to that specific area immediately afterwards.
+
+NOTE: The example presented here uses XML configuration. You can also configure and
+use @AspectJ with xref:core/beans/java.adoc[Java configuration]. Specifically, you can use the
+`@EnableLoadTimeWeaving` annotation as an alternative to `<context:load-time-weaver/>`
+(see xref:core/aop/using-aspectj.adoc#aop-aj-ltw-spring[below] for details).
+
+The following example shows the profiling aspect, which is not fancy.
+It is a time-based profiler that uses the @AspectJ-style of aspect declaration:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
+----
+	package com.xyz;
+
+	import org.aspectj.lang.ProceedingJoinPoint;
+	import org.aspectj.lang.annotation.Aspect;
+	import org.aspectj.lang.annotation.Around;
+	import org.aspectj.lang.annotation.Pointcut;
+	import org.springframework.util.StopWatch;
+	import org.springframework.core.annotation.Order;
+
+	@Aspect
+	public class ProfilingAspect {
+
+		@Around("methodsToBeProfiled()")
+		public Object profile(ProceedingJoinPoint pjp) throws Throwable {
+			StopWatch sw = new StopWatch(getClass().getSimpleName());
+			try {
+				sw.start(pjp.getSignature().getName());
+				return pjp.proceed();
+			} finally {
+				sw.stop();
+				System.out.println(sw.prettyPrint());
+			}
+		}
+
+		@Pointcut("execution(public * com.xyz..*.*(..))")
+		public void methodsToBeProfiled(){}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
+----
+	package com.xyz
+
+	import org.aspectj.lang.ProceedingJoinPoint
+	import org.aspectj.lang.annotation.Aspect
+	import org.aspectj.lang.annotation.Around
+	import org.aspectj.lang.annotation.Pointcut
+	import org.springframework.util.StopWatch
+	import org.springframework.core.annotation.Order
+
+	@Aspect
+	class ProfilingAspect {
+
+		@Around("methodsToBeProfiled()")
+		fun profile(pjp: ProceedingJoinPoint): Any? {
+			val sw = StopWatch(javaClass.simpleName)
+			try {
+				sw.start(pjp.getSignature().getName())
+				return pjp.proceed()
+			} finally {
+				sw.stop()
+				println(sw.prettyPrint())
+			}
+		}
+
+		@Pointcut("execution(public * com.xyz..*.*(..))")
+		fun methodsToBeProfiled() {
+		}
+	}
+----
+======
+
+We also need to create an `META-INF/aop.xml` file, to inform the AspectJ weaver that
+we want to weave our `ProfilingAspect` into our classes. This file convention, namely
+the presence of a file (or files) on the Java classpath called `META-INF/aop.xml` is
+standard AspectJ. The following example shows the `aop.xml` file:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "https://www.eclipse.org/aspectj/dtd/aspectj.dtd">
+	<aspectj>
+
+		<weaver>
+			<!-- only weave classes in our application-specific packages -->
+			<include within="com.xyz.*"/>
+		</weaver>
+
+		<aspects>
+			<!-- weave in just this aspect -->
+			<aspect name="com.xyz.ProfilingAspect"/>
+		</aspects>
+
+	</aspectj>
+----
+
+Now we can move on to the Spring-specific portion of the configuration. We need
+to configure a `LoadTimeWeaver` (explained later). This load-time weaver is the
+essential component responsible for weaving the aspect configuration in one or
+more `META-INF/aop.xml` files into the classes in your application. The good
+thing is that it does not require a lot of configuration (there are some more
+options that you can specify, but these are detailed later), as can be seen in
+the following example:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<?xml version="1.0" encoding="UTF-8"?>
+	<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans
+			https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/context
+			https://www.springframework.org/schema/context/spring-context.xsd">
+
+		<!-- a service object; we will be profiling its methods -->
+		<bean id="entitlementCalculationService"
+				class="com.xyz.StubEntitlementCalculationService"/>
+
+		<!-- this switches on the load-time weaving -->
+		<context:load-time-weaver/>
+	</beans>
+----
+
+Now that all the required artifacts (the aspect, the `META-INF/aop.xml`
+file, and the Spring configuration) are in place, we can create the following
+driver class with a `main(..)` method to demonstrate the LTW in action:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
+----
+	package com.xyz;
+
+	// imports
+
+	public class Main {
+
+		public static void main(String[] args) {
+			ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
+
+			EntitlementCalculationService service =
+					ctx.getBean(EntitlementCalculationService.class);
+
+			// the profiling aspect is 'woven' around this method execution
+			service.calculateEntitlement();
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
+----
+	package com.xyz
+
+	// imports
+
+	fun main() {
+		val ctx = ClassPathXmlApplicationContext("beans.xml")
+
+		val service = ctx.getBean(EntitlementCalculationService.class)
+
+		// the profiling aspect is 'woven' around this method execution
+		service.calculateEntitlement()
+	}
+----
+======
+
+We have one last thing to do. The introduction to this section did say that one could
+switch on LTW selectively on a per-`ClassLoader` basis with Spring, and this is true.
+However, for this example, we use a Java agent (supplied with Spring) to switch on LTW.
+We use the following command to run the `Main` class shown earlier:
+
+[literal,subs="verbatim"]
+----
+java -javaagent:C:/projects/xyz/lib/spring-instrument.jar com.xyz.Main
+----
+
+The `-javaagent` is a flag for specifying and enabling
+https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/package-summary.html[agents
+to instrument programs that run on the JVM]. The Spring Framework ships with such an
+agent, the `InstrumentationSavingAgent`, which is packaged in the
+`spring-instrument.jar` that was supplied as the value of the `-javaagent` argument in
+the preceding example.
+
+The output from the execution of the `Main` program looks something like the next example.
+(I have introduced a `Thread.sleep(..)` statement into the `calculateEntitlement()`
+implementation so that the profiler actually captures something other than 0
+milliseconds (the `01234` milliseconds is not an overhead introduced by the AOP).
+The following listing shows the output we got when we ran our profiler:
+
+[literal,subs="verbatim"]
+----
+Calculating entitlement
+
+StopWatch 'ProfilingAspect': running time (millis) = 1234
+------ ----- ----------------------------
+ms     %     Task name
+------ ----- ----------------------------
+01234  100%  calculateEntitlement
+----
+
+Since this LTW is effected by using full-blown AspectJ, we are not limited only to advising
+Spring beans. The following slight variation on the `Main` program yields the same
+result:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary",chomp="-packages"]
+----
+	package com.xyz;
+
+	// imports
+
+	public class Main {
+
+		public static void main(String[] args) {
+			new ClassPathXmlApplicationContext("beans.xml");
+
+			EntitlementCalculationService service =
+					new StubEntitlementCalculationService();
+
+			// the profiling aspect will be 'woven' around this method execution
+			service.calculateEntitlement();
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary",chomp="-packages"]
+----
+	package com.xyz
+
+	// imports
+
+	fun main(args: Array<String>) {
+		ClassPathXmlApplicationContext("beans.xml")
+
+		val service = StubEntitlementCalculationService()
+
+		// the profiling aspect will be 'woven' around this method execution
+		service.calculateEntitlement()
+	}
+----
+======
+
+Notice how, in the preceding program, we bootstrap the Spring container and
+then create a new instance of the `StubEntitlementCalculationService` totally outside
+the context of Spring. The profiling advice still gets woven in.
+
+Admittedly, the example is simplistic. However, the basics of the LTW support in Spring
+have all been introduced in the earlier example, and the rest of this section explains
+the "why" behind each bit of configuration and usage in detail.
+
+NOTE: The `ProfilingAspect` used in this example may be basic, but it is quite useful. It is a
+nice example of a development-time aspect that developers can use during development
+and then easily exclude from builds of the application being deployed
+into UAT or production.
+
+
+[[aop-aj-ltw-the-aspects]]
+=== Aspects
+
+The aspects that you use in LTW have to be AspectJ aspects. You can write them in
+either the AspectJ language itself, or you can write your aspects in the @AspectJ-style.
+Your aspects are then both valid AspectJ and Spring AOP aspects.
+Furthermore, the compiled aspect classes need to be available on the classpath.
+
+
+[[aop-aj-ltw-aop_dot_xml]]
+=== 'META-INF/aop.xml'
+
+The AspectJ LTW infrastructure is configured by using one or more `META-INF/aop.xml`
+files that are on the Java classpath (either directly or, more typically, in jar files).
+
+The structure and contents of this file is detailed in the LTW part of the
+https://www.eclipse.org/aspectj/doc/released/devguide/ltw-configuration.html[AspectJ reference
+documentation]. Because the `aop.xml` file is 100% AspectJ, we do not describe it further here.
+
+
+[[aop-aj-ltw-libraries]]
+=== Required libraries (JARS)
+
+At minimum, you need the following libraries to use the Spring Framework's support
+for AspectJ LTW:
+
+* `spring-aop.jar`
+* `aspectjweaver.jar`
+
+If you use the xref:core/aop/using-aspectj.adoc#aop-aj-ltw-environments-generic[Spring-provided agent to enable instrumentation]
+, you also need:
+
+* `spring-instrument.jar`
+
+
+[[aop-aj-ltw-spring]]
+=== Spring Configuration
+
+The key component in Spring's LTW support is the `LoadTimeWeaver` interface (in the
+`org.springframework.instrument.classloading` package), and the numerous implementations
+of it that ship with the Spring distribution. A `LoadTimeWeaver` is responsible for
+adding one or more `java.lang.instrument.ClassFileTransformers` to a `ClassLoader` at
+runtime, which opens the door to all manner of interesting applications, one of which
+happens to be the LTW of aspects.
+
+TIP: If you are unfamiliar with the idea of runtime class file transformation, see the
+javadoc API documentation for the `java.lang.instrument` package before continuing.
+While that documentation is not comprehensive, at least you can see the key interfaces
+and classes (for reference as you read through this section).
+
+Configuring a `LoadTimeWeaver` for a particular `ApplicationContext` can be as easy as
+adding one line. (Note that you almost certainly need to use an
+`ApplicationContext` as your Spring container -- typically, a `BeanFactory` is not
+enough because the LTW support uses `BeanFactoryPostProcessors`.)
+
+To enable the Spring Framework's LTW support, you need to configure a `LoadTimeWeaver`,
+which typically is done by using the `@EnableLoadTimeWeaving` annotation, as follows:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary"]
+----
+	@Configuration
+	@EnableLoadTimeWeaving
+	public class AppConfig {
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary"]
+----
+	@Configuration
+	@EnableLoadTimeWeaving
+	class AppConfig {
+	}
+----
+======
+
+Alternatively, if you prefer XML-based configuration, use the
+`<context:load-time-weaver/>` element. Note that the element is defined in the
+`context` namespace. The following example shows how to use `<context:load-time-weaver/>`:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<?xml version="1.0" encoding="UTF-8"?>
+	<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans
+			https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/context
+			https://www.springframework.org/schema/context/spring-context.xsd">
+
+		<context:load-time-weaver/>
+
+	</beans>
+----
+
+The preceding configuration automatically defines and registers a number of LTW-specific
+infrastructure beans, such as a `LoadTimeWeaver` and an `AspectJWeavingEnabler`, for you.
+The default `LoadTimeWeaver` is the `DefaultContextLoadTimeWeaver` class, which attempts
+to decorate an automatically detected `LoadTimeWeaver`. The exact type of `LoadTimeWeaver`
+that is "automatically detected" is dependent upon your runtime environment.
+The following table summarizes various `LoadTimeWeaver` implementations:
+
+[[aop-aj-ltw-spring-env-impls]]
+.DefaultContextLoadTimeWeaver LoadTimeWeavers
+|===
+| Runtime Environment| `LoadTimeWeaver` implementation
+
+| Running in https://tomcat.apache.org/[Apache Tomcat]
+| `TomcatLoadTimeWeaver`
+
+| Running in https://eclipse-ee4j.github.io/glassfish/[GlassFish] (limited to EAR deployments)
+| `GlassFishLoadTimeWeaver`
+
+| Running in Red Hat's https://www.jboss.org/jbossas/[JBoss AS] or https://www.wildfly.org/[WildFly]
+| `JBossLoadTimeWeaver`
+
+| JVM started with Spring `InstrumentationSavingAgent`
+  (`java -javaagent:path/to/spring-instrument.jar`)
+| `InstrumentationLoadTimeWeaver`
+
+| Fallback, expecting the underlying ClassLoader to follow common conventions
+  (namely `addTransformer` and optionally a `getThrowawayClassLoader` method)
+| `ReflectiveLoadTimeWeaver`
+|===
+
+Note that the table lists only the `LoadTimeWeavers` that are autodetected when you
+use the `DefaultContextLoadTimeWeaver`. You can specify exactly which `LoadTimeWeaver`
+implementation to use.
+
+To specify a specific `LoadTimeWeaver` with Java configuration, implement the
+`LoadTimeWeavingConfigurer` interface and override the `getLoadTimeWeaver()` method.
+The following example specifies a `ReflectiveLoadTimeWeaver`:
+
+[tabs]
+======
+Java::
++
+[source,java,indent=0,subs="verbatim",role="primary"]
+----
+	@Configuration
+	@EnableLoadTimeWeaving
+	public class AppConfig implements LoadTimeWeavingConfigurer {
+
+		@Override
+		public LoadTimeWeaver getLoadTimeWeaver() {
+			return new ReflectiveLoadTimeWeaver();
+		}
+	}
+----
+
+Kotlin::
++
+[source,kotlin,indent=0,subs="verbatim",role="secondary"]
+----
+	@Configuration
+	@EnableLoadTimeWeaving
+	class AppConfig : LoadTimeWeavingConfigurer {
+
+		override fun getLoadTimeWeaver(): LoadTimeWeaver {
+			return ReflectiveLoadTimeWeaver()
+		}
+	}
+----
+======
+
+If you use XML-based configuration, you can specify the fully qualified class name
+as the value of the `weaver-class` attribute on the `<context:load-time-weaver/>`
+element. Again, the following example specifies a `ReflectiveLoadTimeWeaver`:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<?xml version="1.0" encoding="UTF-8"?>
+	<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="
+			http://www.springframework.org/schema/beans
+			https://www.springframework.org/schema/beans/spring-beans.xsd
+			http://www.springframework.org/schema/context
+			https://www.springframework.org/schema/context/spring-context.xsd">
+
+		<context:load-time-weaver
+				weaver-class="org.springframework.instrument.classloading.ReflectiveLoadTimeWeaver"/>
+
+	</beans>
+----
+
+The `LoadTimeWeaver` that is defined and registered by the configuration can be later
+retrieved from the Spring container by using the well known name, `loadTimeWeaver`.
+Remember that the `LoadTimeWeaver` exists only as a mechanism for Spring's LTW
+infrastructure to add one or more `ClassFileTransformers`. The actual
+`ClassFileTransformer` that does the LTW is the `ClassPreProcessorAgentAdapter` (from
+the `org.aspectj.weaver.loadtime` package) class. See the class-level javadoc of the
+`ClassPreProcessorAgentAdapter` class for further details, because the specifics of how
+the weaving is actually effected is beyond the scope of this document.
+
+There is one final attribute of the configuration left to discuss: the `aspectjWeaving`
+attribute (or `aspectj-weaving` if you use XML). This attribute controls whether LTW
+is enabled or not. It accepts one of three possible values, with the default value being
+`autodetect` if the attribute is not present. The following table summarizes the three
+possible values:
+
+[[aop-aj-ltw-ltw-tag-attrs]]
+.AspectJ weaving attribute values
+|===
+| Annotation Value| XML Value| Explanation
+
+| `ENABLED`
+| `on`
+| AspectJ weaving is on, and aspects are woven at load-time as appropriate.
+
+| `DISABLED`
+| `off`
+| LTW is off. No aspect is woven at load-time.
+
+| `AUTODETECT`
+| `autodetect`
+| If the Spring LTW infrastructure can find at least one `META-INF/aop.xml` file,
+  then AspectJ weaving is on. Otherwise, it is off. This is the default value.
+|===
+
+
+[[aop-aj-ltw-environments]]
+=== Environment-specific Configuration
+
+This last section contains any additional settings and configuration that you need
+when you use Spring's LTW support in environments such as application servers and web
+containers.
+
+[[aop-aj-ltw-environments-tomcat-jboss-etc]]
+==== Tomcat, JBoss, WildFly
+
+Tomcat and JBoss/WildFly provide a general app `ClassLoader` that is capable of local
+instrumentation. Spring's native LTW may leverage those ClassLoader implementations
+to provide AspectJ weaving.
+You can simply enable load-time weaving, as xref:core/aop/using-aspectj.adoc[described earlier].
+Specifically, you do not need to modify the JVM launch script to add
+`-javaagent:path/to/spring-instrument.jar`.
+
+Note that on JBoss, you may need to disable the app server scanning to prevent it from
+loading the classes before the application actually starts. A quick workaround is to add
+to your artifact a file named `WEB-INF/jboss-scanning.xml` with the following content:
+
+[source,xml,indent=0,subs="verbatim"]
+----
+	<scanning xmlns="urn:jboss:scanning:1.0"/>
+----
+
+[[aop-aj-ltw-environments-generic]]
+==== Generic Java Applications
+
+When class instrumentation is required in environments that are not supported by
+specific `LoadTimeWeaver` implementations, a JVM agent is the general solution.
+For such cases, Spring provides `InstrumentationLoadTimeWeaver` which requires a
+Spring-specific (but very general) JVM agent, `spring-instrument.jar`, autodetected
+by common `@EnableLoadTimeWeaving` and `<context:load-time-weaver/>` setups.
+
+To use it, you must start the virtual machine with the Spring agent by supplying
+the following JVM options:
+
+[literal]
+[subs="verbatim"]
+----
+-javaagent:/path/to/spring-instrument.jar
+----
+
+Note that this requires modification of the JVM launch script, which may prevent you
+from using this in application server environments (depending on your server and your
+operation policies). That said, for one-app-per-JVM deployments such as standalone
+Spring Boot applications, you typically control the entire JVM setup in any case.
+
+
+
+